/**
******************************************************************************

  @file /common/rm/rmadvxml.cpp
  @brief RM pristupujici k jednotkam,budovam apod. objektum
  
  @author Vta
  @version 1.0

******************************************************************************/
#include "common/rm/rmadvxml.h"
#include "common/utils.h"
#include "common/rm/rmtxti.h"
#include "common/rm/rmmodeli.h"
#include "common/rm/rmsoundi.h"
#include "common/rm/rmsymboli.h"
#include "world/init.h"

using namespace World;

namespace rm
{

void TRM_advxml::requestDep(int id)
{
  this->lock();
  this->request(id);
  this->unlock();
  DA<int> ids;
  TRM_model_i * RMmodeli=(TRM_model_i *)KSendMessage(RQUEUE,MSG_GET_RM_MODEL_I,MOD_RM,MOD_RM,NULL);
  TRM_sound_i * RMsoundi=(TRM_sound_i *)KSendMessage(RQUEUE,MSG_GET_RM_SOUND_I,MOD_RM,MOD_RM,NULL);
  TRM_symbol_i * RMsymboli=(TRM_symbol_i *)KSendMessage(RQUEUE,MSG_GET_RM_SYMBOL_I,MOD_RM,MOD_RM,NULL);
  TRM_raster_i * RMrasti=(TRM_raster_i *)KSendMessage(RQUEUE,MSG_GET_RM_RASTER_I,MOD_RM,MOD_RM,NULL);
  int sndid;
  int rq;
  if (type==RM_UNIT)
  {
    if ((rq=this->index->getDataInt("unit",id,"model",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i There is damaged information about the unit having id %i",this->type,id);
      THROW(E_8K_RM,"RMAdvXML There is damaged information about a unit"); 
    }
    RMmodeli->request(rq);
    if ((rq=this->index->getDataInt("unit",id,"symbol",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i There is damaged information about the unit having id %i",this->type,id);
      THROW(E_8K_RM,"RMAdvXML There is damaged information about a unit"); 
    }
    RMsymboli->requestDep(rq);
    this->index->getListOfIds(&ids,"unit",id,"sounds",0,NULL);
    int i;
    for (i=ids.getNext(-1);i!=-1;i=ids.getNext(i))
    {
      sndid=this->index->getDataInt("unit",id,"sounds",0,"action",i,NULL);
      RMsoundi->request(sndid);
    }
  }
  else if (this->type==RM_BUILDING)
  {
    if ((rq=this->index->getDataInt("building",id,"model",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i There is damaged information about the building having id %i",this->type,id);
      THROW(E_8K_RM,"RMAdvXML There is damaged information about a building"); 
    }
    RMmodeli->request(rq);
    if ((rq=this->index->getDataInt("building",id,"construction_model",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i There is damaged information about the building having id %i",this->type,id);
      THROW(E_8K_RM,"RMAdvXML There is damaged information about a building"); 
    }
    RMmodeli->request(rq);
    if ((rq=this->index->getDataInt("building",id,"symbol",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i There is damaged information about the building having id %i",this->type,id);
      THROW(E_8K_RM,"RMAdvXML There is damaged information about a building"); 
    }
    RMsymboli->requestDep(rq);
    this->index->getListOfIds(&ids,"building",id,"sounds",0,NULL);
    int i;
    for (i=ids.getNext(-1);i!=-1;i=ids.getNext(i))
    {
      sndid=this->index->getDataInt("building",id,"sounds",0,"action",i,NULL);
      RMsoundi->request(sndid);
    }
  }
  else if (this->type==RM_BONUS)
  {
    if ((rq=this->index->getDataInt("bonus",id,"raster",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i There is damaged information about the bonus having id %i",this->type,id);
      THROW(E_8K_RM,"RMAdvXML There is damaged information about a bonus"); 
    }
    RMrasti->request(rq);
  }
  delete(RMmodeli);
  delete(RMsoundi);
  delete(RMsymboli);
  delete(RMrasti);
}

static char bu_path[K8_MAX_PATH_LEN];
void TRM_advxml::loadData(int id)
{
  this->lock();
  if ((*(this->data))[id]==NULL)
  {

// zjistim, ktery file se ma nacitat

    try
    {
      this->getFileOf(id,bu_path,K8_MAX_PATH_LEN);
    }
    catch (E_8K_RM)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i The file of object having id %i can not be found",this->type,id);
      THROW(E_8K_RM,"V RMAdvXML can not find the path to requested object"); 
    }

// jednotku/budovu nactu xml

    TXMLdata xml;
    int retvalue=xml.readFile(bu_path);
    if (retvalue!=XML_ERROR_OK)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i The object having id %i located in %s can not be loaded",this->type,id,bu_path);
      THROW(E_8K_RM,"RMAdvXML can not load requested object"); 
    }

// prevedu jednotku do struktury 
    if (this->type==RM_UNIT)
    {
      (*(this->data))[id]=(struct UNIT *) KMemAlloc(sizeof(struct UNIT));
      UNIT * u=(UNIT *)(*(this->data))[id];
      UNIT_Init(u);
      u->id=id; // jelikoz v souboru jednotky neni id, pridam rucne
      if (
        ((u->modelid=this->index->getDataInt("unit",u->id,"model",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH) ||
        ((u->nameid=this->index->getDataInt("unit",u->id,"name",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH) ||
        ((u->symbolid=this->index->getDataInt("unit",u->id,"symbol",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
        )
      {
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i Unit %i can not be loaded",this->type,u->id);
        THROW(E_8K_RM,"RMAdvXML can not read a unit"); 
      }
      // zvuky
      int i;
      for (i=0;i!=MAX_ACTION_SOUNDS;i++)
      {
        u->soundsid[i]=this->index->getDataInt("unit",u->id,"sounds",0,"action",i,NULL);
        if (u->soundsid[i]==-1)
          u->soundsid[i]=0;
      }
      this->XMLtoUnit((UNIT*)(*(this->data))[id],&xml); // prevedu do pameti
    }
    else if (this->type==RM_BUILDING) // prevedu budovu
    {
      (*(this->data))[id]=(struct BUILDING *) KMemAlloc(sizeof(struct BUILDING));
      BUILDING * b=(BUILDING *)(*(this->data))[id];
      BUILDING_Init(b);
      b->id=id; // jelikoz v souboru budovy neni id, pridam rucne

      if (
        ((b->modelid=this->index->getDataInt("building",b->id,"model",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH) ||
        ((b->construction_modelid=this->index->getDataInt("building",b->id,"construction_model",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH) ||
        ((b->nameid=this->index->getDataInt("building",b->id,"name",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH) ||
        ((b->symbolid=this->index->getDataInt("building",b->id,"symbol",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
        )
      {
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i building having id %i can not be loaded",this->type,b->id);
        THROW(E_8K_RM,"RMAdvXML can not read a building"); 
      }
      // zvuky
      int i;
      for (i=0;i!=MAX_ACTION_SOUNDS;i++)
      {
        b->soundsid[i]=this->index->getDataInt("building",b->id,"sounds",0,"action",i,NULL);
        if (b->soundsid[i]==-1)
          b->soundsid[i]=0;
      }
      this->XMLtoBuilding((BUILDING*)(*(this->data))[id],&xml); // prevedu do pameti
    }
    else if (this->type==RM_BONUS) // prevedu budovu
    {
      (*(this->data))[id]=(struct UNIT_PROPERTY_BONUS *) KMemAlloc(sizeof(struct UNIT_PROPERTY_BONUS));
      UNIT_PROPERTY_BONUS * b=(UNIT_PROPERTY_BONUS *)(*(this->data))[id];

      // inicializace implicitnimi (nulovymi) hodnotami
      UNIT_PROPERTY_BONUS_Init(b);

      b->id=id; // jelikoz v souboru budovy neni id, pridam rucne
      if (
          ((b->nameid=this->index->getDataInt("bonus",b->id,"name",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH) ||
          ((b->imageid=this->index->getDataInt("bonus",b->id,"raster",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)           
         )
      {
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i bonus having id %i can not be loaded",this->type,b->id);
        THROW(E_8K_RM,"V RMAdvXML nelze nacist bonus"); 
      }
      this->XMLtoBonus((UNIT_PROPERTY_BONUS*)(*(this->data))[id],&xml); // prevedu do pameti
    }
  }
  this->unlock();

}

void TRM_advxml::get(void ** data,int id)
{
  this->lock();
  this->loadData(id); // zjistim, jestli je nacteno
  *data = (*(this->data))[id]; // vratim
  this->unlock();
}

void TRM_advxml::getAll(DA<void *> ** all)
{
  this->lock();
  GLOBALLOGID(PRIORITY_DATA_WERE_TAKEN, "RMadvxml type %i getAll() was called",this->type);
  (*all)=this->data;
//  this->data=NULL;
  this->unlock();
}

void TRM_advxml::getIds(DA<int> * ids)
{
  this->index->getListOfIds(ids,0,0,NULL);
}

void TRM_advxml::freeData(int id)
{
  this->lock();

  if ((*(this->data))[id]!=NULL)
  {
    KMemFree((*(this->data))[id]);
    (*(this->data))[id]=NULL;
  }
  else
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i unit having id %i can not be removed because it was not loaded before",this->type,id);
    THROW(E_8K_RM,"RMAdvXML can not release unit"); 
  }
  this->unlock();
}

static char bu_data[K8_MAX_FILE_NAME_LEN];
void TRM_advxml::getFileOf(int id,char * path,int pathsize)
{
  int retvalue=XML_ERROR_NO_SUCH_A_PATH; // pouze inicialace

  if (this->type==RM_UNIT)
    retvalue=this->index->getData(bu_data,K8_MAX_FILE_NAME_LEN,"unit",id,"file",0,NULL); // zjistim jmeno souboru
  else if (this->type==RM_BUILDING)
    retvalue=this->index->getData(bu_data,K8_MAX_FILE_NAME_LEN,"building",id,"file",0,NULL); // zjistim jmeno souboru
  else if (this->type==RM_BONUS)
    retvalue=this->index->getData(bu_data,K8_MAX_FILE_NAME_LEN,"bonus",id,"file",0,NULL); // zjistim jmeno souboru

  if (retvalue==XML_ERROR_NO_SUCH_A_PATH)
  {

    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i there is missing data about object having id %i",this->type,id);
    THROW(E_8K_RM,"V RMAdvXML neni zaznam o pozadovaneho objektu"); 
  }
 
  if (this->type==RM_UNIT)
    strpartpath(path,RESOURCES_DIR,this->rmconfi->getPack(),UNITS_DIR,bu_data,pathsize,".xml");
  else if (this->type==RM_BUILDING)
    strpartpath(path,RESOURCES_DIR,this->rmconfi->getPack(),BUILDINGS_DIR,bu_data,pathsize,".xml");
  else if (this->type==RM_BONUS)
    strpartpath(path,RESOURCES_DIR,this->rmconfi->getPack(),BONUSES_DIR,bu_data,pathsize,".xml");

}


static char bu_path2[K8_MAX_PATH_LEN];
void TRM_advxml::modify(void * data_i)
{
  this->lock();
  int newid=-1;
  TXMLdata xml;
  if (this->type==RM_UNIT)
  {
    UNIT * unit2=(UNIT*) data_i;
    if ((*(this->data))[unit2->id]!=NULL)
    {
      (*(this->data))[unit2->id]=data_i; // modifikuji

      this->unitToXML(&xml,unit2); // vytvorim xml, ktere budu zapisovat

      newid=unit2->id;
    }
    else 
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i unable to modify non existing unit (id=%i)",this->type,unit2->id);
      THROW(E_8K_RM,"RMAdvXML can not modify non-existing unit"); 
    }
  }
  else if (this->type==RM_BUILDING)
  {
    BUILDING * data2=(BUILDING*) data_i;
    if ((*(this->data))[data2->id]!=NULL)
    {
      (*(this->data))[data2->id]=data_i; // modifikuji

      this->buildingToXML(&xml,data2); // vytvorim xml, ktere budu zapisovat
      newid=data2->id;
    }
    else 
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i unable to modify non existing building (id=%i)",this->type,data2->id);
      THROW(E_8K_RM,"RMAdvXML can not modify non-existing building"); 
    }
  }
  else if (this->type==RM_BONUS)
  {
    UNIT_PROPERTY_BONUS * data2=(UNIT_PROPERTY_BONUS*) data_i;
    if ((*(this->data))[data2->id]!=NULL)
    {
      (*(this->data))[data2->id]=data_i; // modifikuji

      this->bonusToXML(&xml,data2); // vytvorim xml, ktere budu zapisovat
      newid=data2->id;
    }
    else 
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i unable to modify non existing bonus (id=%i)",this->type,data2->id);
      THROW(E_8K_RM,"RMAdvXML can not modify non-existing bonus"); 
    }
  }


// zapsani do souboru
  try
  {
    this->getFileOf(newid,bu_path2,K8_MAX_PATH_LEN); // tady v tom se to jeste lisi
  }
  catch (E_8K_RM)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not find the path where to store the object having id %i",this->type,newid);
    THROW(E_8K_RM,"RMAdvXML can not save modified data to file"); 
  }
  int res=xml.saveToFile(bu_path2); // zapisu do souboru
  if (res!=XML_ERROR_OK)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i the file %s can not be written",this->type,bu_path2);
    THROW(E_8K_RM,"RMAdvXML can not save modified data to file"); 
  }

  this->unlock();
}

int TRM_advxml::getMaxId()
{
  this->lock();

  int maxindex;
  if (this->data->getMaxId()>this->index->getMaxId())
    maxindex=this->data->getMaxId();
  else
    maxindex=this->index->getMaxId(); // mela by byt aktivni jen tato vetev, v souboru je toho vic
  this->unlock();
  return maxindex;
}

int TRM_advxml::addDep(void * data_i,int startiddata_i,char * unitfile,char * name,int startid)
{
  TRM_txt_i * RMtxti=(TRM_txt_i *)KSendMessage(RQUEUE,MSG_GET_RM_TXT_I,MOD_RM,MOD_RM,NULL);
  UNIT * data2 = (UNIT *) data_i;
  data2->nameid=RMtxti->addString(name,data2->nameid,startid);
  delete(RMtxti);
  int ret=this->add(data_i,startiddata_i,unitfile);
  return ret;
}

static char bu_path3[K8_MAX_PATH_LEN];
int TRM_advxml::add(void * data_i,int startid,char * file)
//!//
{
  this->lock();
  int maxindex;
  TXMLdata xml(1,1);
  int newid=-1;
  UNIT * unit2;
  BUILDING * building2;
  UNIT_PROPERTY_BONUS * bonus2;

  if (this->type==RM_UNIT)
  {
    unit2=(UNIT *) data_i;
    newid=unit2->id;
  }
  else if (this->type==RM_BUILDING)
  {
    building2=(BUILDING *) data_i; 
    newid=building2->id;
  }
  else if (this->type==RM_BONUS)
  {
    bonus2=(UNIT_PROPERTY_BONUS *) data_i; 
    newid=bonus2->id;
  }

  if (newid==-1)
  {
    // vezmu prvni volny - tj. max (id_ze_souboru,id_v_pameti) pro pripad, ze uz je neco ulozeno
    maxindex=this->getMaxId();
    maxindex++;
    if (startid<1)
      startid=1;
    int i;
    for (i=startid;i<maxindex;i++) // kdyztak to skonci u maxindex (tj. tedka uz volny na 100%) 
    {
      // aby nebylo nic v souboru ani nacteno - nic se neprepsalo
      if (this->type==RM_UNIT)
      {
        if ((this->index->getData(NULL,0,"unit",i,"file",0,NULL)==XML_ERROR_NO_SUCH_A_PATH ) && ((*(this->data))[i]==NULL) )
        {
          break;
        }
      }
      else if (this->type==RM_BUILDING)
        if ((this->index->getData(NULL,0,"building",i,"file",0,NULL)==XML_ERROR_NO_SUCH_A_PATH ) && ((*(this->data))[i]==NULL) )
        {
          break;
        }
      else if (this->type==RM_BONUS)
        if ((this->index->getData(NULL,0,"bonus",i,"file",0,NULL)==XML_ERROR_NO_SUCH_A_PATH ) && ((*(this->data))[i]==NULL) )
        {
          break;
        }
    }
    maxindex=i; // vezmu prvni volnou hodnotu
  }
  else
  {
    if (this->type==RM_UNIT)
    {
      maxindex=unit2->id;
    }
    else if (this->type==RM_BUILDING)
    {
      maxindex=building2->id;
    }
    else if (this->type==RM_BONUS)
    {
      maxindex=bonus2->id;
    }
  }
  if (maxindex<1)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i object having id %i < 1 can not be added",this->type,maxindex);
    THROW(E_8K_RM,"RMAdvXML can not add object having id less than 1"); 
  }

  if (this->type==RM_UNIT)
  {
  // priradim id - tj. i pro pripad modifikace
    unit2->id=maxindex;
    (*(this->data))[maxindex]=(void*)KMemAlloc(sizeof(UNIT));
    UNIT * unit3 = (UNIT *) (*(this->data))[maxindex];
    
  // inicializace implicitnimi (nulovymi) hodnotami  
    UNIT_Init(unit3);

  // predvod jednotky RM

    unit3->id=unit2->id; // navic jeste id
    if (unit2->nameid<1)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not add a unit addressing non-existing name",this->type);
      THROW(E_8K_RM,"RMAdvXML can not add a unit addressing non-existing name"); 
    }
    unit3->nameid=unit2->nameid; // id retezce jmena
    if (unit2->modelid<1)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not add a unit addressing non-existing model",this->type);
      THROW(E_8K_RM,"RMAdvXML can not add a unit addressing non-existing name"); 
    }
    unit3->modelid=unit2->modelid; // id modelu

  // zapis do indexu

    this->index->setData(file,"unit",unit2->id,"file",0,NULL); // pridam do indexu zaznam o jednoce 
    this->index->setDataInt(unit2->nameid,"unit",unit2->id,"name",0,NULL); // zapisu jmeno, aby bylo jasne z xml o kterou jednotku jde (zavislosit do indexu)
    this->index->setDataInt(unit2->modelid,"unit",unit2->id,"model",0,NULL); // zapisu prislusny model
    this->index->setDataInt(unit2->symbolid,"unit",unit2->id,"symbol",0,NULL); // zapisu prislusny model

  // zapis do vlasniho souboru jednotky

    this->unitToXML(&xml,unit2);
    newid=unit2->id; // ktere se bude doopravdy pridavat  
  }
  else if (this->type==RM_BUILDING)
  {
    building2->id=maxindex;
    (*(this->data))[maxindex]=(void*)KMemAlloc(sizeof(BUILDING));
    BUILDING * building3 = (BUILDING *) (*(this->data))[maxindex];
  // predvod budovy RM

    building3->id=building2->id; // navic jeste id
    if (building2->nameid<1)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not add a building addressing non-existing name",this->type);
      THROW(E_8K_RM,"RMAdvXML type %i can not add a building addressing non-existing name"); 
    }
    building3->nameid=building2->nameid; // id retezce jmena
    if (building2->modelid<1)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not add a building addressing non-existing model.",this->type);
      THROW(E_8K_RM,"V RMAdvXML nelze pridat budovu odkazujici na jiste neexistujici model"); 
    }
    building3->modelid=building2->modelid; // id modelu

  // zapis do indexu

    this->index->setData(file,"building",building2->id,"file",0,NULL); // pridam do indexu zaznam o budove 
    this->index->setDataInt(building2->nameid,"building",building2->id,"name",0,NULL); // zapisu jmeno, aby bylo jasne z xml o kterou budovu jde (zavislosit do indexu)
    this->index->setDataInt(building2->modelid,"building",building2->id,"model",0,NULL); // zapisu prislusny model
    this->index->setDataInt(building2->construction_modelid,"building",building2->id,"construction_modelid",0,NULL); // zapisu prislusny model rozestavene budovy   
    this->index->setDataInt(building2->symbolid,"building",building2->id,"symbol",0,NULL); // zapisu prislusny model rozestavene budovy   

  // zapis do vlasniho souboru budovy

    this->buildingToXML(&xml,building2);
    newid=building2->id; // ktere se bude doopravdy pridavat  
  }
  else if (this->type==RM_BONUS)
  {
    bonus2->id=maxindex;
    (*(this->data))[maxindex]=(void*)KMemAlloc(sizeof(UNIT_PROPERTY_BONUS));
    UNIT_PROPERTY_BONUS * bonus3 = (UNIT_PROPERTY_BONUS *) (*(this->data))[maxindex];
  
  // inicializace implicitnimi (nulovymi) hodnotami
    UNIT_PROPERTY_BONUS_Init(bonus3);

  // predvod budovy RM

    bonus3->id=bonus2->id; // navic jeste id
    if (bonus2->nameid<1)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not add a bonus addressing non-existing name",this->type);
      THROW(E_8K_RM,"RMAdvXML can not add a bonus addressing non-existing name"); 
    }
    bonus3->nameid=bonus2->nameid; // id retezce jmena
    if (bonus2->imageid<1)
    {
      this->unlock();
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not add a bonus addressing non-existing raster",this->type);
      THROW(E_8K_RM,"RMAdvXML can not add a bonus addressing non-existing name"); 
    }
    bonus3->imageid=bonus2->imageid; // id rasteru

  // zapis do indexu

    this->index->setData(file,"bonus",bonus2->id,"file",0,NULL); // pridam do indexu 
    this->index->setDataInt(bonus2->nameid,"bonus",bonus2->nameid,"name",0,NULL); // zapisu jmeno, aby bylo jasne z xml o ktere kouzlo jde (zavislosit do indexu)
    this->index->setDataInt(bonus2->imageid,"bonus",bonus2->imageid,"raster",0,NULL); // zapisu prislusny model

  // zapis do vlasniho souboru budovy

    this->bonusToXML(&xml,bonus2);
    newid=bonus2->id; // ktere se bude doopravdy pridavat  
  }
// nalezeni mista kam se bude zapisovat

  try
  {
    this->getFileOf(newid,bu_path3,K8_MAX_PATH_LEN);
  }
  catch (E_8K_RM)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not find the path to object having id %i",this->type,newid);
    THROW(E_8K_RM,"RMAdvXML can not the find path to object"); 
  }

  int res=xml.saveToFile(bu_path3); // zapsani objektu na disk
  if (res!=XML_ERROR_OK)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not write to the file %s",this->type,bu_path2);
    THROW(E_8K_RM,"RMAdvXML can not write to a file"); 
  }

  // zapsani indexu
  if (type==RM_UNIT)
    res=this->saveToFile(this->rmconfi->getPack(),this->rmconfi->getUnitFile());// zapisi ji take do units.xml aby byla v seznamu
  else if (this->type==RM_BUILDING)
    res=this->saveToFile(this->rmconfi->getPack(),this->rmconfi->getBuildingFile());// zapisi ji take do units.xml aby byla v seznamu
  else if (this->type==RM_BONUS)
    res=this->saveToFile(this->rmconfi->getPack(),this->rmconfi->getBonusFile());// zapisi ji take do units.xml aby byla v seznamu

  if (res!=XML_ERROR_OK)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not write to index file",this->type);
    THROW(E_8K_RM,"RMAdvXML can not write to index file"); 
  }

  this->unlock();
  return maxindex;
}

void TRM_advxml::unitToXML(TXMLdata * xml,UNIT* unit)
{
//  xml->setDTD("<!DOCTYPE K8 [\n	<!ELEMENT Name (#PCDATA)>\n]>");
  // zakladni charakteristika
//  xml->setDataInt(unit->nameid,"nameid",0,NULL); toto je v indexu!
//  xml->setDataInt(unit->modelid,"modelid",0,NULL);
  xml->setDataInt(unit->type,"type",0,NULL);

  // pohyb
  xml->setDataInt(unit->max_points_of_movement,"movement_points",0,NULL);
  xml->setDataDouble(unit->movement_elevation[ET_LEVEL0],"elevation",0,"level_0",0,NULL);
  xml->setDataDouble(unit->movement_elevation[ET_LEVEL1],"elevation",0,"level_1",0,NULL);
  xml->setDataDouble(unit->movement_elevation[ET_LEVEL2],"elevation",0,"level_2",0,NULL);
  xml->setDataDouble(unit->movement_elevation[ET_LEVEL3],"elevation",0,"level_3",0,NULL);
  xml->setDataDouble(unit->movement_elevation[ET_LEVEL4],"elevation",0,"level_4",0,NULL);

  xml->setDataDouble(unit->movement_weather[WS_SUNNY],"weather",0,"sunny",0,NULL);
  xml->setDataDouble(unit->movement_weather[WS_RAIN],"weather",0,"rain",0,NULL);
  xml->setDataDouble(unit->movement_weather[WS_SNOW],"weather",0,"snow",0,NULL);

  xml->setDataDouble(unit->movement_terrain[TT_PLAIN],"terrain",0,"plain",0,NULL);
  xml->setDataDouble(unit->movement_terrain[TT_FOREST],"terrain",0,"forest",0,NULL); 
  xml->setDataDouble(unit->movement_terrain[TT_DEEP_FOREST],"terrain",0,"deepforest",0,NULL);
  xml->setDataDouble(unit->movement_terrain[TT_ROCKS],"terrain",0,"rocks",0,NULL);
  xml->setDataDouble(unit->movement_terrain[TT_SWAMP],"terrain",0,"swamp",0,NULL);
  xml->setDataDouble(unit->movement_terrain[TT_RIVER],"terrain",0,"river",0,NULL); 
  xml->setDataDouble(unit->movement_terrain[TT_SHALLOW],"terrain",0,"shallow",0,NULL);
  xml->setDataDouble(unit->movement_terrain[TT_SEA],"terrain",0,"sea",0,NULL);
  xml->setDataDouble(unit->movement_terrain[TT_TOWN],"terrain",0,"town",0,NULL);

  xml->setDataDouble(unit->movement_uphill,"uphill",0,NULL);
  xml->setDataDouble(unit->movement_downhill,"downhill",0,NULL);

  xml->setDataInt(unit->men_in_row,"meninrow",0,NULL);

  // boj 
  xml->setDataInt(unit->attack,"attack",0,NULL);
  xml->setDataInt(unit->defense,"defense",0,NULL);
  xml->setDataInt(unit->movement_and_fight_combination,"fight",0,NULL);
  xml->setDataInt(unit->counterattack,"counterattack",0,NULL);
  xml->setDataInt(unit->fight_type,"fight_type",0,NULL);

  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_PLAIN],"defense_bonus_from",0,"plain",0,NULL);
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_FOREST],"defense_bonus_from",0,"forest",0,NULL); 
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_DEEP_FOREST],"defense_bonus_from",0,"deepforest",0,NULL);
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_ROCKS],"defense_bonus_from",0,"rocks",0,NULL);
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_SWAMP],"defense_bonus_from",0,"swamp",0,NULL);
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_RIVER],"defense_bonus_from",0,"river",0,NULL); 
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_SHALLOW],"defense_bonus_from",0,"shallow",0,NULL);
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_SEA],"defense_bonus_from",0,"sea",0,NULL);
  xml->setDataDouble(unit->defense_bonus_from_terrain[TT_TOWN],"defense_bonus_from",0,"town",0,NULL);

  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_PLAIN],"attack_bonus_against",0,"plain",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_FOREST],"attack_bonus_against",0,"forest",0,NULL); 
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_DEEP_FOREST],"attack_bonus_against",0,"deepforest",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_ROCKS],"attack_bonus_against",0,"rocks",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_SWAMP],"attack_bonus_against",0,"swamp",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_RIVER],"attack_bonus_against",0,"river",0,NULL); 
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_SHALLOW],"attack_bonus_against",0,"shallow",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_SEA],"attack_bonus_against",0,"sea",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_terrain[TT_TOWN],"attack_bonus_against",0,"town",0,NULL);

  xml->setDataDouble(unit->attack_bonus_against_unit[UT_INFANTRY],"attack_against",0,"infantry",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_unit[UT_CAVALRY],"attack_against",0,"cavarly",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_unit[UT_VEHICLE],"attack_against",0,"vehicle",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_unit[UT_INDIVIDUAL],"attack_against",0,"individual",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_unit[UT_BEAST],"attack_against",0,"beast",0,NULL);
  xml->setDataDouble(unit->attack_bonus_against_unit[UT_FLYING],"attack_against",0,"flying",0,NULL);

  xml->setDataDouble(unit->attack_bonus_against_building,"attack_building",0,NULL);
  xml->setDataInt(unit->attack_range,"range",0,NULL);
  xml->setDataDouble(unit->hit_probability,"hit_probability",0,NULL);

  //nakup a zold
  xml->setDataInt(unit->default_occurrence,"occurrence",0,NULL);
  xml->setDataInt(unit->cost,"cost",0,NULL);
  xml->setDataInt(unit->pay,"pay",0,NULL);

  //zivoty a leceni
  xml->setDataInt(unit->max_lives,"max_lives",0,NULL);
  xml->setDataInt(unit->cure_cost,"cure_cost",0,NULL);

  // videni (rozhled)
  xml->setDataInt(unit->eyesight_distance,"eyesight",0,NULL);

  // umi stavet budovy
  xml->setDataInt(unit->can_build_building,"build_building",0,NULL);

}

