XMLGenerator::XMLGenerator(const QString &baseDir)
{
QList<QEngine*> qengines = QtEngines::self()->engines();
foreach(QEngine *engine, qengines) {
QString engineDir = engine->name();
QString fileName = engineDir + "/" + "data.xml";
if (!baseDir.isEmpty()) {
engineDir = QString("%1/%2").arg(baseDir).arg(engineDir);
fileName = QString("%1/%2").arg(baseDir).arg(fileName);
}
if (!QFile::exists(fileName))
continue;
XMLReader handler;
QXmlSimpleReader reader;
reader.setContentHandler(&handler);
reader.setErrorHandler(&handler);
QFile file(fileName);
if (!file.open(QFile::ReadOnly | QFile::Text)) {
qWarning("Cannot open file '%s', because: %s",
qPrintable(fileName), qPrintable(file.errorString()));
continue;
}
QXmlInputSource xmlInputSource(&file);
if (reader.parse(xmlInputSource)) {
XMLEngine *engine = handler.xmlEngine();
checkDirs(engine->generationDate, engineDir);
engines.insert(engine->name, engine);
}
}
int main(int argc, char ** argv)
{
//add ResourceFinder to locate iCub config file (?)
yarp::os::ResourceFinder resourceFinder;
resourceFinder.configure(argc, argv);
yarp::os::Value file = resourceFinder.find("inputFile");
if (file.isNull()) {
std::cerr << "No input file provided." << std::endl;
exit(-1);
}
std::cout << "Start parsing " << file.asString() << std::endl;
XMLReader xmlReader;
Robot robot = xmlReader.getRobot(file.asString());
icub2gazebo::iCubConfigParser parser(robot);
parser.startParsing();
std::cout << std::endl << std::endl << "Computing updated PIDs" << std::endl << parser.outputPIDs();
return 0;
}
void EntityFactory::LoadBulletComponent(EntityData& aEntityToAddTo, XMLReader& aDocument, tinyxml2::XMLElement* aBulletComponentElement, float aDifficultScale)
{
aEntityToAddTo.myDamageRadius = 0.f;
aEntityToAddTo.myEntity->AddComponent<BulletComponent>();
for (tinyxml2::XMLElement* e = aBulletComponentElement->FirstChildElement(); e != nullptr; e = e->NextSiblingElement())
{
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("lifeTime").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "value", aEntityToAddTo.myMaxTime);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("damage").c_str()) == 0)
{
int damage = 0;
aDocument.ForceReadAttribute(e, "value", damage);
aEntityToAddTo.myDamage = int(damage * aDifficultScale);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("damageRadius").c_str()) == 0)
{
float radius = 0;
aDocument.ForceReadAttribute(e, "value", radius);
aEntityToAddTo.myDamageRadius = radius;
}
}
}
void MainWindow::setFileName(QString fileName){
XMLReader * xMlReader = new XMLReader(fileName);
bool ok = true;
eventList = xMlReader->readFile(&ok);
if (!ok){
eventName.clear();
ui->labelUpper->setText("<font color='red'>Error reading file " + fileName + "</font>" );
ui->labelMiddle->setText("<font color='red'>Check if the file exists and if the program has read acces</font>");
ui->labelLower->setText("<font color='red'>The file might also be damaged or contain XML errors</font");
return;
}
if (eventList.length() == 0){
ui->labelUpper->setText("<font color ='red'>Error: empty or incorrectly formatted XML file " + fileName + ".</font>");
return;
}
QSignalMapper * signalMapper = new QSignalMapper(this);
connect(signalMapper,SIGNAL(mapped(int)),this,SLOT(setEventSlot(int)));
for (int i = 0; i < eventList.length();i++){
actions.append(ui->menuEvents->addAction(eventList.at(i)->getName()));
actions.at(i)->setCheckable(true);
signalMapper->setMapping(actions.at(i),i);
connect(actions.at(i),SIGNAL(triggered()),signalMapper,SLOT(map()));
}
currentEventIndex = 0;
setEvent();
actions.at(currentEventIndex)->setChecked(true);
connect(timer,SIGNAL(timeout()),this,SLOT(eventTimerSlot()));
}
EMPAction::EMPAction(XMLReader& aReader, tinyxml2::XMLElement* aElement)
{
aReader.ForceReadAttribute(aReader.ForceFindFirstChild(aElement, "position"), "X", myPosition.x);
aReader.ForceReadAttribute(aReader.ForceFindFirstChild(aElement, "position"), "Y", myPosition.y);
aReader.ForceReadAttribute(aReader.ForceFindFirstChild(aElement, "position"), "Z", myPosition.z);
myPosition *= 10.f;
}
void
Joystick::load(const XMLReader& root_reader)
{
std::string cfg_name;
if (root_reader.read("name", cfg_name) && name == cfg_name)
{
// Read calibration data
if (XMLReader reader = root_reader.get_section("calibration"))
{
std::vector<CalibrationData> calibration_data;
const std::vector<XMLReader>& sections = reader.get_sections();
for(std::vector<XMLReader>::const_iterator i = sections.begin(); i != sections.end(); ++i)
{
CalibrationData data;
//i->read("axis", );
//i->read("precision", );
i->read("invert", data.invert);
i->read("center-min", data.center_min);
i->read("center-max", data.center_max);
i->read("range-min", data.range_min);
i->read("range-max", data.range_max);
calibration_data.push_back(data);
}
set_calibration(calibration_data);
}
{ // Read axis mapping
const std::vector<std::string>& cfg_axis_map = root_reader.get_string_list("axis-map");
std::vector<int> mapping;
for(std::vector<std::string>::const_iterator i = cfg_axis_map.begin(); i != cfg_axis_map.end(); ++i)
{
int type = 0;
int code = 0;
str2event(*i, type, code);
mapping.push_back(code);
}
set_axis_mapping(mapping);
}
{ // Read button mapping
const std::vector<std::string>& cfg_button_map = root_reader.get_string_list("button-map");
std::vector<int> mapping;
for(std::vector<std::string>::const_iterator i = cfg_button_map.begin(); i != cfg_button_map.end(); ++i)
{
int type = 0;
int code = 0;
str2event(*i, type, code);
mapping.push_back(code);
}
set_button_mapping(mapping);
}
}
}
XMLReader* XMLReader::getFileReader(const std::string& file)
{
XMLReader* result = new XMLReader() ;
result->m_reader = xmlReaderForFile(file.c_str(), NULL, 0) ;
result->processNode() ;
return result ;
}
void Waypoint::Restore(XMLReader &reader)
{
// read my Element
reader.readElement("Waypoint");
Name = reader.getAttribute("name");
// get the value of the placement
EndPos = Base::Placement(Base::Vector3d(reader.getAttributeAsFloat("Px"),
reader.getAttributeAsFloat("Py"),
reader.getAttributeAsFloat("Pz")),
Base::Rotation(reader.getAttributeAsFloat("Q0"),
reader.getAttributeAsFloat("Q1"),
reader.getAttributeAsFloat("Q2"),
reader.getAttributeAsFloat("Q3")));
Velocity = (float) reader.getAttributeAsFloat("vel");
Accelaration = (float) reader.getAttributeAsFloat("acc");
Cont = (reader.getAttributeAsInteger("cont") != 0)?true:false;
Tool = reader.getAttributeAsInteger("tool");
Base = reader.getAttributeAsInteger("base");
std::string type = reader.getAttribute("type");
if(type=="PTP")
Type = Waypoint::PTP;
else if(type=="LIN")
Type = Waypoint::LINE;
else if(type=="CIRC")
Type = Waypoint::CIRC;
else if(type=="WAIT")
Type = Waypoint::WAIT;
else
Type = Waypoint::UNDEF;
}
Customer::Customer(XMLReader& reader)
{
XMLReader customerReader = reader.GetNextElement(CUSTOMER_TAG);
mName = customerReader.GetAsString(NAME_TAG);
mAddress = customerReader.GetAsString(ADDRESS_TAG);
mData = customerReader.GetAsString(DATA_TAG);
}
void
QGAppRegister::load(const char * filename) throw (runtime_error)
{
//-- Perform previous data cleanup
delete _parseData;
for_each(_entryVect.begin(), _entryVect.end(), qstlDeleteObject());
//-- Parse File
_parseData = new ParseData();
// Open input source.
ifstream stream(filename);
InputSource source(stream);
// Parse input source.
XMLReader * parser = XMLReaderFactory::createXMLReader();
parser->setContentHandler(this);
parser->parse(source);
// Clean-up.
delete _parseData;
_parseData = 0;
delete parser;
}
void LevelFactory::LoadTriggers(XMLReader& aReader, tinyxml2::XMLElement* aLevelElement)
{
for (tinyxml2::XMLElement* entityElement = aReader.FindFirstChild(aLevelElement, "trigger"); entityElement != nullptr;
entityElement = aReader.FindNextElement(entityElement, "trigger"))
{
myCurrentLevel->AddTrigger(aReader, entityElement);
}
}
XMLReader* XMLReader::getStringReader(const std::string& content)
{
XMLReader* result = new XMLReader() ;
result->m_reader = xmlReaderForDoc((const xmlChar*) content.c_str(),
NULL, NULL, 0) ;
result->processNode() ;
return result ;
}
void ParticleSystemData::Load(const std::string& aFilePath)
{
myEmitterData.Init(4);
myOrientations.Init(4);
myTimeStamps.Init(4);
XMLReader xmlDoc;
xmlDoc.OpenDocument(aFilePath);
XMLElement emitterElement = xmlDoc.FindFirstChild();
emitterElement = emitterElement->FirstChildElement("Emitter");
while (emitterElement != nullptr)
{
XMLElement dataElement = emitterElement->FirstChildElement("Name");
std::string emitterName = dataElement->GetText();
dataElement = emitterElement->FirstChildElement("Time");
float time;
dataElement->QueryFloatText(&time);
dataElement = emitterElement->FirstChildElement("Position");
Vector3<float> position;
position.x = dataElement->FloatAttribute("x");
position.y = dataElement->FloatAttribute("y");
position.z = dataElement->FloatAttribute("z");
dataElement = emitterElement->FirstChildElement("Rotation");
Vector3<float> rotation;
rotation.x = dataElement->FloatAttribute("x");
rotation.y = dataElement->FloatAttribute("y");
rotation.z = dataElement->FloatAttribute("z");
Matrix44<float> orientation;
orientation *= Matrix44<float>::CreateRotateAroundX(rotation.x);
orientation *= Matrix44<float>::CreateRotateAroundY(rotation.y);
orientation *= Matrix44<float>::CreateRotateAroundZ(rotation.z);
orientation.SetTranslation(position);
myEmitterData.Add(emitterName);
myOrientations.Add(orientation);
myTimeStamps.Add(time);
emitterElement = emitterElement->NextSiblingElement("Emitter");
}
}
XMLReader*
ReaderMgr::createIntEntReader( const XMLCh* const sysId
, const XMLReader::RefFrom refFrom
, const XMLReader::Types type
, const XMLCh* const dataBuf
, const XMLSize_t dataLen
, const bool copyBuf
, const bool calcSrcOfs
, XMLSize_t lowWaterMark)
{
//
// This one is easy, we just create an input stream for the data and
// provide a few extra goodies.
//
// NOTE: We use a special encoding string that will be recognized
// as a 'do nothing' transcoder for the already internalized XMLCh
// data that makes up an internal entity.
//
BinMemInputStream* newStream = new (fMemoryManager) BinMemInputStream
(
(const XMLByte*)dataBuf
, dataLen * sizeof(XMLCh)
, copyBuf ? BinMemInputStream::BufOpt_Copy
: BinMemInputStream::BufOpt_Reference
, fMemoryManager
);
if (!newStream)
return 0;
XMLReader* retVal = new (fMemoryManager) XMLReader
(
sysId
, 0
, newStream
, XMLRecognizer::XERCES_XMLCH
, refFrom
, type
, XMLReader::Source_Internal
, false
, calcSrcOfs
, lowWaterMark
, fXMLVersion
, fMemoryManager
);
// If it failed for any reason, then return zero.
if (!retVal) {
delete newStream;
return 0;
}
// Set the reader number to the next available number
retVal->setReaderNum(fNextReaderNum++);
return retVal;
}
std::string SAXParserTest::parseMemory(XMLReader& reader, int options, const std::string& data)
{
std::istringstream istr(data);
std::ostringstream ostr;
XMLWriter writer(ostr, options);
reader.setContentHandler(&writer);
reader.setDTDHandler(&writer);
reader.setProperty(XMLReader::PROPERTY_LEXICAL_HANDLER, static_cast<Poco::XML::LexicalHandler*>(&writer));
reader.parseMemoryNP(data.data(), data.size());
return ostr.str();
}
void LevelFactory::LoadProps(XMLReader& aReader, tinyxml2::XMLElement* aLevelElement)
{
for (tinyxml2::XMLElement* entityElement = aReader.FindFirstChild(aLevelElement, "prop"); entityElement != nullptr;
entityElement = aReader.FindNextElement(entityElement, "prop"))
{
Entity* newEntity = new Entity(eEntityType::PROP, *myCurrentLevel->myScene, Prism::eOctreeType::STATIC);
std::string propType;
aReader.ForceReadAttribute(entityElement, "propType", propType);
myCurrentLevel->myEntityFactory->CopyEntity(newEntity, propType);
newEntity->AddComponent<PropComponent>()->Init("", "");
FillDataPropOrDefendable(aReader, entityElement, newEntity);
}
}
void LevelFactory::LoadDifficults()
{
XMLReader reader;
reader.OpenDocument("Data/Setting/SET_difficulty.xml");
tinyxml2::XMLElement* rootElement = reader.ForceFindFirstChild("root");
int index = 0;
for (tinyxml2::XMLElement* e = reader.ForceFindFirstChild(rootElement); e != nullptr; e = reader.FindNextElement(e))
{
DL_ASSERT_EXP(index < static_cast<int>(eDifficult::_COUNT), "You are trying to add more difficults than there should be.");
if (std::strcmp(e->Name(), "Difficult") == 0)
{
Difficult newDifficult;
std::string diffType;
reader.ForceReadAttribute(e, "type", diffType);
reader.ForceReadAttribute(e, "multiplier", newDifficult.myMultiplier);
reader.ForceReadAttribute(e, "defendHealthMulitplier", newDifficult.myHealthMultiplier);
if (diffType == "Easy")
{
newDifficult.myType = eDifficult::EASY;
}
else if (diffType == "Normal")
{
newDifficult.myType = eDifficult::NORMAL;
}
else if (diffType == "Hard")
{
newDifficult.myType = eDifficult::HARD;
}
myDifficults.Insert(index++,newDifficult);
}
}
reader.CloseDocument();
}
/** This function is not exported by FLHook so we include it here */
HK_ERROR HkFMsgEncodeMsg(const wstring &wscMessage, char *szBuf, uint iSize, uint &iRet)
{
XMLReader rdr;
RenderDisplayList rdl;
wstring wscMsg = L"<?xml version=\"1.0\" encoding=\"UTF-16\"?><RDL><PUSH/>";
wscMsg += L"<TRA data=\"0xE6C68400\" mask=\"-1\"/><TEXT>" + XMLText(wscMessage) + L"</TEXT>";
wscMsg += L"<PARA/><POP/></RDL>\x000A\x000A";
if(!rdr.read_buffer(rdl, (const char*)wscMsg.c_str(), (uint)wscMsg.length() * 2))
return HKE_WRONG_XML_SYNTAX;
BinaryRDLWriter rdlwrite;
rdlwrite.write_buffer(rdl, szBuf, iSize, iRet);
return HKE_OK;
}
TimeLimitBTDecorator::TimeLimitBTDecorator(XMLReader& fileReader) :
BTDecoratorNode(fileReader)
{
m_timeLimit = fileReader.getFloatValueForSubElement(timeLimitConfigAttributeName);
m_executionTimer = m_timeLimit;
}
int Module_SOW_Car::load(const XMLReader& xmldata)
{
/* //See comment below
if (ModuleG2D::load(xmldata) != 0) {
//Some error happened
return -1;
}*/
//xmldata.getXMLGroupHandle("")->dump();
//Load from xml
xmldata.for_all("object", [=](const XMLGroup* g) {
XMLReader r(*g);
SFG::Pointer<SOW_Car> c(new SOW_Car(this));
int loadableret = c.cast<Loadable>()->Loadable::load(r);
int gobjret = c.cast<GObjectBase>()->GObjectBase::load(XMLReader(*r.getXMLGroupHandle("GObjectBase/")));
int carret = c->load(XMLReader(*r.getXMLGroupHandle("Car")));
SFG::Util::printLog(SFG::Util::Information, __FILE__, __LINE__,
"Loading car module has return values %d - %d -%d", loadableret, gobjret, carret);
this->addObject(c);
});
return 0;
}
void Trajectory::Restore(XMLReader &reader)
{
vpcWaypoints.clear();
// read my element
reader.readElement("Trajectory");
// get the value of my Attribute
int count = reader.getAttributeAsInteger("count");
vpcWaypoints.resize(count);
for (int i = 0; i < count; i++) {
Waypoint *tmp = new Waypoint();
tmp->Restore(reader);
vpcWaypoints[i] = tmp;
}
generateTrajectory();
}
void LevelFactory::LoadPowerups(XMLReader& aReader, tinyxml2::XMLElement* aLevelElement)
{
for (tinyxml2::XMLElement* entityElement = aReader.FindFirstChild(aLevelElement, "powerup"); entityElement != nullptr;
entityElement = aReader.FindNextElement(entityElement, "powerup"))
{
Entity* newEntity = new Entity(eEntityType::POWERUP, *myCurrentLevel->myScene, Prism::eOctreeType::STATIC);
tinyxml2::XMLElement* powerUpElement = aReader.ForceFindFirstChild(entityElement, "position");
CU::Vector3<float> powerUpPosition;
aReader.ForceReadAttribute(powerUpElement, "X", powerUpPosition.x);
aReader.ForceReadAttribute(powerUpElement, "Y", powerUpPosition.y);
aReader.ForceReadAttribute(powerUpElement, "Z", powerUpPosition.z);
newEntity->myOriginalOrientation.SetPos(powerUpPosition*10.f);
newEntity->myOrientation = newEntity->myOriginalOrientation;
powerUpElement = aReader.ForceFindFirstChild(entityElement, "type");
std::string powerUp;
aReader.ForceReadAttribute(powerUpElement, "powerup", powerUp);
myCurrentLevel->myEntityFactory->CopyEntity(newEntity, powerUp);
newEntity->GetComponent<PowerUpComponent>()->SetPlayer(myCurrentLevel->myPlayer);
myCurrentLevel->myCollisionManager->Add(newEntity->GetComponent<CollisionComponent>(), eEntityType::POWERUP);
myCurrentLevel->myEntities.Add(newEntity);
}
}
void LevelFactory::LoadLevelListFromXML(const std::string& aXMLPath)
{
myLevelPaths.clear();
XMLReader reader;
reader.OpenDocument(aXMLPath);
std::string levelPath = "";
int ID = 0;
int lastID = ID - 1;
tinyxml2::XMLElement* levelElement = reader.FindFirstChild("level");
for (; levelElement != nullptr; levelElement = reader.FindNextElement(levelElement))
{
lastID = ID;
reader.ForceReadAttribute(levelElement, "ID", ID);
reader.ForceReadAttribute(levelElement, "path", levelPath);
myLevelPaths[ID] = levelPath;
if (ID - 1 != lastID)
{
DL_ASSERT("[LevelFactory] Wrong ID-number in levelList.xml! The numbers should be counting up, in order.");
}
if (myCurrentID >= 10)
{
DL_ASSERT("[LevelFactory] Can't handle level ID with two digits.");
}
}
reader.CloseDocument();
}
void EntityFactory::LoadPowerUpComponent(EntityData& aEntityToAddTo, XMLReader& aDocument, tinyxml2::XMLElement* aPowerUpComponent)
{
aEntityToAddTo.myDuration = 0.f;
aEntityToAddTo.myPowerUpValue = 0.f;
aEntityToAddTo.myUpgradePickupMessageTime = 0.f;
aEntityToAddTo.myUpgradeName = "";
aEntityToAddTo.myPowerUpName = "";
aEntityToAddTo.myUpgradePickupMessage = "";
aEntityToAddTo.myUpgradeID = -1;
aEntityToAddTo.myEntity->AddComponent<PowerUpComponent>();
for (tinyxml2::XMLElement* e = aPowerUpComponent->FirstChildElement(); e != nullptr; e = e->NextSiblingElement())
{
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("Power").c_str()) == 0)
{
std::string name;
aDocument.ForceReadAttribute(e, "type", name);
aDocument.ForceReadAttribute(e, "value", aEntityToAddTo.myPowerUpValue);
aDocument.ForceReadAttribute(e, "time", aEntityToAddTo.myDuration);
aEntityToAddTo.myPowerUpType = ConvertToPowerUpType(name);
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("WeaponUpgrade").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "entityName", aEntityToAddTo.myUpgradeName);
aDocument.ForceReadAttribute(e, "weaponID", aEntityToAddTo.myUpgradeID);
aDocument.ForceReadAttribute(e, "pickupMessage", aEntityToAddTo.myUpgradePickupMessage);
aDocument.ForceReadAttribute(e, "pickupMessageTime", aEntityToAddTo.myUpgradePickupMessageTime);
aEntityToAddTo.myPowerUpType = ePowerUpType::WEAPON_UPGRADE;
}
aEntityToAddTo.myPowerUpName = ConvertToPowerUpInGameName(aEntityToAddTo.myPowerUpType);
}
}
bool SceneSerializer::DeserializeParticleAffectors(XMLReader& reader,
std::vector<std::shared_ptr<ParticleAffector>>& outList)
{
bool failureDetected = false;
bool currResult = false;
if(reader.MoveToChildNode())
{
std::string currNodeName;
std::string currAttName;
do
{
currNodeName= reader.GetCurrentNodeName();
if (currNodeName == ScaleAffector)
{
std::shared_ptr<ScaleParticleAffector> scaleAffector;
currResult = DeserializeScaleAffector(reader, scaleAffector);
if(currResult)
outList.push_back(scaleAffector);
else
failureDetected = true;
}
else if(currNodeName == ColourFaderAffector)
{
std::shared_ptr<ColourFadeParticleAffector> colorAffector;
currResult = DeserializeColourFadeAffector(reader, colorAffector);
if(currResult)
outList.push_back(colorAffector);
else
failureDetected = true;
}
} while (reader.MoveToNextSiblingNode());
reader.PopNode();
return !failureDetected;
}
return false;
}
void EntityFactory::LoadStreakEmitterComponent(EntityData& aEntityToAddTo, XMLReader& aDocument, tinyxml2::XMLElement* aStreakEmitterComponent)
{
for (tinyxml2::XMLElement* e = aStreakEmitterComponent->FirstChildElement(); e != nullptr; e = e->NextSiblingElement())
{
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("Path").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "src", aEntityToAddTo.myStreakEmitterXMLPath);
}
}
}
void Project::load(const string &_filename) {
setFilename(_filename);
XMLReader reader;
reader.addFactory("tool_table", tools.get());
reader.read(filename, &options);
// Default workpiece
if (!options["automatic-workpiece"].hasValue())
options["automatic-workpiece"].
setDefault(workpieceMin.empty() && workpieceMax.empty());
// Load NC files
Option::strings_t ncFiles = options["nc-files"].toStrings();
options["nc-files"].reset();
for (unsigned i = 0; i < ncFiles.size(); i++)
addFile(decodeFilename(ncFiles[i]));
markClean();
}
int SOW_Car::load(const XMLReader& data)
{
data.for_all("blinker", [=](const XMLGroup* g){
XMLReader(*g).for_all("Light",[=](const XMLGroup* g2){
//Add lights and stuff
});
});
return 0;
}
void LevelFactory::LoadDefendables(XMLReader& aReader, tinyxml2::XMLElement* aLevelElement, float aDifficultScale)
{
for (tinyxml2::XMLElement* entityElement = aReader.FindFirstChild(aLevelElement, "defendable"); entityElement != nullptr;
entityElement = aReader.FindNextElement(entityElement, "defendable"))
{
Entity* newEntity = new Entity(eEntityType::DEFENDABLE, *myCurrentLevel->myScene, Prism::eOctreeType::STATIC);
std::string propType;
aReader.ForceReadAttribute(entityElement, "propType", propType);
myCurrentLevel->myEntityFactory->CopyEntity(newEntity, propType);
int difficultHealth = int(newEntity->GetComponent<HealthComponent>()->GetHealth() * aDifficultScale);
newEntity->GetComponent<HealthComponent>()->Init(difficultHealth);
std::string defendName;
aReader.ForceReadAttribute(entityElement, "defendName", defendName);
defendName = CU::ToLower(defendName);
newEntity->AddComponent<PropComponent>()->Init(defendName, "");
FillDataPropOrDefendable(aReader, entityElement, newEntity);
}
}
void
QgarAppDescr::init(InputSource source)
throw (runtime_error)
{
// Create parse data structure
_parseData = new ParseData();
// Parse input source
// Parse
XMLReader* parser = XMLReaderFactory::createXMLReader();
parser->setContentHandler(this);
parser->parse(source);
// Clean-up
delete _parseData;
_parseData = 0;
delete parser;
}
