ContentBuildingReader.cpp

#include <iostream>
#include <fstream>
#include <string>

#include "common.h"
#include "BuildingConfiguration.h"
#include "BlockCondition.h"
#include "tinyxml.h"
#include "GUI.h"
#include "ContentLoader.h"

int parseConditionNode(ConditionalNode* node, TiXmlElement* elemCondition, bool silent);
bool parseSpriteNode(SpriteNode* node, TiXmlElement* elemParent);
bool includeFile(SpriteNode* node, TiXmlElement* includeNode, SpriteBlock* &oldSibling);

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();
	BlockCondition* cond = NULL;	
	if( strcmp(strType, "NeighbourWall") == 0){
		cond = new NeighbourWallCondition( elemCondition->Attribute("dir") );
	}

	else if( strcmp(strType, "PositionIndex") == 0){
		cond = new PositionIndexCondition( elemCondition->Attribute("value") );
	} 

	else if( strcmp(strType, "MaterialType") == 0){
		cond = new MaterialTypeCondition( elemCondition->Attribute("value") , elemCondition->Attribute("subtype"));
	}   

	else if( strcmp(strType, "always") == 0){
		cond = new AlwaysCondition();
	} 

	else if( strcmp(strType, "never") == 0){
		cond = new NeverCondition();
	}     

	else if( strcmp(strType, "BuildingOccupancy") == 0){
		cond = new BuildingOccupancyCondition( elemCondition->Attribute("value") );
	} 

	else if( strcmp(strType, "NeighbourSameBuilding") == 0){
		cond = new NeighbourSameBuildingCondition( elemCondition->Attribute("dir") );
	}     

	else if( strcmp(strType, "NeighbourSameType") == 0){
		cond = new NeighbourSameTypeCondition( elemCondition->Attribute("dir") );
	}

	else if( strcmp(strType, "NeighbourOfType") == 0){
		cond = new NeighbourOfTypeCondition( elemCondition->Attribute("dir") , elemCondition->Attribute("value") );
	}

	else if( strcmp(strType, "NeighbourIdentical") == 0){
		cond = new NeighbourIdenticalCondition( elemCondition->Attribute("dir") );
	}     

	else if( strcmp(strType, "AnimationFrame") == 0){
		cond = new AnimationFrameCondition( elemCondition->Attribute("value") );
	}  

	else if( strcmp(strType, "FluidBelow") == 0){
		cond = new FluidBelowCondition( elemCondition->Attribute("value") );
	}  

	else if( strcmp(strType, "HaveFloor") == 0){
		cond = new HaveFloorCondition();
	}

	else if( strcmp(strType, "and") == 0){
		AndConditionalNode* andNode = new AndConditionalNode();
		cond = andNode;
		if (!parseRecursiveNodes(andNode, elemCondition))
		{
			delete(andNode);
			return 0;
		}
	}

	else if( strcmp(strType, "or") == 0){
		OrConditionalNode* orNode = new OrConditionalNode();
		cond = orNode;
		if (!parseRecursiveNodes(orNode, elemCondition))
		{
			delete(orNode);
			return 0;
		}
	}

	else if( strcmp(strType, "not") == 0){
		NotConditionalNode* notNode = new NotConditionalNode();
		cond = notNode;
		if (!parseRecursiveNodes(notNode, elemCondition))
		{
			delete(notNode);
			return 0;
		}
	}

	if (cond != NULL)
	{ 
		if (!node->addCondition( cond ))
		{
			contentError("Unable to add subcondition",elemCondition);
			delete(cond);
			return 0;
		}
		return 1;
	}
	else if (!silent)
	{
		contentError("Misplaced or invalid element in Condition",elemCondition);
		return 0;
	}
	return -1;
}