void TRM_advxml::XMLtoUnit(UNIT* unit,TXMLdata * xml)
{
  int temp; // type
  int temp2; // movement_and_fight_combination
  int temp3; // fight type
  if (
  // zakladni charakteristika
//      ((unit->nameid=xml->getDataInt("nameid",0,NULL))==XML_ERROR_NO_SUCH_A_PATH) ||
//      ((unit->modelid=xml->getDataInt("modelid",0,NULL))==XML_ERROR_NO_SUCH_A_PATH) ||
      ((temp=xml->getDataInt("type",0,NULL))==XML_ERROR_NO_SUCH_A_PATH) ||

  // pohyb
      ((unit->max_points_of_movement=xml->getDataInt("movement_points",0,NULL))==XML_ERROR_NO_SUCH_A_PATH) ||

      ((unit->movement_elevation[ET_LEVEL0]=(float)xml->getDataDouble("elevation",0,"level_0",0,NULL))<0) ||
      ((unit->movement_elevation[ET_LEVEL1]=(float)xml->getDataDouble("elevation",0,"level_1",0,NULL))<0) ||
      ((unit->movement_elevation[ET_LEVEL2]=(float)xml->getDataDouble("elevation",0,"level_2",0,NULL))<0) ||
      ((unit->movement_elevation[ET_LEVEL3]=(float)xml->getDataDouble("elevation",0,"level_3",0,NULL))<0) ||
      ((unit->movement_elevation[ET_LEVEL4]=(float)xml->getDataDouble("elevation",0,"level_4",0,NULL))<0) ||
             
      ((unit->movement_weather[WS_SUNNY]=(float)xml->getDataDouble("weather",0,"sunny",0,NULL))<0) ||
      ((unit->movement_weather[WS_RAIN]=(float)xml->getDataDouble("weather",0,"rain",0,NULL))<0) ||
      ((unit->movement_weather[WS_SNOW]=(float)xml->getDataDouble("weather",0,"snow",0,NULL))<0) ||

      ((unit->movement_terrain[TT_PLAIN]=(float)xml->getDataDouble("terrain",0,"plain",0,NULL))<0) ||
      ((unit->movement_terrain[TT_FOREST]=(float)xml->getDataDouble("terrain",0,"forest",0,NULL))<0) ||
      ((unit->movement_terrain[TT_DEEP_FOREST]=(float)xml->getDataDouble("terrain",0,"deepforest",0,NULL))<0) ||
      ((unit->movement_terrain[TT_ROCKS]=(float)xml->getDataDouble("terrain",0,"rocks",0,NULL))<0) ||
      ((unit->movement_terrain[TT_SWAMP]=(float)xml->getDataDouble("terrain",0,"swamp",0,NULL))<0) ||
      ((unit->movement_terrain[TT_RIVER]=(float)xml->getDataDouble("terrain",0,"river",0,NULL))<0) ||
      ((unit->movement_terrain[TT_SEA]=(float)xml->getDataDouble("terrain",0,"sea",0,NULL))<0) ||
      ((unit->movement_terrain[TT_SHALLOW]=(float)xml->getDataDouble("terrain",0,"shallow",0,NULL))<0) ||
      ((unit->movement_terrain[TT_TOWN]=(float)xml->getDataDouble("terrain",0,"town",0,NULL))<0) ||

      ((unit->movement_uphill=(float)xml->getDataDouble("uphill",0,NULL))<0) ||
      ((unit->movement_downhill=(float)xml->getDataDouble("downhill",0,NULL))<0) ||

      ((unit->men_in_row=xml->getDataInt("meninrow",0,NULL))<=0) ||

  // boj
      ((unit->attack=xml->getDataInt("attack",0,NULL))<0) ||
      ((unit->defense=xml->getDataInt("defense",0,NULL))<0) ||
      ((unit->counterattack=xml->getDataInt("counterattack",0,NULL))<0) ||
      ((temp2=xml->getDataInt("fight",0,NULL))<0)||
      ((temp3=xml->getDataInt("fight_type",0,NULL))<0)||

      ((unit->defense_bonus_from_terrain[TT_PLAIN]=(float)xml->getDataDouble("defense_bonus_from",0,"plain",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_FOREST]=(float)xml->getDataDouble("defense_bonus_from",0,"forest",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_DEEP_FOREST]=(float)xml->getDataDouble("defense_bonus_from",0,"deepforest",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_ROCKS]=(float)xml->getDataDouble("defense_bonus_from",0,"rocks",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_SWAMP]=(float)xml->getDataDouble("defense_bonus_from",0,"swamp",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_RIVER]=(float)xml->getDataDouble("defense_bonus_from",0,"river",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_SHALLOW]=(float)xml->getDataDouble("defense_bonus_from",0,"shallow",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_SEA]=(float)xml->getDataDouble("defense_bonus_from",0,"sea",0,NULL))<0) ||
      ((unit->defense_bonus_from_terrain[TT_TOWN]=(float)xml->getDataDouble("defense_bonus_from",0,"town",0,NULL))<0) ||

      ((unit->attack_bonus_against_terrain[TT_PLAIN]=(float)xml->getDataDouble("attack_bonus_against",0,"plain",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_FOREST]=(float)xml->getDataDouble("attack_bonus_against",0,"forest",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_DEEP_FOREST]=(float)xml->getDataDouble("attack_bonus_against",0,"deepforest",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_ROCKS]=(float)xml->getDataDouble("attack_bonus_against",0,"rocks",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_SWAMP]=(float)xml->getDataDouble("attack_bonus_against",0,"swamp",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_RIVER]=(float)xml->getDataDouble("attack_bonus_against",0,"river",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_SHALLOW]=(float)xml->getDataDouble("attack_bonus_against",0,"shallow",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_SEA]=(float)xml->getDataDouble("attack_bonus_against",0,"sea",0,NULL))<0) ||
      ((unit->attack_bonus_against_terrain[TT_TOWN]=(float)xml->getDataDouble("attack_bonus_against",0,"town",0,NULL))<0) ||

      ((unit->attack_bonus_against_unit[UT_INFANTRY]=(float)xml->getDataDouble("attack_against",0,"infantry",0,NULL))<0) ||
      ((unit->attack_bonus_against_unit[UT_CAVALRY]=(float)xml->getDataDouble("attack_against",0,"cavarly",0,NULL))<0) ||
      ((unit->attack_bonus_against_unit[UT_VEHICLE]=(float)xml->getDataDouble("attack_against",0,"vehicle",0,NULL))<0) ||
      ((unit->attack_bonus_against_unit[UT_INDIVIDUAL]=(float)xml->getDataDouble("attack_against",0,"individual",0,NULL))<0) ||
      ((unit->attack_bonus_against_unit[UT_BEAST]=(float)xml->getDataDouble("attack_against",0,"beast",0,NULL))<0) ||
      ((unit->attack_bonus_against_unit[UT_FLYING]=(float)xml->getDataDouble("attack_against",0,"flying",0,NULL))<0) ||

      ((unit->attack_range=xml->getDataInt("range",0,NULL))<0) ||

      ((unit->attack_bonus_against_building=(float)xml->getDataDouble("attack_buildings",0,NULL))<0) ||
      ((unit->hit_probability=(float)xml->getDataDouble("hit",0,NULL))<0) ||

  // vyskyt
      ((unit->default_occurrence=xml->getDataInt("occurrence",0,NULL))<0) ||
      ((unit->cost=xml->getDataInt("cost",0,NULL))<0) ||
      ((unit->pay=xml->getDataInt("pay",0,NULL))<0) ||

  //zivoty a leceni
      ((unit->max_lives=xml->getDataInt("max_lives",0,NULL))<0) ||
      ((unit->cure_cost=xml->getDataInt("cure_cost",0,NULL))<0) ||

  // videni (rozhled)
      ((unit->eyesight_distance=xml->getDataInt("eyesight",0,NULL))<0) ||

  // umi stavet budovy
      ((unit->can_build_building=xml->getDataInt("build_building",0,NULL))<0)

    )
  {
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a unit",this->type);
    THROW(E_8K_RM,"RMAdvXML can not load a unit"); 
  }
  // !! zde chybi jeste podstatna cast !!

  // prevedni ENUMu
  switch (temp) // typ jednotky
  {
    case UT_INFANTRY:   // pechota 
    case UT_CAVALRY:    // jizda
    case UT_VEHICLE:    // stroj
    case UT_INDIVIDUAL: // jednotlivec (hrdina, kouzelnik)
    case UT_BEAST:      // netvor (drak, obr)
    case UT_FLYING:     // letajici jednotka
    {
      unit->type=(UNIT_TYPE)temp; // pretypovani dopadne dobre
    }
    break;
    default: // jinak chyba
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a unit with bad type", this->type);
      THROW(E_8K_RM,"RMAdvXML can not load a unit"); 
    }
    break;
  }

  switch (temp2)
  {
    case MFC_ANYTHING:         // libovolna kombinace (i opakovana) pohybu a boje
    case MFC_MOVEMENT_FIRST:   // jednotka se muze pohnout a pote bojovat (bojem ztraci vsechny b.p.)
    case MFC_ATTACK_FIRST:     // jednotka muze utocit pouze pred pohybem, pak uz ne
    case MFC_SINGLE:           // jednotka muze zautocit a pohnout se, anebo naopak
    {
      unit->movement_and_fight_combination=(MOVEMENT_AND_FIGHT_COMBINATION) temp2; // pretypovani dopadne dobre
    }
    break;
    default: // jinak chyba
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a unit with bad \"movement_and_fight_combination\"(fight). Value: %d", this->type, temp2);
      THROW(E_8K_RM,"RMAdvXML can not load a unit"); 
    }
    break;
  }

  switch (temp3)
  {
    case FT_NONE:
    case FT_FACE_TO_FACE:      
    case FT_BLAST:   
    case FT_FIRE:     
    case FT_CATAPULT:     
    case FT_MAGIC:
    {
      unit->fight_type=(FIGHT_TYPE) temp3; // pretypovani dopadne dobre
    }
    break;
    default: // jinak chyba
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a unit with bad \"fight_type\"(fight_type) Value: %d", this->type, temp3);
      THROW(E_8K_RM,"RMAdvXML can not load a unit"); 
    }
    break;
  }
