void Translate::init(GameObject* go, XML* xml){
Parent::init(go, xml);
string s = xml->getString("speed");
if (xml->getError() != XML_OK){
throw("Translate Goanim requires speed");
}
vector<string> vs;
Tokenize(s, vs, ",");
if (vs[0].find(":") != string::npos){
vector<string> as;
Tokenize(vs[0], as, ":");
mSpeed.x = Ogre::Math::RangeRandom(atof(as[0].c_str()), atof(as[1].c_str()));
}else{
mSpeed.x = atof(vs[0].c_str());
}
if (vs[1].find(":") != string::npos){
vector<string> as;
Tokenize(vs[1], as, ":");
mSpeed.y = Ogre::Math::RangeRandom(atof(as[0].c_str()), atof(as[1].c_str()));
}else{
mSpeed.y = atof(vs[1].c_str());
}
if (vs[2].find(":") != string::npos){
vector<string> as;
Tokenize(vs[2], as, ":");
mSpeed.z = Ogre::Math::RangeRandom(atof(as[0].c_str()), atof(as[1].c_str()));
}else{
mSpeed.z = atof(vs[2].c_str());
}
if (xml->getError() != XML_OK){
throw("Translation GoAnim without Speed");
}
mZone.setMinimum(vector3FromString(xml->getString("zone_min")));
if (xml->getError() != XML_OK){
xml->getString("zone_max");
if (xml->getError() == XML_OK){
throw("Translation GoAnim Zone has maximum but not minimum");
}else{
mZone.setMinimum(-10,-10,-10);
mZone.setMaximum(-10,-10,-10);
mZone.setInfinite();
}
}else{
mZone.setMaximum(vector3FromString(xml->getString("zone_max")));
if (xml->getError() != XML_OK){
throw("Translation GoAnim Zone has minimum but not maximum");
}
}
}
bool OriginElement::setAttributes(const std::unordered_map<std::string, std::shared_ptr<iDynTree::XMLAttribute>>& attributes)
{
auto xyz = attributes.find("xyz");
if (xyz != attributes.end()) {
Position origin;
if (vector3FromString(xyz->second->value(), origin)) {
m_jointOrigin.setPosition(origin);
}
}
auto rpy = attributes.find("rpy");
if (rpy != attributes.end()) {
Rotation orientation;
Vector3 rpyVector;
if (vector3FromString(rpy->second->value(), rpyVector)) {
orientation = Rotation::RPY(rpyVector(0),
rpyVector(1),
rpyVector(2));
m_jointOrigin.setRotation(orientation);
}
}
return true;
}
void DefaultDroneDBE::init(XML& dronestatXml, XML& objectMovementXml){
string coord = objectMovementXml.getString("transform_c");
if (objectMovementXml.getError() != XML_OK){
coord = "macro:zero_transform";
}else{
int g=0;
}
mTransformCoordinator = dynamic_cast<Coordinator::TransformCoordinator*>(Coordinator::CoordinatorFactory::getSingleton()->get(coord));
mMaxTime = mTransformCoordinator->getLength();
{
XMLIterator it(&objectMovementXml);
it.setElemName("##anything##>goanim");
it.gotoZero();
while(it.gotoNext() != false){
XML* goxml = new XML(it.getElem().getContent());
mGoAnim.push_back(goxml);
};
}{
XMLIterator it(&objectMovementXml);
it.setElemName("##anything##>anim");
it.gotoZero();
while(it.gotoNext() != false){
XML* goxml = new XML(it.getElem().getContent());
mAnim.push_back(goxml);
};
}
mMaxTime = 9999;
Parent::init(dronestatXml,objectMovementXml);
/*XML xml3;
xml3 = xml->extractElem("level>dronestats");
if (xml->getError()!=XML_OK){
throw("WTF?");
}*/
{
XMLIterator it(&dronestatXml);
it.setElemName("##anything##>fire");
it.gotoZero();
FIRING_TIME ft;
std::string g;
while(it.gotoNext() != false){
XML itXml = it.getElem();
string time = itXml.getString("time");
string mount = itXml.getString("mount");
vector<string> t;
vector<string> m;
Tokenize(time,t,",");
Tokenize(mount,m,",");
vector<string>::iterator ti;
vector<string>::iterator mi;
string is = itXml.getString("inertia");
if (itXml.getError() == XML_OK){
if (is == "a"){ // as in actual;
ft.inertia = Ogre::Vector3(FLT_MAX,FLT_MAX,FLT_MAX);
}else{
ft.inertia = vector3FromString(is);
}
}else{
ft.inertia = Ogre::Vector3(0,0,0);
}
mi = m.begin();
//for (mi = m.begin();mi!=m.end();mi++){
for (ti = t.begin();ti!=t.end();ti++){
//ft.mount = atoi((*m.begin()).c_str());
if ((*ti).find("-") != string::npos){
vector<string> i;
Tokenize((*ti),i,"-");
if (i.size() != 3){
i.push_back("0");
//throw("Invalid drone firing times range, requires 3 arguments ("+(*ti)+")");
}
float start, end, step;
start = atof(i[0].c_str());
end = atof(i[1].c_str());
step = atof(i[2].c_str());
ft.time = start;
ft.firingOption = FIRING_START;
for (mi = m.begin();mi!=m.end();mi++){
ft.mount = atoi((*mi).c_str());
mFiringTime.push_back(ft);
ft.time +=step;
}
ft.time = end;
ft.firingOption = FIRING_STOP;
for (mi = m.begin();mi!=m.end();mi++){
ft.mount = atoi((*mi).c_str());
mFiringTime.push_back(ft);
ft.time +=step;
}
/*for (float h=start;h<end;h+=step){
ft.time = h;
mFiringTime.push_back(ft);
mi++;
if (mi == m.end()) mi = m.begin();
ft.mount = atoi((*mi).c_str());
}*/
}else{
ft.mount = atoi((*m.begin()).c_str());
ft.time = atof((*ti).c_str());
ft.firingOption = FIRING_START;
mFiringTime.push_back(ft);
ft.time += .07;
ft.firingOption = FIRING_STOP;
mFiringTime.push_back(ft);
}
}
//}
//ft.time = itXml.getFloat("time");
//ft.mount = itXml.getInt("mount");
//if (itXml.getError() != XML_OK){
// ft.mount = 0;
//}
//ft.inertia = vector3FromString(itXml.getString("inertia"));
//if (itXml.getError() != XML_OK){
//ft.inertia = Ogre::Vector3(0,0,0);
//}
};
}{
/*XMLIterator it(xml2);
it.setElemName("##anything##>anim");
it.gotoZero();
DRONE_TIMED_ANIM ft;
while(it.gotoNext() != false){
ft.time = it.getElem().getFloat("time");
ft.label = it.getElem().getString("label");
ft.loop = (it.getElem().getString("loop")=="true");
mTimedAnim.push_back(ft);
};*/
}
}
void DroneDBE::init(XML& dronestatXml, XML& objectMovementXml){
/*File f(getId()+".xml", "media/drones");
if (f.error() != FILE_OK){
throw("Drone without an XML file ("+getId()+")");
}
XML* xml;
xml = new XML();
xml->setContent((char*)f.content());*/
//XML* xml = new XML(getId()+".xml", "media/drones");
mMaxTime = dronestatXml.getFloat("maxtime");
std::string s;
s = dronestatXml.getString("class");
if (dronestatXml.getError() != XML_OK){
throw("Drone class undefined ("+getId()+")");
}
/*File file(s+".xml", "media/drones/classes");
if (file.error() != FILE_OK){
throw("Drone without an XML class file ("+getId()+")");
}
XML* classXml;
classXml = new XML();
classXml->setContent((char*)file.content());*/
XML* classXml = new XML(s+".xml", "media/drones/classes");
mScale = vector3FromString(classXml->getString("drone", "scale"));
if (classXml->getError() != XML_OK){
mScale = Ogre::Vector3(1,1,1);
}/*else{
int g=0;
}*/
mMaxLife = classXml->getFloat("drone", "life");
if (classXml->getError() != XML_OK)
throw("Class File Missing Argument : "+getId()+" (life)");
mScore= classXml->getInt("drone", "score");
if (classXml->getError() != XML_OK)
throw("Class File Missing Argument : "+getId()+" (score)");
string dllName= classXml->getString("drone", "dll");
if (classXml->getError() == XML_OK){
#ifdef _DEBUG
string name = dllName+"d";
mDll = LoadLibrary(name.c_str());
#else
mDll = LoadLibrary(dllName.c_str());
#endif
//mDllCallback = (DLLCallback)::GetProcAddress(weaponModule, "getInstance");
}else{
mDll = NULL;
//mDllCallback = NULL;
}
{
XMLIterator it(classXml);
it.setElemName("drone>death");
it.gotoZero();
while(it.gotoNext() != false){
DEATH_BEHAVIOUR db;
XML dbxml = it.getElem();
db.mFX = dbxml.getString("fx");
if (dbxml.getError() != XML_OK) db.mFX = "";
db.mDLLCustomCode = dbxml.getString("dll");
if (dbxml.getError() != XML_OK) db.mDLLCustomCode = "";
db.mTime = dbxml.getFloat("time");
if (dbxml.getError() != XML_OK) db.mTime = 0;
#if 0
XMLIterator dit(&dbxml);
dit.setElemName("death>debris");
dit.gotoZero();
while(dit.gotoNext() != false){
db.mDebris.push_back(dit.getElem());
/*DEBRIS_DETAIL dd;
XML ditElem = dit.getElem();
string dir = ditElem.getString("direction");
if (dir == "forward"){
dd.mDirection = DEBRIS_DIRECTION_FORWARD;
}else if (dir == "random"){
dd.mDirection = DEBRIS_DIRECTION_RANDOM;
}else{
throw("Unsupported debris direction : "+dir);
}
dd.mSpinMultiplier = ditElem.getFloat("spin");
dd.mMesh = ditElem.getString("mesh");
dd.mPython = ditElem.getString("python");
if (ditElem.getError() != XML_OK){
dd.mPython = "";
}
db.mDebris.push_back(dd);*/
};
#endif
mDeath.push_back(db);
}
}
{
XMLIterator it(classXml);
it.setElemName("drone>child");
it.gotoZero();
while(it.gotoNext() != false){
DRONE_CHILD dc;
XML xml = it.getElem();
dc.mName = xml.getString("drone");
dc.mBone = xml.getString("bone");
if (xml.getError() != XML_OK){
dc.mBone = "";
}
dc.mLabel = xml.getString("label");
int f = xml.getInt("forwardhits");
if (f == 1){
dc.mForward = true;
}else{
dc.mForward = false;
}
Ogre::Vector3 v = vector3FromString(xml.getString("delta"));
if (xml.getError() != XML_OK){
dc.mDelta = Ogre::Vector3(0,0,0);
}else{
dc.mDelta = v;
}
mChild.push_back(dc);
}
}
//if (classXml->getError() != XML_OK) throw("Class File Missing Argument : "+getId()+" (deathtime)");
string resource = classXml->getString("drone", "resource_path");
/*if (classXml->getError() == XML_OK){
this->addResourceContext(resource,"models");
}*/
string cn = classXml->getString("drone", "children");
if (classXml->getError() == XML_OK){
setChildrenName(cn);
}else{
setChildrenName(".");
}
setMeshName(classXml->getString("drone", "mesh"));
if (classXml->getError() != XML_OK){
throw("class without drone mesh");
}
mResourceContext = classXml->getString("drone", "resource_path");
if (classXml->getError() != XML_OK){
mResourceContext = mMeshName;
}
{
XMLIterator it(classXml);
it.setElemName("drone>weapon");
it.gotoZero();
//FIRING_TIME ft;
while(it.gotoNext() != false){
addWeaponInfo(&it.getElem());
};
}
XMLIterator it(classXml);
it.setElemName("drone>resource");
it.gotoZero();
//FIRING_TIME ft;
while(it.gotoNext() != false){
/*if (it.getElem().getString("type") != "meshmaterial"){
addResource(it.getElem().getString("name"), it.getElem().getString("type"));
}else{
addMeshResources(it.getElem().getString("name"));
}*/
if (it.getElem().getError() != XML_OK){
throw("Class File Resource Missing Argument : "+getId()+" (name)");
}
};
it.setElemName("drone>resourcecontext");
it.gotoZero();
while(it.gotoNext() != false){
string s = it.getElem().getString("path");
if (it.getElem().getError() != XML_OK){
throw("Class File Resource Content Missing Argument : "+getId()+" (path)");
}
//addResourceContext(s);
};
}
std::shared_ptr<XMLElement> JointElement::childElementForName(const std::string& name) {
// As an alternative for simple elements, instead of creating other classes,
// I implement the simple functions of the generic element
if (name == "origin") {
return std::make_shared<OriginElement>(m_jointFrame);
} else if (name == "parent" || name == "child") {
std::string& ref = (name == "parent") ? m_parentLink : m_childLink;
XMLElement* element = new XMLElement(name);
element->setAttributeCallback([&ref](const std::unordered_map<std::string, std::shared_ptr<XMLAttribute>>& attributes) {
auto linkName = attributes.find("link");
if (linkName != attributes.end()) {
ref = linkName->second->value();
}
return true;
});
return std::shared_ptr<XMLElement>(element);
} else if (name == "axis") {
XMLElement* element = new XMLElement(name);
element->setAttributeCallback([this](const std::unordered_map<std::string, std::shared_ptr<XMLAttribute>>& attributes) {
auto xyz = attributes.find("xyz");
if (xyz != attributes.end()) {
Vector3 direction;
if (vector3FromString(xyz->second->value(), direction)) {
m_axis = Axis(Direction(direction(0), direction(1), direction(2)),
Position(0.0, 0.0, 0.0));
}
}
return true;
});
return std::shared_ptr<XMLElement>(element);
} else if (name == "limit") {
m_limits = std::make_shared<Limits>();
m_limits->positionLower = .0;
m_limits->positionUpper = .0;
// TODO: check how the defaults/required works
XMLElement* element = new XMLElement(name);
element->setAttributeCallback([this](const std::unordered_map<std::string, std::shared_ptr<XMLAttribute>>& attributes) {
auto found = attributes.find("lower");
if (found != attributes.end()) {
double value = 0;
if (stringToDoubleWithClassicLocale(found->second->value(), value)) {
m_limits->positionLower = value;
}
}
found = attributes.find("upper");
if (found != attributes.end()) {
double value = 0;
if (stringToDoubleWithClassicLocale(found->second->value(), value)) {
m_limits->positionUpper = value;
}
}
found = attributes.find("effort");
if (found != attributes.end()) {
double value = 0;
if (stringToDoubleWithClassicLocale(found->second->value(), value)) {
m_limits->effort = value;
}
}
found = attributes.find("velocity");
if (found != attributes.end()) {
double value = 0;
if (stringToDoubleWithClassicLocale(found->second->value(), value)) {
m_limits->velocity = value;
}
}
// TODO: check if we need to impose restrictions on the joint type
return true;
});
return std::shared_ptr<XMLElement>(element);
}
return std::make_shared<XMLElement>(name);
}