inline bool readNode(SpriteNode* node, TiXmlElement* elemNode, TiXmlElement* elemParent, SpriteBlock* &oldSibling)
{
	const char* strType = elemNode->Value();
	if (strcmp(strType, "if") == 0 || strcmp(strType, "else") == 0)
	{
		SpriteBlock* block = new SpriteBlock();
		if (!elemNode->Attribute("file") && elemParent->Attribute("file"))
		{
			elemNode->SetAttribute("file", elemParent->Attribute("file"));
		}
		if (!parseSpriteNode(block,elemNode))
		{
			delete(block);
			return false;
		}
		if (elemNode->Attribute("else") || strcmp(strType, "else") == 0)
		{
			if (!oldSibling)
			{
				contentError("Misplaced or invalid element in SpriteNode",elemNode);
				return false;
			}
			oldSibling->addElse(block);	
		}
		else
		{
			node->addChild(block);
		}
		oldSibling = block;
	}
	else if (strcmp(strType, "rotate") == 0)
	{
		RotationBlock* block = new RotationBlock();
		if (!elemNode->Attribute("file") && elemParent->Attribute("file"))
		{
			elemNode->SetAttribute("file",elemParent->Attribute("file"));
		}
		if (!parseSpriteNode(block,elemNode))
		{
			delete(block);
			return false;
		}
		else
		{
			node->addChild(block);
		}
		oldSibling = NULL;
	}
	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;
		}
		SpriteElement* sprite = new SpriteElement();
		sprite->sprite.set_by_xml(elemNode, fileindex);
		node->addChild(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, SpriteBlock* &oldSibling)
{
    // get path... ugly
    char configfilepath[FILENAME_BUFFERSIZE] = {0};
    const char* documentRef = getDocument(includeNode);

    if (!getLocalFilename(configfilepath,includeNode->Attribute("file"),documentRef))
    {
        return false;
    }
    ALLEGRO_PATH * incpath = al_create_path(configfilepath);
    al_append_path_component(incpath, "include");
    TiXmlDocument doc( al_path_cstr(incpath, ALLEGRO_NATIVE_PATH_SEP) );
    al_destroy_path(incpath);
	bool loadOkay = doc.LoadFile();
	TiXmlHandle hDoc(&doc);
	TiXmlElement* elemParent;
	if(!loadOkay)
	{
		contentError("Include failed",includeNode);
        WriteErr("File load failed: %s\n",configfilepath);
		WriteErr("Line %d: %s\n",doc.ErrorRow(),doc.ErrorDesc());
		return false;
	}
	elemParent = hDoc.FirstChildElement("include").Element();
	if( elemParent == NULL)
	{
		contentError("Main <include> node not present",&doc);
		return false;
	}
	TiXmlElement* elemNode =  elemParent->FirstChildElement();
	if (elemNode == NULL)
	{
		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.
	SpriteBlock* oldSibling = NULL;
	TiXmlElement* elemNode =  elemParent->FirstChildElement();
	const char* strParent = elemParent->Value();
	if (elemNode == NULL)
	{
		contentError("Empty SpriteNode Element",elemParent);
		return false;		
	}
	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 spriteblocks
		// should get here
		int retvalue =parseConditionNode((SpriteBlock *)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,  vector<BuildingConfiguration>* knownBuildings ){
    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 == NULL || strGameID == NULL || strName[0] == 0 || strGameID[0] == 0)
    {
        contentError("<building> node must have name and game_type attributes",elemRoot);
        return false;
    }
    building_type::building_type main_type = (building_type::building_type) INVALID_INDEX;
    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 == (building_type::building_type) INVALID_INDEX)
    {
        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)
            {
                contentError("<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 == furnace_type::Custom)
                needs_custom = true;
            break;
        }
        case building_type::Construction:
        {
            if(!strGameSub)
            {
                contentError("<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)
            {
                contentError("<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)
            {
                contentError("<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)
            {
                contentError("<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 == workshop_type::Custom)
                needs_custom = true;
            break;
        }
        default:
        {
            // we need no sub/custom type.
            break;
        }
    }
    string custom;
    // needs custom building spec, doesn't have a string... FAIL
    if (needs_custom && !strGameCustom)
    {
        contentError("<building> game_custom attribute is required, but missng.",elemRoot);
        return false;
    }
    else if (strGameCustom)
    {
        custom = strGameCustom;
    }
    BuildingConfiguration building(strName, main_type, subtype, custom );
    RootBlock* spriteroot = new RootBlock();
    building.sprites = spriteroot;
    if (!parseSpriteNode(spriteroot,elemRoot))
    {
        delete(spriteroot);
        contentError("<building> Failed while parsing sprite node",elemRoot);
        return false;
    }

    //add a copy of 'building' to known buildings
    knownBuildings->push_back( building );
    return true;
}

void flushBuildingConfig( vector<BuildingConfiguration>* knownBuildings )
{
	// clean up building data trees before deleting them
	// a nasty cludge that only works cause knownbuildings
	// isnt modified anywhere else
	// TODO: look into smart pointers or something
	uint32_t numBuildings = (uint32_t)knownBuildings->size();
	for(uint32_t i = 0; i < numBuildings; i++)
	{
		delete(knownBuildings->at(i).sprites);
		//should set to null, but we will nuke the lot in a second
	}
	knownBuildings->clear();
}



/*
bool LoadBuildingConfiguration( vector<BuildingConfiguration>* knownBuildings ){
  string line;
  ifstream myfile ("buildings/index.txt");
  if (myfile.is_open() == false){
    WriteErr("Unable to load building config index file!\n");
    return false;
  }


  //img files are now unused
  flushImgFiles();
  
  while ( !myfile.eof() )
  {
    char filepath[50] = {0};
    getline (myfile,line);
    
    //some systems don't remove the \r char as a part of the line change:
    if(line.size() > 0 &&  line[line.size() -1 ] == '\r' )
      line.resize(line.size() -1);

    if(line.size() > 0){
      sprintf(filepath, "buildings/%s", line.c_str() );
      WriteErr("Reading %s...\t\t", filepath);
      bool result = addSingleConfig( filepath, knownBuildings );
      if (result)
      	WriteErr("ok\n");
      else
        WriteErr("Unable to load building config %s\n(Will ignore building and continue)\n", filepath);
    }
  }
  myfile.close();

  BuildingNamesTranslatedFromGame = false;

  return true;
}

*/