//  int bonuses=xml->getMaxId("bonuses",0,"bonus",0,NULL);
  int i;
  int count=0;
  for (i=0;i<UNIT_PROPERTY_COUNT;i++)
  {
    temp=xml->getDataInt("bonuses",0,"bonus",i,NULL);
    if (temp>0)
    {
      unit->bonuses[i]=1;
      if ( (i==UP_ATTACK_RANGE) && (unit->attack_range<=1) )
      {     
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i an unit can not have bonus UP_ATTACK_RANGE",this->type);
        THROW(E_8K_RM,"RMAdvXML can not load a unit"); 
      }
      count++;
      if (count>UNIT_PROPERTY_IMPROVE_MAX_COUNT)
      {
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i an unit can not have more than %d bonuses",this->type,UNIT_PROPERTY_IMPROVE_MAX_COUNT);
        THROW(E_8K_RM,"RMAdvXML can not load a unit"); 
      }
    }
    else
      unit->bonuses[i]=0;
  }
}

void TRM_advxml::buildingToXML(TXMLdata * xml,BUILDING* building)
{
//  xml->setDTD("<!DOCTYPE K8 [\n	<!ELEMENT Name (#PCDATA)>\n]>");
//  xml->setDataInt(building->modelid,"modelid",0,NULL); // toto je v indexu
//  xml->setDataInt(building->construction_modelid,"construction_modelid",0,NULL);
//  xml->setDataInt(building->nameid,"nameid",0,NULL);
  xml->setDataDouble(building->hit_probability,"hit_probability",0,NULL);
  xml->setDataInt(building->lives,"lives",0,NULL);

  xml->setDataInt(building->base_cost,"base_cost",0,NULL);
  xml->setDataInt(building->repair_cost,"repair_cost",0,NULL);
  xml->setDataInt(building->orientation_count,"orientation_count",0,NULL);
  xml->setDataInt(building->construction_duration,"construction_duration",0,NULL);
  xml->setDataInt(building->construction_position,"position",0,NULL);
  xml->setDataInt(building->structure_type,"structure_type",0,NULL);
  xml->setDataInt(building->counterattack,"counterattack",0,NULL);
  xml->setDataInt(building->defense_bonus,"defense_bonus",0,NULL);
  xml->setDataInt(building->eyesight_distance,"eyesight",0,NULL);

  xml->setDataInt(building->terrain[TT_PLAIN],"terrain",0,"plain",0,NULL);
  xml->setDataInt(building->terrain[TT_FOREST],"terrain",0,"forest",0,NULL); 
  xml->setDataInt(building->terrain[TT_DEEP_FOREST],"terrain",0,"deepforest",0,NULL);
  xml->setDataInt(building->terrain[TT_ROCKS],"terrain",0,"rocks",0,NULL);
  xml->setDataInt(building->terrain[TT_SWAMP],"terrain",0,"swamp",0,NULL);
  xml->setDataInt(building->terrain[TT_RIVER],"terrain",0,"river",0,NULL); 
  xml->setDataInt(building->terrain[TT_SHALLOW],"terrain",0,"shallow",0,NULL);
  xml->setDataInt(building->terrain[TT_SEA],"terrain",0,"sea",0,NULL);
  xml->setDataInt(building->terrain[TT_TOWN],"terrain",0,"town",0,NULL);

  int k;
  if (building->unit_recruitment.data!=0)
  {
    for (k=0;k<building->unit_recruitment.length;k++)
    {
      xml->setDataInt(building->unit_recruitment.data[k],"recruitments",0,"recruitment",k+1,NULL);
    }
  }
  if (building->bonuses.data!=0)
  {
/*    for (k=0;k<building->bonuses.length;k++)
    {
      xml->setDataInt(building->bonuses.data[k],"bonuses",0,"bonus",k+1,NULL);
    }*/
  }
}

void TRM_advxml::XMLtoBuilding(BUILDING* building,TXMLdata * xml)
{
  int temp,temp2; // pozice
  if ( 
//      ( (building->modelid=xml->getDataInt("modelid",0,NULL) ) == XML_ERROR_NO_SUCH_A_PATH) ||
//      ( (building->construction_modelid=xml->getDataInt("construction_modelid",0,NULL) ) == XML_ERROR_NO_SUCH_A_PATH) ||
//      ( (building->nameid=xml->getDataInt("nameid",0,NULL) ) == XML_ERROR_NO_SUCH_A_PATH) ||
      ( (building->hit_probability=(float)xml->getDataDouble("hit_probability",0,NULL) ) <0 ) ||
      ( (building->lives=xml->getDataInt("lives",0,NULL) ) <0 ) ||

      ( (building->base_cost=xml->getDataInt("base_cost",0,NULL) ) <0 ) ||
      ( (building->repair_cost=xml->getDataInt("repair_cost",0,NULL) ) <0 ) ||
      ( (building->construction_duration=xml->getDataInt("construction_duration",0,NULL) ) <=1 ) ||
      ( (building->orientation_count=xml->getDataInt("orientation_count",0,NULL) ) <0 ) ||
      ( (temp=xml->getDataInt("position",0,NULL) ) <0) ||
      ( (temp2=xml->getDataInt("structure_type",0,NULL) ) <0 ) ||
      ( (building->counterattack=xml->getDataInt("counterattack",0,NULL) ) <0 ) ||
      ( (building->defense_bonus=xml->getDataInt("defense_bonus",0,NULL) ) <0 ) ||
      ( (building->eyesight_distance=xml->getDataInt("eyesight",0,NULL) ) <0 ) ||


      ( (building->terrain[TT_PLAIN]=xml->getDataInt("terrain",0,"plain",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_FOREST]=xml->getDataInt("terrain",0,"forest",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_DEEP_FOREST]=xml->getDataInt("terrain",0,"deepforest",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_ROCKS]=xml->getDataInt("terrain",0,"rocks",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_SWAMP]=xml->getDataInt("terrain",0,"swamp",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_RIVER]=xml->getDataInt("terrain",0,"river",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_SHALLOW]=xml->getDataInt("terrain",0,"shallow",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_SEA]=xml->getDataInt("terrain",0,"sea",0,NULL) ) <0 ) ||
      ( (building->terrain[TT_TOWN]=xml->getDataInt("terrain",0,"town",0,NULL) ) <0 )
    )
  {
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a bulding %i",this->type,building->id);
    THROW(E_8K_RM,"RMAdvXML can not load a building"); 
  }

  // pocet orientaci je jen 6 nebo 12
  if ((building->orientation_count!=6) && (building->orientation_count!=12))
  {
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a bulding %i",this->type,building->id);
    THROW(E_8K_RM,"RMAdvXML can not load a building"); 
  }

  switch (temp)
  {
    case CP_SAME_HEX:
    case CP_ADJACENT_HEX:
    {
      building->construction_position=(CONSTRUCTION_POSITION) temp; // pretypovani dopadne dobre
    }
    break;
    default:
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a bulding %i",this->type,building->id);
      THROW(E_8K_RM,"RMAdvXML can not load a building"); 
    }
    break;

  }
  switch (temp2)
  {
    case ST_COVERED:
    case ST_OPEN:
    {
      building->structure_type=(STRUCTURE_TYPE) temp2;
    }
    break;
    default:
    {
      GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a bulding %i",this->type,building->id);
      THROW(E_8K_RM,"RMAdvXML can not load a building"); 
    }
    break;

  }

  int recruit=xml->getMaxId("recruitments",0,"recruitment",0,NULL);
  int k;
  if (recruit>0) 
  {
    building->unit_recruitment.length=recruit;
    building->unit_recruitment.data=(UNIT_TYPE_ID*)KMemAlloc(sizeof(UNIT_TYPE_ID)*(recruit));
    for (k=0;k<recruit;k++)
    {
      if ( (building->unit_recruitment.data[k]=xml->getDataInt("recruitments",0,"recruitment",k+1,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
      {
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a bulding %i",this->type,building->id);
        THROW(E_8K_RM,"RMAdvXML can not load a building");        
      }
    }
  }
  else
  {
    building->unit_recruitment.length=0;
    building->unit_recruitment.data=NULL;
  }

  int bonuses=xml->getMaxId("bonuses",0,"bonus",0,NULL);
  if (bonuses>0)
  {
    building->bonuses.length=bonuses;
    building->bonuses.data=(UNIT_PROPERTY_BONUS_ID*)KMemAlloc(sizeof(UNIT_PROPERTY_BONUS_ID)*(bonuses));
    for (k=0;k<bonuses;k++)
    {
      if ( (building->bonuses.data[k]=xml->getDataInt("bonuses",0,"bonus",k+1,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
      {
        GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not load a bulding %i, bad bonus %i",this->type,building->id,k);
        THROW(E_8K_RM,"RMAdvXML can not load a building");        
      }
    }
  }
  else
  {
    building->bonuses.length=0;
    building->bonuses.data=NULL;
  }
}

void TRM_advxml::XMLtoBonus(UNIT_PROPERTY_BONUS * bonus,TXMLdata * xml)
{
  int temp;
  if ((bonus->bonus=xml->getDataInt("bonus",0,NULL))==XML_ERROR_NO_SUCH_A_PATH)
  {
    GLOBALLOGID(PRIORITY_ERROR_IN_XML,"Bad XML file (bonus)");
    THROW(E_8K_RM,"Bad XML file (bonus)"); 
  }
  if ((bonus->cost=xml->getDataInt("cost",0,NULL))==XML_ERROR_NO_SUCH_A_PATH)
  {
    GLOBALLOGID(PRIORITY_ERROR_IN_XML,"Bad XML file (bonus) - chybna cena");
    THROW(E_8K_RM,"Bad XML file (bonus)"); 
  }
  if ( (temp=xml->getDataInt("property",0,NULL)) == XML_ERROR_NO_SUCH_A_PATH)
  {
    GLOBALLOGID(PRIORITY_ERROR_IN_XML,"Bad XML file (bonus)");
    THROW(E_8K_RM,"Bad XML file (bonus)"); 
  }
  else
  {
    switch (temp)
    {
      case UP_ATTACK:      
      {
        bonus->property=UP_ATTACK;
      }
      break;
      case UP_DEFENSE:      
      {
        bonus->property=UP_DEFENSE;
      }
      break;
      case UP_LIVES:       
      {
        bonus->property=UP_LIVES;
      }
      break;
      case UP_MOVEMENT:      
      {
        bonus->property=UP_MOVEMENT;
      }
      break;
      case UP_ATTACK_RANGE: 
      { 
        bonus->property=UP_ATTACK_RANGE; 
      } 
      break; 
      default:
      {
        GLOBALLOGID(PRIORITY_ERROR_IN_XML,"Bad XML file (bonus)");
        THROW(E_8K_RM,"Bad XML file (bonus)"); 
      }
      break;
    }
  }
}

void TRM_advxml::bonusToXML(TXMLdata * xml,UNIT_PROPERTY_BONUS * bonus)
{
  xml->setDataInt(bonus->bonus,"bonus",0,NULL);
  xml->setDataInt(bonus->cost,"cost",0,NULL);
  xml->setDataInt(bonus->property,"property",0,NULL);
}


void TRM_advxml::del(int id)
{
  this->lock();
  int res;
  if (this->type==RM_UNIT)
  {
    this->index->delData(0,"unit",id,NULL);
    res=this->saveToFile(this->rmconfi->getPack(),this->rmconfi->getUnitFile()); // zapisi do souboru
  }
  else if (this->type==RM_BUILDING)
  {
    this->index->delData(0,"building",id,NULL);
    res=this->saveToFile(this->rmconfi->getPack(),this->rmconfi->getBuildingFile()); // zapisi do souboru
  }
  else if (this->type==RM_BONUS)
  {
    this->index->delData(0,"bonus",id,NULL);
    res=this->saveToFile(this->rmconfi->getPack(),this->rmconfi->getBonusFile()); // zapisi do souboru
  }

  if (res!=XML_ERROR_OK)
  {
    this->unlock();
    GLOBALLOGID(PRIORITY_FATAL, "RMAdvXML type %i can not write the index-file",this->type);
    THROW(E_8K_RM,"RMAdvXML can not write the index-file"); 
  }


  if ((*(this->data))[id]!=NULL) // odstranim i z pameti
  {
    KMemFree((*(this->data))[id]);
  }
  this->unlock();
}

void TRM_advxml::delDep(int id)
{
  this->lock();
  int nameid=-1;
  if (this->type==RM_UNIT)
    nameid=this->index->getDataInt("unit",id,"name",0,NULL);
  else if (this->type==RM_BUILDING)
    nameid=this->index->getDataInt("building",id,"name",0,NULL);
  else if (this->type==RM_BONUS)
    nameid=this->index->getDataInt("bonus",id,"name",0,NULL);
  this->unlock();
  TRM_txt_i * RMtxti=(TRM_txt_i *)KSendMessage(RQUEUE,MSG_GET_RM_TXT_I,MOD_RM,MOD_RM,NULL);
  RMtxti->delString(nameid);
  delete(RMtxti);
  this->del(id);
}


int TRM_advxml::getCount()
{
  this->lock();
  int num=this->index->getNumId();
  this->unlock();
  return num;
}

int TRM_advxml::getLoaded()
{
  this->lock();
  int num=0;
  int j;
  for (j=this->data->getNext(-1);j!=-1;j=this->data->getNext(j))
  {
    num++;
  }
  this->unlock();
  return num;
}

TRM_advxml::TRM_advxml(TRM_conf_i * rmc,int type)
// konstruktor nema smyl zamykat...
{
  this->type=type;
  this->data=new DA<void*>;
  this->rmconfi=rmc;

  char *path=(char*)KMemAlloc(100*sizeof(char));
  size_t pathsize=100;

  int retvalue;

  try
  {
    if (this->type==RM_UNIT)
      strpath(&path,RESOURCES_DIR,this->rmconfi->getPack(),XML_DIR,this->rmconfi->getUnitFile(),pathsize,".xml");
    else if (this->type==RM_BUILDING)
      strpath(&path,RESOURCES_DIR,this->rmconfi->getPack(),XML_DIR,this->rmconfi->getBuildingFile(),pathsize,".xml");
    else if (this->type==RM_BONUS)
      strpath(&path,RESOURCES_DIR,this->rmconfi->getPack(),XML_DIR,this->rmconfi->getBonusFile(),pathsize,".xml");
  }
  catch (E_8K_RM)
  {
    GLOBALLOGID(PRIORITY_FATAL, "Bad files.xml");
    THROW(E_8K_RM,"Bad files.xml"); 
  }

  retvalue=this->readInfoFile(path); 
  if (retvalue!=XML_ERROR_OK)  // chyba pri cteni souboru
  {
    GLOBALLOGID(PRIORITY_MISSING_FILE,"The file %s is damaged or missing",path);
    THROW(E_8K_RM,"The index-file is damaged or missing"); 
  }

  KMemFree(path);
  if (this->type==RM_UNIT)
    GLOBALLOGID(PRIORITY_CONFIRM ,"RMunit was created");
  else if (this->type==RM_BUILDING)
    GLOBALLOGID(PRIORITY_CONFIRM ,"RMbuilding was created");
  else if (this->type==RM_BONUS)
    GLOBALLOGID(PRIORITY_CONFIRM ,"RMbonus was created");
}

TRM_advxml::~TRM_advxml()
{
  delete this->rmconfi;
  if (this->data!=NULL)
  {
    int j;
    for (j=this->data->getNext(-1);j!=-1;j=this->data->getNext(j))
    {
      if (this->type==RM_UNIT)
      {
//        UNIT * u=(UNIT *)(*(this->data))[j];
      }
      else if (this->type==RM_BUILDING) // prevedu budovu
      {
        BUILDING * b=(BUILDING *)(*(this->data))[j]; 
        if (b->unit_recruitment.data!=0)
        {
          KMemFree(b->unit_recruitment.data);
        }
      }
      else if (this->type==RM_BONUS) // prevedu budovu
      {
//        UNIT_PROPERTY_BONUS * b=(UNIT_PROPERTY_BONUS *)(*(this->data))[j]; 
      }
      KMemFree((*(this->data))[j]);
    }
    delete (this->data);
  }
  else
  {
    GLOBALLOGID(PRIORITY_DATA_WERE_NOT_RETURNED,"Data were not returned");
  }
  GLOBALLOGID(PRIORITY_CONFIRM ,"RMadvxml was destroyed");
}

}