void MapLoader::load(const std::string &xmlFilename, ResourceHandler &handler) { XMLFile doc(xmlFilename); XMLElement *areaElement = doc.FirstChildElement("maps").FirstChildElement("area").ToElement(); while(areaElement) { u16 area = areaElement->IntAttribute("id"); XMLElement *mapElement = areaElement->FirstChildElement("map"); while(mapElement) { std::string name = mapElement->Attribute("name"); std::string tilesetName = mapElement->Attribute("tileset"); u16 x = mapElement->IntAttribute("x"); u16 y = mapElement->IntAttribute("y"); Tileset &tileset = handler.get<Tileset>(tilesetName); loadMap(name, area, x, y, tileset, handler); mapElement = mapElement->NextSiblingElement("map"); } areaElement = areaElement->NextSiblingElement("area"); } }
void MapLoader::loadMap(const std::string &name, u16 area, u16 x, u16 y, Tileset &tileset, ResourceHandler &handler) { XMLFile doc("data/maps/" + name + ".tmx"); XMLElement *mapElement = doc.FirstChildElement("map").ToElement(); u16 width = mapElement->IntAttribute("width"); u16 height = mapElement->IntAttribute("height"); std::vector<u16> data; XMLElement *tileElement = mapElement->FirstChildElement("layer")->FirstChildElement("data")->FirstChildElement("tile"); while(tileElement) { s16 tileID = tileElement->IntAttribute("gid") - 1; data.push_back((tileID >= 0) ? tileID : 0); tileElement = tileElement->NextSiblingElement("tile"); } Map &map = handler.add<Map>(makeName(area, x, y), area, x, y, width, height, tileset, data); for(u16 tileY = 0 ; tileY < height ; tileY++) { for(u16 tileX = 0 ; tileX < width ; tileX++) { u16 tileID = map.getTile(tileX, tileY); if(tileset.info()[tileID] == TilesInfos::TileType::GrassTile) { map.scene().addObject(GrassFactory::create(tileX, tileY)); } else if(tileset.info()[tileID] == TilesInfos::TileType::LowGrassTile) { map.scene().addObject(GrassFactory::create(tileX, tileY, true)); } } } SceneObjectLoader::load(name, map.scene()); }
void SpriteAnimationManager::init() { XMLFile doc("data/config/spriteAnimations.xml"); XMLElement *animationElement = doc.FirstChildElement("spriteAnimations").FirstChildElement("animation").ToElement(); while(animationElement) { std::string name = animationElement->Attribute("name"); std::vector<SpriteAnimation> animation; XMLElement *framesElement = animationElement->FirstChildElement("frames"); while(framesElement) { std::vector<u16> frames; u16 delay = framesElement->IntAttribute("delay"); XMLElement *frameElement = framesElement->FirstChildElement("frame"); while(frameElement) { frames.push_back(frameElement->IntAttribute("id")); frameElement = frameElement->NextSiblingElement("frame"); } animation.push_back(SpriteAnimation(frames.size(), frames, delay)); framesElement = framesElement->NextSiblingElement("frames"); } spriteAnimations[name] = animation; animationElement = animationElement->NextSiblingElement("animation"); } }
int CTransportConfig::Initialize(const char* confname) { if (m_transports.size() <= 0) { XMLDocument doc; if (doc.LoadFile(confname) != XML_NO_ERROR) { throw CMudException("load xml transports config file failed"); } XMLHandle docHandle(&doc); XMLHandle current_handle = docHandle.FirstChildElement("config").FirstChildElement("transports").FirstChild(); XMLElement* elem = current_handle.ToElement(); while (elem) { int id = elem->IntAttribute("id"); m_transports[id].id = id; m_transports[id].name = elem->Attribute("name"); m_transports[id].x = elem->IntAttribute("x"); m_transports[id].y = elem->IntAttribute("y"); m_transports[id].enabled = elem->BoolAttribute("enabled"); STDOUT_DEBUG("id=%d, name=%s, x=%d, y=%d, enabled=%d", id, m_transports[id].name.c_str(), m_transports[id].x, m_transports[id].y, m_transports[id].enabled); elem = current_handle.NextSibling().ToElement(); } } return 0; }
ensoft::tmx::Image loadImage(XMLElement *element) { XMLElement *ximage = element->FirstChildElement("image"); std::string format = getAttributeString(ximage, "format"); std::string source = getAttributeString(ximage, "source"); std::string trans = getAttributeString(ximage, "trans"); int width = ximage->IntAttribute("width"); int height = ximage->IntAttribute("height"); return ensoft::tmx::Image{format, source, trans, width, height}; }
void VisualComponent::init(XMLElement *xmlData) { XMLElement *visibleElt = xmlData->FirstChildElement("Visible"); // if no visibility if specified, default to true if (visibleElt == nullptr) visible = true; else { visible = visibleElt->BoolAttribute("value"); } XMLElement *textureElt = xmlData->FirstChildElement("Texture"); // if no texture is specified, set it to null if (textureElt == nullptr) texture = nullptr; else { string texID = textureElt->Attribute("id"); texture = TextureManager::get()->getTexture(texID); } XMLElement *dimElt = xmlData->FirstChildElement("Dimensions"); // if both are null, we have no dimension data if (dimElt == nullptr && textureElt == nullptr) throw BAD_DIMENSION_ERR; // if no dimensions are specified, take them from the texture else if (dimElt == nullptr) { width = texture->width; height = texture->height; } else { width = dimElt->DoubleAttribute("w"); height = dimElt->DoubleAttribute("h"); } XMLElement *colorElt = xmlData->FirstChildElement("Color"); // if no color is specified, default to white if (colorElt == nullptr) colorData = bm::Color(255, 255, 255, 255); else { int r = colorElt->IntAttribute("r"); int g = colorElt->IntAttribute("g"); int b = colorElt->IntAttribute("b"); int a = colorElt->IntAttribute("a"); colorData = bm::Color(r, g, b, a); } }
void VisualComponent::init(XMLElement *componentElement) { XMLElement* textureElement; const char* textureFileLocation; const char* fontFileLocation; std::ostringstream LabelString; ComponentID = componentElement->IntAttribute("ComponentType"); viewType = (ViewType)componentElement->IntAttribute("GameViewId"); XMLElement* colorElement = componentElement->FirstChildElement("Color"); //actorColor = new sf::Color(colorElement->IntAttribute("r"),colorElement->IntAttribute("g"),colorElement->IntAttribute("b"),colorElement->IntAttribute("a")); XMLElement* shapeElement = colorElement->NextSiblingElement("Structure"); shapeID = shapeElement->IntAttribute("ShapeID"); switch(shapeElement->IntAttribute("ShapeID")) { case 1://"Rectangle": actorShape = new ActorShape::Rectangle(); ((ActorShape::Rectangle*)actorShape)->setSize(shapeElement->FloatAttribute("Height"), shapeElement->FloatAttribute("Width")); ((ActorShape::Rectangle*)actorShape)->actorShape.setFillColor((const sf::Color &)actorColor);//(const sf::Color &)actorColor break; case 2://"Circle": actorShape = new ActorShape::Circle(); ((ActorShape::Circle*)actorShape)->setSize(shapeElement->FloatAttribute("Radious")); ((ActorShape::Circle*)actorShape)->actorShape.setFillColor((const sf::Color &)actorColor); break; case 3://"GRID MAP": actorShape = new ActorShape::GridMap(); ((ActorShape::GridMap*)actorShape)->setBlockSize(shapeElement->IntAttribute("BlockHeight"),shapeElement->IntAttribute("BlockWidth")); break; case 5://TextArea textureElement = shapeElement->NextSiblingElement("Texture"); textureFileLocation = textureElement->Attribute("TextureFileName"); actorShape = new ActorShape::GridMap(); ((ActorShape::GridMap*)actorShape)->LoadTexture(textureFileLocation); ((ActorShape::GridMap*)actorShape)->setBlockSize(shapeElement->IntAttribute("BlockHeight"),shapeElement->IntAttribute("BlockWidth")); fontFileLocation = textureElement->Attribute("FontFileName"); ((ActorShape::GridMap*)actorShape)->LoadFont(fontFileLocation); //LabelString << textureElement->Attribute("Text");// put float into string buffer //((ActorShape::GridMap*)actorShape)->SetTextInBox(LabelString, 0, 0); break; default: actorShape = new ActorShape::Circle(); ((ActorShape::Circle*)actorShape)->setSize(10); ((ActorShape::Circle*)actorShape)->actorShape.setFillColor((const sf::Color &)actorColor); break; } isVisible = true; }
Level* DataManager::getLevel(string name) { int gridSize = 8; XMLDocument doc; doc.LoadFile("data/levels.xml"); XMLElement* element = doc.FirstChildElement("package")->FirstChildElement("levels")->FirstChildElement("level"); int width = element->IntAttribute("width"); int height = element->IntAttribute("height"); //string name = element->Attribute("name"); Level* level = new Level(); level->width = width; level->height = height; level->name = name; stringstream ss; ss << hex << element->GetText(); int i = 0; int j = 0; int value; while (ss >> value) { int x = i * gridSize; int y = j * gridSize; int type = getBits(value, 0, 5); switch (type) { case 0x01: level->objects.push_back(new Object(x, y, Object::Type::BRICK)); break; case 0x02: level->objects.push_back(new Object(x, y, Object::Type::KEY)); break; case 0x03: level->objects.push_back(new Object(x, y, Object::Type::CACTUS)); break; case 0x04: level->objects.push_back(new Object(x, y, Object::Type::TRAVELATOR_LEFT)); break; case 0x05: level->blagger = new Blagger(x, y); break; case 0x06: level->objects.push_back(new Object(x, y, Object::Type::CROSS)); break; case 0x07: level->objects.push_back(new Object(x, y, Object::Type::METAL_FLOOR)); break; case 0x08: level->objects.push_back(new Object(x, y, Object::Type::SINKING_FLOOR)); break; case 0x09: level->objects.push_back(new Object(x, y, Object::Type::TRAVELATOR_RIGHT)); break; case 0x0A: level->objects.push_back(new Object(x, y, Object::Type::WALL_TOP)); break; case 0x0B: level->objects.push_back(new Object(x, y, Object::Type::WALL_CENTER)); break; case 0x0C: level->objects.push_back(new Object(x, y, Object::Type::WALL_BOTTOM)); break; } i++; if (i >= width) { i = 0; j++; } } return level; }
void MapManager::initMaps() { XMLFile doc("data/config/maps.xml"); XMLElement *areasElement = doc.FirstChildElement("maps").ToElement(); XMLElement *areaElement = areasElement->FirstChildElement("area"); u16 areaID = 0; while(areaElement) { XMLElement *mapElement = areaElement->FirstChildElement("map"); std::vector<Map*> currentArea; while(mapElement) { std::stringstream mapFilename; u8 layers; u16 x, y, tilesetID; layers = mapElement->IntAttribute("layers"); x = mapElement->IntAttribute("x"); y = mapElement->IntAttribute("y"); tilesetID = mapElement->IntAttribute("tilesetID"); mapFilename << "data/maps/map" << areaID << "-" << x << "-" << y << ".tmx"; currentArea.push_back(new Map(mapFilename.str().c_str(), x, y, areaID, layers, tilesetID)); currentArea.back()->setBattleback(new Image(std::string(std::string("graphics/battlebacks/") + mapElement->Attribute("battleback") + ".jpg").c_str())); XMLElement *eventElement = mapElement->FirstChildElement("event"); while(eventElement) { currentArea.back()->addEvent(EventManager::getEventByName(eventElement->Attribute("name"))); eventElement = eventElement->NextSiblingElement("event"); } mapElement = mapElement->NextSiblingElement("map"); } maps.push_back(currentArea); areaID++; areaElement = areaElement->NextSiblingElement("area"); } u16 startarea = areasElement->IntAttribute("startarea"); u16 startx = areasElement->IntAttribute("startx"); u16 starty = areasElement->IntAttribute("starty"); currentMap = maps[startarea][MAP_POS(startarea, startx, starty)]; }
void ItemManager::loadSkills() { XMLFile doc("data/config/skills.xml"); XMLElement *skillElement = doc.FirstChildElement("skills").FirstChildElement("skill").ToElement(); u8 id = 0; while(skillElement) { const char *animation; animation = skillElement->Attribute("animation"); if(!animation) animation = ""; skills.push_back(new Skill( std::string("Skill") + to_string(id), std::string("Skill") + to_string(id) + "Desc", std::string("graphics/skills/") + to_string(id) + ".png", AnimationManager::getAnimationByName(animation), skillElement->IntAttribute("damage"), skillElement->DoubleAttribute("hitRate") )); skills.back()->setID(id); skillElement = skillElement->NextSiblingElement("skill"); id++; } }
bool GraphDataStorageXML::load(const char* fullpath, GraphData& data, StageBaseData* baseData) { try { XMLDocument doc; XMLDocument *myDocument = &doc; if (! FileUtils::getInstance()->isFileExist(fullpath)) return false; auto Data = FileUtils::getInstance()->getDataFromFile(fullpath); if (myDocument->Parse((const char*)Data.getBytes(), Data.getSize())) return false; //if (myDocument->LoadFile(fullpath)) return false; static GraphData s_defGraphData = { 10/*row*/, 10/*column*/, 5/*vertex_num*/, 64/*box_heights*/, 64/*box_widths*/, 0/*diff_row_off_x*/, 32/*offsert_x*/, 32/*offsert_y*/ }; data = s_defGraphData; for (XMLElement* property = myDocument->FirstChildElement("property"); property; property = property->NextSiblingElement("property")) { data.cols = property->IntAttribute("cols"); data.rows = property->IntAttribute("rows"); if (baseData) { baseData->m_bonusNeedStar = 12; baseData->m_lbNeedScore = property->IntAttribute("score") * 5; } } for (XMLElement* property = myDocument->FirstChildElement("map"); property; property = property->NextSiblingElement()) { for (auto attribute = property->FirstAttribute(); attribute; attribute = attribute->Next()) { const char* name = attribute->Name(); int row = 0, col = 0; sscanf(name, "a%d_%d", &row, &col); data.map[row][col] = GraphAttrib::make(NodeCategory::make(static_cast<enNodeColor>(attribute->IntValue()), CHESS_CATEGORY_NORM, 0)); } } } catch (std::string& e) { cocos2d::log("%s\n", e.c_str()); return false; } return true; }
int OliWeb::configXml() { string msg = "Opening "; msg += OLIWEB_CONFIG; writeLog(msg); //writeLog("Parsing XML (tinyxml2)"); //config.Parse(OLIWEB_CONFIG); //config.Parse("utf8test.xml"); config.LoadFile(OLIWEB_CONFIG); //writeLog("Errorcode = " + toString(config.ErrorID())); // Pick apart the XML for config options... XMLElement *root = config.RootElement(); if ( root == NULL ) { writeLog("Error parsing file - no root element found."); return -1; } // Configuration Options XMLElement *parserElement = root->FirstChildElement("ConfigurationSettings"); if (parserElement != NULL) { writeLog("Reading configuration parameters",false); XMLElement *configElement = parserElement->FirstChildElement(); while (configElement != NULL) { string settingName = configElement->Name(); string value = configElement->Attribute("value"); writeLog(settingName + " = " + value,false); if ( settingName == "PortNumber") portNumber = configElement->IntAttribute("value"); else if ( settingName == "RootFileDirectory") rootFileDirectory = value; else if ( settingName == "ScriptDirectory") scriptDirectory = value; else if ( settingName == "DefaultFileName") defaultFileName = value; else if ( settingName == "FileNotFoundPage") fileNotFoundPage = value; else if ( settingName == "LogFile") logFileName = value; else if ( settingName == "PhpEngine") phpEngine = value; else if ( settingName == "PhpFlags") phpFlags = value; else if ( settingName == "UtilDirectory") utilDirectory = value; else writeLog("Setting not recognized!!"); configElement = configElement->NextSiblingElement(); } } return 0; // Success }
void ItemManager::loadArmors() { XMLFile doc("data/config/armors.xml"); XMLElement *armorElement = doc.FirstChildElement("armors").FirstChildElement("armor").ToElement(); u8 id = 0; while(armorElement) { armors.push_back(new Armor( std::string("Armor") + to_string(id), std::string("Armor") + to_string(id) + "Desc", std::string("graphics/armors/") + to_string(id) + ".png", armorElement->IntAttribute("slot"), armorElement->IntAttribute("defense") )); armors.back()->setID(id); armorElement = armorElement->NextSiblingElement("armor"); id++; } }
void getNonPassableTiles(const char *filename, Tileset *tileset) { XMLFile doc(filename); XMLElement *nonPassableTilesElement = doc.FirstChildElement("map").FirstChildElement("layer").NextSiblingElement().ToElement(); if(!nonPassableTilesElement) return; u16 size = nonPassableTilesElement->IntAttribute("width") * nonPassableTilesElement->IntAttribute("height"); tileset->nonPassableLayer = new u16[size]; XMLElement *tileElement = nonPassableTilesElement->FirstChildElement("data")->FirstChildElement("tile"); for(u16 i = 0 ; i < size ; i++) { if(!tileElement) break; s16 tile = tileElement->IntAttribute("gid") - 1; if(tile == -1) tileset->nonPassableLayer[i] = 0; else tileset->nonPassableLayer[i] = tile; tileElement = tileElement->NextSiblingElement("tile"); } }
XMLElement* CManagerModel::ParseMesh(XMLElement *XMLMesh,CModel* Model) { // Parse a SINGLE Mesh // Parse XMLSources AND Triangles. CMesh Mesh; XMLElement *XMLSource = XMLMesh->FirstChildElement("source"); XMLElement *Tri = XMLMesh->FirstChildElement("triangles"); XMLElement *Input = Tri->FirstChildElement("input"); //Mesh.mTriangleCount = Tri->IntAttribute("count"); while (Input != NULL) { CSource Source; if (strcmp(Input->Attribute("semantic"),"VERTEX") == 0) { Source.mID = XMLMesh->FirstChildElement("vertices")->FirstChildElement("input")->Attribute("source"); } else { Source.mID = Input->Attribute("source"); } Source.mType = (char*) Input->Attribute("semantic"); Source.mOffset = Input->IntAttribute("offset"); Source.mID = Source.mID.erase(0, 1); // Remove the pound symbol. // This is actually <p>, aka an index list. Mesh.mIndex = gusVector_SplitString((char*)Tri->FirstChildElement("p")->GetText(),' '); ParseSource(SourceByID(XMLMesh,(char*)Source.mID.c_str()),&Mesh,&Source); Input = Input->NextSiblingElement("input"); } // [Matrix setup] // Let's hope we've added everything needed in these loops. Model->AddMesh(Mesh); return XMLMesh->NextSiblingElement("mesh"); }
Volume3d<float, float>::Attribute CGBFile<float, float>::load(const std::string& filename) { tinyxml2::XMLDocument xml; xml.LoadFile(filename.c_str()); XMLElement* root = xml.FirstChildElement("root"); Volume3d<float, float>::Attribute attr; { XMLElement* res = root->FirstChildElement(resStr.c_str()); attr.resx = res->IntAttribute("x"); attr.resy = res->IntAttribute("y"); attr.resz = res->IntAttribute("z"); } XMLElement* res = root->FirstChildElement("origin"); Vector3d<float> origin = XMLHelper::parse(*res); XMLElement* lengthElem = root->FirstChildElement("length"); Vector3d<float> length = XMLHelper::parse(*lengthElem); Space3d<float> space(origin, length); attr.space = space; XMLElement* volumeElem = root->FirstChildElement("volume"); XMLElement* imageElem = volumeElem->FirstChildElement("image"); imageFileNames.clear(); while (imageElem != nullptr) { imageFileNames.push_back(imageElem->Attribute("path")); imageElem = imageElem->NextSiblingElement("image"); } return attr; }
void FileList::read() { XMLDocument doc; const string filepath = dir + "filelist"; doc.LoadFile(filepath.c_str()); XMLElement* filelist = doc.FirstChildElement(); try { validateXML(filelist, filepath); } catch (NoFile) { return; } for (XMLElement* i = filelist->FirstChildElement(); i != NULL; i = (XMLElement*) i->NextSibling()) { const string from = i->Attribute("from"); const string to = i->Attribute("to"); const Args::Action action = static_cast<Args::Action>(i->IntAttribute("action")); records.push_back(Record(from, to, action)); } }
bool InventoryComponent::Init(XMLElement* node) { if (node->QueryBoolAttribute("drop", &m_canDrop) != tinyxml2::XMLError::XML_SUCCESS) return false; if (node->QueryIntAttribute("maxsize", &m_maxSize) != tinyxml2::XMLError::XML_SUCCESS) return false; XMLElement* pItems = node->FirstChildElement("Items"); XMLElement* pItem = pItems->FirstChildElement("Item"); while (pItem) { if (!AddItem(pItem->Attribute("name"), pItem->IntAttribute("quantity"))) return false; pItem = pItem->NextSiblingElement("Item"); } return true; }
void ItemManager::loadWeapons() { XMLFile doc("data/config/weapons.xml"); XMLElement *weaponElement = doc.FirstChildElement("weapons").FirstChildElement("weapon").ToElement(); u8 id = 0; while(weaponElement) { weapons.push_back(new Weapon( std::string("Weapon") + to_string(id), std::string("Weapon") + to_string(id) + "Desc", std::string("graphics/weapons/") + to_string(id) + ".png", weaponElement->IntAttribute("damage"), weaponElement->DoubleAttribute("hitRate") )); weapons.back()->setID(id); weaponElement = weaponElement->NextSiblingElement("weapon"); id++; } }
void GameObject::LoadProperties( XMLElement & e ) { XMLElement * prop = e.FirstChildElement("Property"); while ( prop ){ g_Log << "Property id is: " << prop->Attribute("id") << "\n"; if ( !prop->Attribute("id") ) throw AttributeMissingException("Property - No id attribute"); if ( !prop->Attribute("type") ) throw AttributeMissingException("Property - No type attribute"); if ( !prop->Attribute("value") ) throw AttributeMissingException("Property - No value attribute"); string type = prop->Attribute("type"); if ( type == "bool" ) AddProperty( prop->Attribute("id"), prop->BoolAttribute("value")); else if ( type == "int" ) AddProperty( prop->Attribute("id"), prop->IntAttribute("value")); else if ( type == "float" ) AddProperty( prop->Attribute("id"), prop->FloatAttribute("value")); else if ( type == "string" ) AddProperty( prop->Attribute("id"), prop->Attribute("value")); else throw InvalidAttributeException("Invalid attribute type defined!"); prop = prop->NextSiblingElement("Property"); } }
std::string SystemSettings::load(const K::File& file) { XMLDocument doc; doc.LoadFile( file.getAbsolutePath().c_str() ); XMLElement* nRoot = doc.FirstChildElement("KSynth"); if (nRoot == nullptr) {return "";} // list of all encountered problems; std::string problems; XMLElement* nSettings = nRoot->FirstChildElement("Settings"); if (!nSettings) {return "missing node for 'Settings'\n";} // sound-sink XMLElement* nSink = nSettings->FirstChildElement("SoundSink"); if (nSink) { std::string name = nSink->Attribute("name"); SoundSinkHardware* ss = SoundSinks::get().getHardwareSinkByName(name); if (ss) { setSoundSink(ss); } else { problems += "could not find a SoundSink named '"+name+"'\n"; } } else { problems += "no 'SoundSink' given\n"; } // refresh interval XMLElement* nGui = nSettings->FirstChildElement("GUI"); if (nGui) { XMLElement* nGuiRefresh = nGui->FirstChildElement("Refresh"); if (nGuiRefresh) { setGuiRefreshInterval(nGuiRefresh->IntAttribute("ms")); } } return problems; }
GSV* gsv_parse(char* xmlString) { #ifdef GSV_DEBUG printf("gsv_parse(%p)\n",xmlString); printf("XML = %s\n",xmlString); #endif XMLDocument doc; doc.Parse(xmlString); GSV* gsvHandle = (GSV*) malloc(sizeof(GSV)); if(gsvHandle == NULL) return NULL; *gsvHandle = GSVDefault; XMLElement* panoramaElement = doc.FirstChildElement("panorama"); XMLElement* dataPropertiesElement = panoramaElement->FirstChildElement("data_properties"); int error = dataPropertiesElement->QueryIntAttribute("image_width",&gsvHandle->dataProperties.imageWidth); GSV_WARNING("image_width",error); error = dataPropertiesElement->QueryIntAttribute("image_height",&gsvHandle->dataProperties.imageHeight); GSV_WARNING("image_height",error); error = dataPropertiesElement->QueryIntAttribute("tile_width",&gsvHandle->dataProperties.tileWidth); GSV_WARNING("tile_width",error); error = dataPropertiesElement->QueryIntAttribute("tile_height",&gsvHandle->dataProperties.tileHeight); GSV_WARNING("tile_height",error); char year[5]; memset(year,'\0',sizeof(year)*sizeof(char)); char month[3]; memset(month,'\0',sizeof(month)*sizeof(char)); const char* imageDate = dataPropertiesElement->Attribute("image_date"); memcpy(year,imageDate,4*sizeof(char)); memcpy(month,&imageDate[5],2*sizeof(char)); struct tm imageDateTm = { 0, 0, 0, 1, atoi(month)-1, atoi(year)-1900, 0, 0, -1 }; gsvHandle->dataProperties.imageDate = mktime(&imageDateTm); memcpy(gsvHandle->dataProperties.panoramaId,dataPropertiesElement->Attribute("pano_id"),GSV_PANORAMA_ID_LENGTH); error = dataPropertiesElement->QueryIntAttribute("num_zoom_levels",&gsvHandle->dataProperties.numZoomLevels); GSV_WARNING("num_zoom_levels",error); error = dataPropertiesElement->QueryDoubleAttribute("lat",&gsvHandle->dataProperties.latitude); GSV_WARNING("lat",error); error = dataPropertiesElement->QueryDoubleAttribute("lng",&gsvHandle->dataProperties.longitude); GSV_WARNING("lng",error); error = dataPropertiesElement->QueryDoubleAttribute("original_lat",&gsvHandle->dataProperties.longitude); GSV_WARNING("original_lat",error); error = dataPropertiesElement->QueryDoubleAttribute("original_lng",&gsvHandle->dataProperties.longitude); GSV_WARNING("original_lng",error); gsv_copy_string(dataPropertiesElement->FirstChildElement("copyright")->GetText(),&gsvHandle->dataProperties.copyright); gsv_copy_string(dataPropertiesElement->FirstChildElement("text")->GetText(),&gsvHandle->dataProperties.text); gsv_copy_string(dataPropertiesElement->FirstChildElement("street_range")->GetText(),&gsvHandle->dataProperties.streetRange); gsv_copy_string(dataPropertiesElement->FirstChildElement("region")->GetText(),&gsvHandle->dataProperties.region); gsv_copy_string(dataPropertiesElement->FirstChildElement("country")->GetText(),&gsvHandle->dataProperties.country); XMLElement* projectionPropertiesElement = panoramaElement->FirstChildElement("projection_properties"); gsv_copy_string(projectionPropertiesElement->Attribute("projection_type"),&gsvHandle->projectionProperties.projectionType); gsvHandle->projectionProperties.panoramaYaw = projectionPropertiesElement->DoubleAttribute("pano_yaw_deg"); gsvHandle->projectionProperties.tiltYaw = projectionPropertiesElement->DoubleAttribute("tilt_yaw_deg"); gsvHandle->projectionProperties.tiltYaw = projectionPropertiesElement->DoubleAttribute("tilt_pitch_deg"); XMLElement* annotationProperties = panoramaElement->FirstChildElement("annotation_properties"); XMLElement* linkElement = annotationProperties->FirstChildElement("link"); while(linkElement != NULL) { gsvHandle->annotationProperties.links = (gsvLink*) realloc(gsvHandle->annotationProperties.links,(gsvHandle->annotationProperties.numLinks+1)*sizeof(gsvLink)); gsvLink* link = &gsvHandle->annotationProperties.links[gsvHandle->annotationProperties.numLinks]; error = linkElement->QueryDoubleAttribute("yaw_deg",&link->yaw); GSV_WARNING("yaw_deg",error); memcpy(link->panoramaId,linkElement->Attribute("pano_id"),GSV_PANORAMA_ID_LENGTH); const char* road_argb = linkElement->Attribute("road_argb"); *((unsigned int*)&link->roadColour) = (unsigned int)strtoul(&road_argb[2],NULL,16); link->scene = linkElement->IntAttribute("scene"); XMLElement* linkTextElement = linkElement->FirstChildElement("link_text"); gsv_copy_string(linkTextElement->GetText(),&link->text); gsvHandle->annotationProperties.numLinks++; XMLNode* siblingNode = linkElement->NextSibling(); if(siblingNode == NULL) break; linkElement = siblingNode->ToElement(); } return gsvHandle; }
std::unique_ptr<ensoft::tmx::Map> ensoft::tmx::TmxLoader::loadMap(std::string filename) { Logger logger("TMX Loader"); logger.log("Loading " + filename); XMLDocument doc; XMLError error = doc.LoadFile(filename.c_str()); std::unique_ptr<ensoft::tmx::Map> map; if (error != XMLError::XML_NO_ERROR) { logger.error("Error code: " + std::to_string(error)); } else { // start parsing the TMX map XMLElement *xmap = doc.FirstChildElement("map"); map = std::make_unique<ensoft::tmx::Map>(loadProperties(xmap)); map->version = xmap->Attribute("version"); map->orientation = xmap->Attribute("orientation"); map->width = xmap->IntAttribute("width"); map->height = xmap->IntAttribute("height"); map->tilewidth = xmap->IntAttribute("tilewidth"); map->tileheight = xmap->IntAttribute("tileheight"); map->renderorder = xmap->Attribute("renderorder"); map->properties = loadProperties(xmap); // load all the tilesets XMLElement *xtileset = xmap->FirstChildElement("tileset"); while (xtileset) { auto tileSet = std::make_unique<ensoft::tmx::TileSet>(loadProperties(xtileset)); tileSet->firstgid = xtileset->IntAttribute("firstgid"); tileSet->source = getAttributeString(xtileset, "source"); tileSet->name = getAttributeString(xtileset, "name"); tileSet->tilewidth = xtileset->IntAttribute("tilewidth"); tileSet->tileheight = xtileset->IntAttribute("tileheight"); tileSet->spacing = xtileset->IntAttribute("spacing"); tileSet->margin = xtileset->IntAttribute("margin"); // get the tiles for this tileset XMLElement *xtile = xtileset->FirstChildElement("tile"); while (xtile) { auto tile = make_unique<ensoft::tmx::Tile>(loadProperties(xtile)); tile->id = xtile->IntAttribute("id"); tile->terrain = getAttributeString(xtile, "terrain"); tile->probability = xtile->FloatAttribute("probability"); tile->image = loadImage(xtile); // keep track of all tiles and their global IDs int tileGid = tileSet->firstgid + tile->id; map->allTiles[tileGid] = tile.get(); std::cout << "[TMX Loader] Added: " << tile->image.source << " GID: " << tileGid << " Tileset: " << tileSet->name << std::endl; tileSet->tiles.push_back(std::move(tile)); xtile = xtile->NextSiblingElement("tile"); } map->tilesets.push_back(std::move(tileSet)); // try to find another tileset xtileset = xtileset->NextSiblingElement("tileset"); } XMLElement *xlayer = xmap->FirstChildElement("layer"); while (xlayer) { auto layer = std::make_shared<ensoft::tmx::Layer>(loadProperties(xlayer)); layer->name = xlayer->Attribute("name"); layer->x = xlayer->IntAttribute("x"); layer->y = xlayer->IntAttribute("y"); layer->width = xlayer->IntAttribute("width"); layer->height = xlayer->IntAttribute("height"); layer->opacity = xlayer->FloatAttribute("opacity"); layer->visible = xlayer->BoolAttribute("visible"); // load the data element XMLElement *xdata = xlayer->FirstChildElement("data"); if (xdata) { string data = trim_copy(xdata->GetText()); loadData(*layer, map.get(), data); } map->layers.push_back(layer); xlayer = xlayer->NextSiblingElement("layer"); } XMLElement *ximagelayer = xmap->FirstChildElement("imagelayer"); while (ximagelayer) { auto imageLayer = std::make_unique<ensoft::tmx::ImageLayer>(loadProperties(ximagelayer)); imageLayer->name = ximagelayer->Attribute("name"); imageLayer->x = ximagelayer->IntAttribute("x"); imageLayer->y = ximagelayer->IntAttribute("y"); imageLayer->width = ximagelayer->IntAttribute("width"); imageLayer->height = ximagelayer->IntAttribute("height"); imageLayer->opacity = ximagelayer->FloatAttribute("opacity"); imageLayer->visible = ximagelayer->BoolAttribute("visible"); imageLayer->image = loadImage(ximagelayer); map->imageLayers.push_back(std::move(imageLayer)); ximagelayer = ximagelayer->NextSiblingElement("imagelayer"); } XMLElement *xobjectgroup = xmap->FirstChildElement("objectgroup"); while (xobjectgroup) { auto objectGroup = std::make_unique<ensoft::tmx::ObjectGroup>(loadProperties(xobjectgroup)); objectGroup->name = xobjectgroup->Attribute("name"); objectGroup->x = xobjectgroup->IntAttribute("x"); objectGroup->y = xobjectgroup->IntAttribute("y"); objectGroup->width = xobjectgroup->IntAttribute("width"); objectGroup->height = xobjectgroup->IntAttribute("height"); objectGroup->opacity = xobjectgroup->FloatAttribute("opacity"); objectGroup->visible = xobjectgroup->BoolAttribute("visible"); //grab the objects XMLElement *xobject = xobjectgroup->FirstChildElement("object"); while (xobject) { auto object = std::make_unique<ensoft::tmx::Object>(loadProperties(xobject)); object->id = xobject->Attribute("id"); object->name = getAttributeString(xobject, "name"); object->type = getAttributeString(xobject, "type"); object->x = xobject->IntAttribute("x"); object->y = xobject->IntAttribute("y"); object->width = xobject->IntAttribute("witdth"); object->height = xobject->IntAttribute("height"); object->gid = xobject->IntAttribute("gid"); object->visible = xobject->BoolAttribute("visible"); objectGroup->objects.push_back(std::move(object)); xobject = xobject->NextSiblingElement("object"); } map->objectGroups.push_back(std::move(objectGroup)); xobjectgroup = xobjectgroup->NextSiblingElement("objectgroup"); } } return std::move(map); }
Map *MapParser::loadMap(string mapName, string mapPropertiesPath) { XMLDocument doc; cout << "Loading map..." << endl; doc.LoadFile(mapName.c_str()); cout << "Map loaded..." << endl; XMLElement *el = doc.FirstChildElement("map"); // Dimensões do mapa e dos tile int tx = el->IntAttribute("width"); int ty = el->IntAttribute("height"); int tw = el->IntAttribute("tilewidth"); int th = el->IntAttribute("tileheight"); el = el->FirstChildElement("tileset")->FirstChildElement("image"); int tilesetWidth = el->IntAttribute("width"); int tilesetHeight = el->IntAttribute("height"); el = el->Parent()->Parent()->ToElement(); cout << "Tileset properties loaded..." << endl; queue<char *> lines; int nlayer = 0; for (XMLElement *e = el->FirstChildElement("layer"); e != NULL; e = e->NextSiblingElement("layer") ) nlayer++; string property; string value; string name; cout << "Properties..." << endl; // Carrega propriedades definidas pelo usuário, se existir alguma if ( el->FirstChildElement("properties") != NULL ) { el = el->FirstChildElement("properties"); for (XMLElement *e = el->FirstChildElement("property"); e != NULL; e = e->NextSiblingElement("property") ) { property = e->Attribute("name"); value = e->Attribute("value"); if ( property.compare("name") == 0 ) { name = value; } } el = el->Parent()->ToElement(); } // matriz usada para armazena o valor dos tiles int ***matrixMap; matrixMap = new int**[nlayer]; for (int i=0; i < nlayer; i++) { matrixMap[i] = new int*[ty]; for (int j=0; j < ty; j++) { matrixMap[i][j] = new int[tx]; } } int layer = 0; cout << "Matrix created..." << endl; // Carrega cada camada do mapa for ( XMLElement *e = el->FirstChildElement("layer"); e != NULL; e = e->NextSiblingElement("layer") ) { property = e->FirstChildElement("data")->Attribute("encoding"); cout << "Matrix created..." << endl; // Se for 'Comma-Separated Values' if ( property.compare("csv") == 0 ) { // map->setName(value); cout << "Layer " << layer << endl; char *mapTiles = (char *)e->FirstChildElement("data")->GetText(); cout << "Layer " << layer << endl; char *line = strtok(mapTiles, "\n"); // Itera sobre cada linha while ( line != NULL ) { lines.push(line); line = strtok(NULL, "\n"); } char *tokens = NULL; int intToken; int mline = 0; while ( !lines.empty() ) { line = lines.front(); tokens = strtok(line, ","); int mcol = 0; // Itera sobre cada valor do tile, de cada linha while ( tokens != NULL ) { intToken = atoi(tokens); if ( intToken > 0 ) intToken--; matrixMap[layer][mline][mcol++] = intToken; cout << intToken << ", "; tokens = strtok(NULL, ","); } lines.pop(); mline++; } } cout << endl; layer++; } cout << "Before loading properties..." << endl; Tileset *tileset = new Tileset(tilesetWidth, tilesetHeight, tw, th); loadMapProperties(tileset, mapPropertiesPath); // CRIA MAPA Map *map = new Map(tileset, tx, ty, nlayer); map->setName(name); map->setMapMatrix(matrixMap); cout << "Map loaded..." << endl; return map; }
bool ScEclipseTheme::Load(const char* themeName) { using namespace tinyxml2; XMLDocument xmlDocument; XMLError result = xmlDocument.LoadFile(themeName); if (result != XML_SUCCESS) return false; XMLElement* rootElement = xmlDocument.RootElement(); if (!rootElement) return false; XMLElement* colorTheme = xmlDocument.FirstChildElement("colorTheme"); const char* name = colorTheme->Attribute("name"); if (name == nullptr) return false; //strcpy(m_themeName, name); m_themeId = (unsigned int)colorTheme->IntAttribute("id"); if (m_themeId == 0) return false; bool success = true; success &= LoadColour(m_searchResultIndication, "searchResultIndication", colorTheme); success &= LoadColour(m_filteredSearchResultIndication, "filteredSearchResultIndication", colorTheme); success &= LoadColour(m_occurrenceIndication, "occurrenceIndication", colorTheme); success &= LoadColour(m_writeOccurrenceIndication, "writeOccurrenceIndication", colorTheme); success &= LoadColour(m_findScope, "findScope", colorTheme); success &= LoadColour(m_sourceHoverBackground, "sourceHoverBackground", colorTheme); success &= LoadColour(m_singleLineComment, "singleLineComment", colorTheme); success &= LoadColour(m_multiLineComment, "multiLineComment", colorTheme); success &= LoadColour(m_commentTaskTag, "commentTaskTag", colorTheme); success &= LoadColour(m_javadoc, "javadoc", colorTheme); success &= LoadColour(m_javadocLink, "javadocLink", colorTheme); success &= LoadColour(m_javadocTag, "javadocTag", colorTheme); success &= LoadColour(m_javadocKeyword, "javadocKeyword", colorTheme); success &= LoadColour(m_class, "class", colorTheme); success &= LoadColour(m_interface, "interface", colorTheme); success &= LoadColour(m_method, "method", colorTheme); success &= LoadColour(m_methodDeclaration, "methodDeclaration", colorTheme); success &= LoadColour(m_bracket, "bracket", colorTheme); success &= LoadColour(m_number, "number", colorTheme); success &= LoadColour(m_string, "string", colorTheme); success &= LoadColour(m_operator, "operator", colorTheme); success &= LoadColour(m_keyword, "keyword", colorTheme); success &= LoadColour(m_annotation, "annotation", colorTheme); success &= LoadColour(m_staticMethod, "staticMethod", colorTheme); success &= LoadColour(m_localVariable, "localVariable", colorTheme); success &= LoadColour(m_localVariableDeclaration, "localVariableDeclaration", colorTheme); success &= LoadColour(m_field, "field", colorTheme); success &= LoadColour(m_staticField, "staticField", colorTheme); success &= LoadColour(m_staticFinalField, "staticFinalField", colorTheme); success &= LoadColour(m_deprecatedMember, "deprecatedMember", colorTheme); success &= LoadColour(m_background, "background", colorTheme); success &= LoadColour(m_currentLine, "currentLine", colorTheme); success &= LoadColour(m_foreground, "foreground", colorTheme); success &= LoadColour(m_lineNumber, "lineNumber", colorTheme); success &= LoadColour(m_selectionBackground, "selectionBackground", colorTheme); success &= LoadColour(m_selectionForeground, "selectionForeground", colorTheme); return success; }
void MapParser::loadMapProperties(Tileset *tileset, string filename) { XMLDocument doc; queue<char *> lines; int currentTile = 0; int *tilesetProperties; string property; doc.LoadFile(filename.c_str()); cout << "Loading map properties..." << endl; XMLElement *header = doc.FirstChildElement("tileset"); if ( header == NULL ) { cerr << "Error to read " << filename << endl; return; } int width = header->IntAttribute("width"); int height = header->IntAttribute("height"); XMLElement *properties = header->FirstChildElement("properties"); int walkable = properties->IntAttribute("walkable"); int block = properties->IntAttribute("block"); int passBelow = properties->IntAttribute("passbelow"); tileset->setProperties(walkable, block, passBelow); tilesetProperties = new int[width*height]; // Carrega cada camada do mapa XMLElement *data = header->FirstChildElement("data"); property = data->Attribute("encoding"); // Se for 'Comma-Separated Values' if ( property.compare("csv") == 0 ) { char *mapTiles = (char *)data->GetText(); char *line = strtok(mapTiles, "\n"); // Itera sobre cada linha while ( line != NULL ) { lines.push(line); // cout << line << endl; line = strtok(NULL, "\n"); } char *tokens = NULL; int mline = 0; while ( !lines.empty() ) { line = lines.front(); tokens = strtok(line, ","); int mcol = 0; // Itera sobre cada valor do tile, de cada linha while ( tokens != NULL ) { tilesetProperties[currentTile++] = atoi(tokens); mcol++; tokens = strtok(NULL, ","); } lines.pop(); mline++; } } tileset->setTilesetProperties(tilesetProperties); cout << "Map properties loaded..." << endl; }
void Level::loadMap(std::string mapName, Graphics &graphics) { //Parse the .tmx file XMLDocument doc; std::stringstream ss; ss << "content/maps/" << mapName << ".tmx"; //Pass in Map1; content/maps/Map1.tmx doc.LoadFile(ss.str().c_str()); XMLElement* mapNode = doc.FirstChildElement("map"); //Get the width and the height of the whole map and store it in _size int width, height; mapNode->QueryIntAttribute("width", &width); mapNode->QueryIntAttribute("height", &height); this->_size = Vector2(width, height); //Get the width and the height of an individual tile and store it in _tileSize int tileWidth, tileHeight; mapNode->QueryIntAttribute("tilewidth", &tileWidth); mapNode->QueryIntAttribute("tileheight", &tileHeight); this->_tileSize = Vector2(tileWidth, tileHeight); //Load the tilesets XMLElement* pTileset = mapNode->FirstChildElement("tileset"); if (pTileset != NULL) { while (pTileset) { int firstgid; const char* source = pTileset->FirstChildElement("image")->Attribute("source"); std::string path = source; path.replace(0, 2, "content"); pTileset->QueryIntAttribute("firstgid", &firstgid); SDL_Texture* tex = SDL_CreateTextureFromSurface(graphics.getRenderer(), graphics.loadImage(path)); this->_tilesets.push_back(Tileset(tex, firstgid)); // Get all the animations for that tileset XMLElement* pTileA = pTileset->FirstChildElement("tile"); if (pTileA != NULL) { while (pTileA) { AnimatedTileInfo ati; ati.StartTileId = pTileA->IntAttribute("id") + firstgid; ati.TilesetsFirstGid = firstgid; XMLElement* pAnimation = pTileA->FirstChildElement("animation"); if (pAnimation != NULL) { while (pAnimation) { XMLElement* pFrame = pAnimation->FirstChildElement("frame"); if (pFrame != NULL) { while (pFrame) { ati.TileIds.push_back(pFrame->IntAttribute("tileid") + firstgid); ati.Duration = pFrame->IntAttribute("duration"); pFrame = pFrame->NextSiblingElement("frame"); } } pAnimation = pAnimation->NextSiblingElement("animation"); } } this->_animatedTileInfos.push_back(ati); pTileA = pTileA->NextSiblingElement("tile"); } } pTileset = pTileset->NextSiblingElement("tileset"); } } //Loading the layers XMLElement* pLayer = mapNode->FirstChildElement("layer"); if (pLayer != NULL) { while (pLayer) { //Loading the data element XMLElement* pData = pLayer->FirstChildElement("data"); if (pData != NULL) { while (pData) { //Loading the tile element XMLElement* pTile = pData->FirstChildElement("tile"); if (pTile != NULL) { int tileCounter = 0; while (pTile) { //Build each individual tile here //If gid is 0, no tile should be drawn. Continue loop. if (pTile->IntAttribute("gid") == 0) { tileCounter++; if (pTile->NextSiblingElement("tile")) { pTile = pTile->NextSiblingElement("tile"); continue; } else { break; } } //Get the tileset for this specific gid int gid = pTile->IntAttribute("gid"); Tileset tls; int closest = 0; for (int i = 0; i < this->_tilesets.size(); i++) { if (this->_tilesets[i].FirstGid <= gid) { if (this->_tilesets[i].FirstGid > closest) { closest = this->_tilesets[i].FirstGid; tls = this->_tilesets.at(i); } } } if (tls.FirstGid == -1) { //No tileset was found for this gid tileCounter++; if (pTile->NextSiblingElement("tile")) { pTile = pTile->NextSiblingElement("tile"); continue; } else { break; } } //Get the position of the tile in the level int xx = 0; int yy = 0; xx = tileCounter % width; xx *= tileWidth; yy += tileHeight * (tileCounter / width); Vector2 finalTilePosition = Vector2(xx, yy); //Calculate the position of the tile in the tileset Vector2 finalTilesetPosition = this->getTilesetPosition(tls, gid, tileWidth, tileHeight); //Build the actual tile and add it to the level's tile list bool isAnimatedTile = false; AnimatedTileInfo ati; for (int i = 0; i < this->_animatedTileInfos.size(); i++) { if (this->_animatedTileInfos.at(i).StartTileId == gid) { ati = this->_animatedTileInfos.at(i); isAnimatedTile = true; break; } } if (isAnimatedTile == true) { std::vector<Vector2> tilesetPositions; for (int i = 0; i < ati.TileIds.size(); i++) { tilesetPositions.push_back(this->getTilesetPosition( tls, ati.TileIds.at(i), tileWidth, tileHeight)); } AnimatedTile tile(tilesetPositions, ati.Duration, tls.Texture, Vector2(tileWidth, tileHeight), finalTilePosition); this->_animatedTileList.push_back(tile); } else { Tile tile(tls.Texture, Vector2(tileWidth, tileHeight), finalTilesetPosition, finalTilePosition); this->_tileList.push_back(tile); } tileCounter++; pTile = pTile->NextSiblingElement("tile"); } } pData = pData->NextSiblingElement("data"); } } pLayer = pLayer->NextSiblingElement("layer"); } } // Parse out the collisions XMLElement* pObjectGroup = mapNode->FirstChildElement("objectgroup"); if (pObjectGroup != NULL) { while (pObjectGroup) { const char* name = pObjectGroup->Attribute("name"); std::stringstream ss; ss << name; if (ss.str() == "collisions") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { float x, y, width, height; x = pObject->FloatAttribute("x"); y = pObject->FloatAttribute("y"); width = pObject->FloatAttribute("width"); height = pObject->FloatAttribute("height"); this->_collisionRects.push_back(Rectangle( std::ceil(x) * globals::SPRITE_SCALE, std::ceil(y) * globals::SPRITE_SCALE, std::ceil(width) * globals::SPRITE_SCALE, std::ceil(height) * globals::SPRITE_SCALE )); pObject = pObject->NextSiblingElement("object"); } } } // Other object groups go here with an else if (ss.str() == "whatever") else if (ss.str() == "slopes") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { std::vector<Vector2> points; Vector2 p1; p1 = Vector2(std::ceil(pObject->FloatAttribute("x")), std::ceil(pObject->FloatAttribute("y"))); XMLElement* pPolyline = pObject->FirstChildElement("polyline"); if (pPolyline != NULL) { std::vector<std::string> pairs; const char* pointString = pPolyline->Attribute("points"); std::stringstream ss; ss << pointString; Utils::split(ss.str(), pairs, ' '); // Now we have each of the pairs. Loop through the list of pairs and // split them into Vector2s. Then store them in points vector. for (int i = 0; i < pairs.size(); i++) { std::vector<std::string> ps; Utils::split(pairs.at(i), ps, ','); points.push_back(Vector2( std::stoi(ps.at(0)), std::stoi(ps.at(1)))); } } for (int i = 0; i < points.size(); i += 2) { this->_slopes.push_back(Slope( Vector2( (p1.x + points.at(i < 2 ? i : i - 1).x) * globals::SPRITE_SCALE, (p1.y + points.at(i < 2 ? i : i - 1).y) * globals::SPRITE_SCALE), Vector2( (p1.x + points.at(i < 2 ? i + 1 : i).x) * globals::SPRITE_SCALE, (p1.y + points.at(i < 2 ? i + 1 : i).y) * globals::SPRITE_SCALE) ) ); } pObject = pObject->NextSiblingElement("object"); } } } else if (ss.str() == "spawn points") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { float x = pObject->FloatAttribute("x"); float y = pObject->FloatAttribute("y"); const char* name = pObject->Attribute("name"); std::stringstream ss; ss << name; if (ss.str() == "player") { this->_spawnPoint = Vector2(std::ceil(x) * globals::SPRITE_SCALE, std::ceil(y) * globals::SPRITE_SCALE); } pObject = pObject->NextSiblingElement("object"); } } } // Parse doors if they exist else if (ss.str() == "doors") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { float x = pObject->FloatAttribute("x"); float y = pObject->FloatAttribute("y"); float w = pObject->FloatAttribute("width"); float h = pObject->FloatAttribute("height"); Rectangle rect = Rectangle(x, y, w, h); XMLElement* pProperties = pObject->FirstChildElement("properties"); if (pProperties != NULL) { while (pProperties) { XMLElement* pProperty = pProperties->FirstChildElement("property"); if (pProperty != NULL) { while (pProperty) { const char* name = pProperty->Attribute("name"); std::stringstream ss; ss << name; if (ss.str() == "destination") { const char* value = pProperty->Attribute("value"); std::stringstream ss2; ss2 << value; Door door = Door(rect, ss2.str()); this->_doorList.push_back(door); } pProperty = pProperty->NextSiblingElement("property"); } } pProperties = pProperties->NextSiblingElement("properties"); } } pObject = pObject->NextSiblingElement("object"); } } } pObjectGroup = pObjectGroup->NextSiblingElement("objectgroup"); } } }
void Level::loadMap(std::string mapName, Graphics &graphics) { //Parse the .tmx file XMLDocument doc; std::stringstream ss; ss << "maps/" << mapName << ".tmx"; //Pass in Map 1, we get maps/Map 1.tmx doc.LoadFile(ss.str().c_str()); XMLElement* mapNode = doc.FirstChildElement("map"); //Get the width and the height of the whole map and store it in _size int width, height; mapNode->QueryIntAttribute("width", &width); mapNode->QueryIntAttribute("height", &height); this->_size = Vector2(width, height); //Get the width and the height of the tiles and store it in _tileSize int tileWidth, tileHeight; mapNode->QueryIntAttribute("tilewidth", &tileWidth); mapNode->QueryIntAttribute("tileheight", &tileHeight); this->_tileSize = Vector2(tileWidth, tileHeight); //Loading the tilesets XMLElement* pTileset = mapNode->FirstChildElement("tileset"); if (pTileset != NULL) { while (pTileset) { int firstgid; const char* source = pTileset->FirstChildElement("image")->Attribute("source"); char* path; std::stringstream ss; ss << source; pTileset->QueryIntAttribute("firstgid", &firstgid); SDL_Texture* tex = SDL_CreateTextureFromSurface(graphics.getRenderer(), graphics.loadImage(ss.str())); this->_tilesets.push_back(Tileset(tex, firstgid)); pTileset = pTileset->NextSiblingElement("tileset"); } } //Loading the layers XMLElement* pLayer = mapNode->FirstChildElement("layer"); if (pLayer != NULL) { while (pLayer) { //Loading the data element XMLElement* pData = pLayer->FirstChildElement("data"); if (pData != NULL) { while (pData) { //Loading the tile element XMLElement* pTile = pData->FirstChildElement("tile"); if (pTile != NULL) { int tileCounter = 0; while (pTile) { //Build each individual tile here //If gid is 0, no tile should be drawn. Continue loop if (pTile->IntAttribute("gid") == 0) { tileCounter++; if (pTile->NextSiblingElement("tile")) { pTile = pTile->NextSiblingElement("tile"); continue; } else { break; } } //Get the tileset for this specific gid int gid = pTile->IntAttribute("gid"); Tileset tls; for (int i = 0; i < this->_tilesets.size(); i++) { if (this->_tilesets[i].FirstGid <= gid) { //This is the tileset we want tls = this->_tilesets.at(i); break; } } if (tls.FirstGid == -1) { //No tileset was found for this gid tileCounter++; if (pTile->NextSiblingElement("tile")) { pTile = pTile->NextSiblingElement("tile"); continue; } else { break; } } //Get the position of the tile in the level int xx = 0; int yy = 0; xx = tileCounter % width; xx *= tileWidth; yy += tileHeight * (tileCounter / width); Vector2 finalTilePosition = Vector2(xx, yy); //Calculate the position of the tile in the tileset int tilesetWidth, tilesetHeight; SDL_QueryTexture(tls.Texture, NULL, NULL, &tilesetWidth, &tilesetHeight); int tsxx = gid % (tilesetWidth / tileWidth) - 1; tsxx *= tileWidth; int tsyy = 0; int amt = (gid / (tilesetWidth / tileWidth)); tsyy = tileHeight * amt; Vector2 finalTilesetPosition = Vector2(tsxx, tsyy); //Build the actual tile and add it to the level's tile list Tile tile(tls.Texture, Vector2(tileWidth, tileHeight), finalTilesetPosition, finalTilePosition); this->_tileList.push_back(tile); tileCounter++; pTile = pTile->NextSiblingElement("tile"); } } pData = pData->NextSiblingElement("data"); } } pLayer = pLayer->NextSiblingElement("layer"); } } //Parse out the collisions XMLElement* pObjectGroup = mapNode->FirstChildElement("objectgroup"); if (pObjectGroup != NULL) { while (pObjectGroup) { const char* name = pObjectGroup->Attribute("name"); std::stringstream ss; ss << name; if (ss.str() == "collisions") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { float x, y, width, height; x = pObject->FloatAttribute("x"); y = pObject->FloatAttribute("y"); width = pObject->FloatAttribute("width"); height = pObject->FloatAttribute("height"); this->_collisionRects.push_back(Rectangle( std::ceil(x) * globals::SPRITE_SCALE, std::ceil(y) * globals::SPRITE_SCALE, std::ceil(width) * globals::SPRITE_SCALE, std::ceil(height) * globals::SPRITE_SCALE )); pObject = pObject->NextSiblingElement("object"); } } } //Other objectgroups go here with an else if (ss.str() == "whatever") else if (ss.str() == "slopes") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { std::vector<Vector2> points; Vector2 p1; p1 = Vector2(std::ceil(pObject->FloatAttribute("x")), std::ceil(pObject->FloatAttribute("y"))); XMLElement* pPolyline = pObject->FirstChildElement("polyline"); if (pPolyline != NULL) { std::vector<std::string> pairs; const char* pointString = pPolyline->Attribute("points"); std::stringstream ss; ss << pointString; Utils::split(ss.str(), pairs, ' '); //Now we have each of the pairs. Loop through the list of pairs //and split them into Vector2s and then store them in our points vector for (int i = 0; i < pairs.size(); i++) { std::vector<std::string> ps; Utils::split(pairs.at(i), ps, ','); points.push_back(Vector2(std::stoi(ps.at(0)), std::stoi(ps.at(1)))); } } for (int i = 0; i < points.size(); i += 2) { this->_slopes.push_back(Slope( Vector2((p1.x + points.at(i < 2 ? i : i - 1).x) * globals::SPRITE_SCALE, (p1.y + points.at(i < 2 ? i : i - 1).y) * globals::SPRITE_SCALE), Vector2((p1.x + points.at(i < 2 ? i + 1 : i).x) * globals::SPRITE_SCALE, (p1.y + points.at(i < 2 ? i + 1 : i).y) * globals::SPRITE_SCALE) )); } pObject = pObject->NextSiblingElement("object"); } } } else if (ss.str() == "spawn points") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if (pObject != NULL) { while (pObject) { float x = pObject->FloatAttribute("x"); float y = pObject->FloatAttribute("y"); const char* name = pObject->Attribute("name"); std::stringstream ss; ss << name; if (ss.str() == "player") { this->_spawnPoint = Vector2(std::ceil(x) * globals::SPRITE_SCALE, std::ceil(y) * globals::SPRITE_SCALE); } pObject = pObject->NextSiblingElement("object"); } } } pObjectGroup = pObjectGroup->NextSiblingElement("objectgroup"); } } }
int Configure::load(const string& xmlpath) { if (m_doc.LoadFile(xmlpath.c_str()) != XML_NO_ERROR) { g_sysLog.e("{Configure} can't load xml %s\n", xmlpath.c_str()); return ERR_LDCFG; } XMLElement* rootElement = m_doc.RootElement(); if (rootElement == NULL) { g_sysLog.e("{Configure} can't get root element %s\n", xmlpath.c_str()); return ERR_LDCFG; } else { bool reset = rootElement->IntAttribute("reset"); if (reset) return ERR_LDCFG; int ver = rootElement->IntAttribute("version"); if (ver != CONF_VERSION) return ERR_LDCFG; // Recreate configure.xml } XMLElement* tempElement = rootElement->FirstChildElement("srclan"); if (tempElement && tempElement->GetText()) { m_srcLan = tempElement->GetText(); } tempElement = rootElement->FirstChildElement("detlan"); if (tempElement && tempElement->GetText()) { m_detLan = tempElement->GetText(); } // Loading dictionary vector<string> dictFiles; scanDictDir(dictFiles); XMLElement* dictsElement = rootElement->FirstChildElement("dict"); XMLElement* dictElement = dictsElement->FirstChildElement(); while (dictElement) { struct DictNode dict; const char* textE; int pos; if (dictElement->FirstChildElement("path")) { if ((textE = dictElement->FirstChildElement("path")->GetText()) != NULL) dict.path = textE; } if ((pos = findDict(dict.path, dictFiles)) == -1 ) { dictsElement->DeleteChild(dictElement); dictElement = dictElement->NextSiblingElement(); continue; } dictFiles[pos] = ""; dict.en = dictElement->BoolAttribute("en"); if (dictElement->Attribute("open")) dict.open = string(dictElement->Attribute("open")); if (dictElement->FirstChildElement("srclan")) { if ((textE = dictElement->FirstChildElement("srclan")->GetText()) != NULL) dict.srclan = textE; } if (dictElement->FirstChildElement("detlan")) { if ((textE = dictElement->FirstChildElement("detlan")->GetText()) != NULL) dict.detlan = textE; } if (dictElement->FirstChildElement("name")) { if ((textE = dictElement->FirstChildElement("name")->GetText()) != NULL) dict.name = textE; } if (dictElement->FirstChildElement("summary")) { if ((textE = dictElement->FirstChildElement("summary")->GetText()) != NULL) dict.summary = textE; } m_dictNodes.push_back(dict); dictElement = dictElement->NextSiblingElement(); } vector<string>::iterator iter = dictFiles.begin(); for (; iter != dictFiles.end(); iter++) { if (*iter != "") { struct DictNode d; d.en = true; d.path = *iter; d.name = boost::filesystem::path(d.path).filename().string(); //printf("%s\n",d.name.c_str()); m_dictNodes.push_back(d); } } // Loading dictionary -- end tempElement = rootElement->FirstChildElement(XML_TAG_CWS); if (tempElement) { m_cws.bselection = tempElement->BoolAttribute("selection"); m_cws.bclipboard = tempElement->BoolAttribute("clipboard"); m_cws.bmouse = tempElement->BoolAttribute("mouse"); m_cws.benable = tempElement->BoolAttribute("enable"); m_cws.shortcutKey = tempElement->IntAttribute("shortcutkey"); m_cws.autoCloseEn = tempElement->BoolAttribute("AutoCloseEnable"); m_cws.autoCloseInv= tempElement->IntAttribute("AutoCloseInterval"); } else { m_cws.benable = false; m_cws.bselection = true; m_cws.bmouse = false; m_cws.bclipboard = false; m_cws.shortcutKey = 'g'-'a'; m_cws.autoCloseEn = true; m_cws.autoCloseInv = 1000*10; XMLElement* e = m_doc.NewElement(XML_TAG_CWS); e->SetAttribute("selection", m_cws.bselection); e->SetAttribute("clipboard", m_cws.bclipboard); e->SetAttribute("mouse", m_cws.bmouse); e->SetAttribute("enable", m_cws.benable); e->SetAttribute("shortcutkey", m_cws.shortcutKey); e->SetAttribute("AutoCloseEnable", m_cws.autoCloseEn); e->SetAttribute("AutoCloseInterval",m_cws.autoCloseInv); rootElement->InsertEndChild(e); } tempElement = rootElement->FirstChildElement(XML_TAG_SETTING); if (tempElement) { m_setting.uilanID = tempElement->IntAttribute("uilan"); m_setting.fontsize = tempElement->IntAttribute("fontsize"); m_setting.font = util::XMLUtil::Attribute(tempElement, "font", ""); m_setting.bsystemTray = tempElement->BoolAttribute("systemtray"); } else { m_setting.uilanID = UILAN_NONE; m_setting.fontsize = 10; m_setting.font = ""; m_setting.bsystemTray = true; XMLElement* e = m_doc.NewElement(XML_TAG_SETTING); e->SetAttribute("uilan", m_setting.uilanID); e->SetAttribute("fontsize", m_setting.fontsize); rootElement->InsertEndChild(e); } m_doc.SaveFile(xmlpath.c_str()); return 0; }
void Level::loadMap(std::string mapName, Graphics &graphics) { //Parse the .tmx file XMLDocument doc; std::stringstream ss; ss << "content/maps/" << mapName << ".tmx"; //"Map 1" = content/maps/Map 1.tmx doc.LoadFile(ss.str().c_str()); XMLElement* mapNode = doc.FirstChildElement("map"); //Get the width and the height of the whole map and store it in _size int height,width; mapNode->QueryIntAttribute("width", &width); mapNode->QueryIntAttribute("height",&height); this->_size = Vector2(width,height); //Get the width and the height of the tiles and store it in _tileSize int tileWidth, tileHeight; mapNode->QueryIntAttribute("tilewidth", &tileWidth); mapNode->QueryIntAttribute("tileheight",&tileHeight); this->_tileSize = Vector2(tileWidth,tileHeight); //load tilesets XMLElement* pTileset = mapNode->FirstChildElement("tileset"); if(pTileset != NULL) { while(pTileset) { int firstgid; const char* source = pTileset->FirstChildElement("image")->Attribute("source"); std::string path(source); path = path.substr(3,path.length()); std::stringstream ss; ss << "content/" << path; pTileset->QueryIntAttribute("firstgid", &firstgid); SDL_Texture* tex = SDL_CreateTextureFromSurface(graphics.getRenderer(), graphics.loadImage(ss.str())); this->_tilesets.push_back(Tileset(tex, firstgid)); pTileset = pTileset->NextSiblingElement("tileset"); } } //Loading the layers XMLElement* pLayer = mapNode->FirstChildElement("layer"); if(pLayer != NULL) { while(pLayer) { //Loading the data element XMLElement* pData = pLayer->FirstChildElement("data"); if(pData != NULL) { while(pData){ //Loading the tile element XMLElement* pTile = pData->FirstChildElement("tile"); if(pTile != NULL) { int tileCounter = 0; while(pTile){ //Build each individual tile here //if gid is 0, no tile should be drawn. Continue loop if(pTile->IntAttribute("gid") == 0){ tileCounter++; if(pTile->NextSiblingElement("tile")){ pTile = pTile->NextSiblingElement("tile"); continue; } else { break; } } //Get the tileset for this specific gid int gid = pTile->IntAttribute("gid"); Tileset tls; for(int i = 0; i < this->_tilesets.size(); i++) { if(this->_tilesets[i].FirstGid <= gid) { //This is the tileset we want tls = this->_tilesets.at(i); break; } } if(tls.FirstGid == -1) { //No tileset was found for this gid tileCounter++; if(pTile->NextSiblingElement("tile")) { pTile = pTile->NextSiblingElement("tile"); continue; } else{ break; } } //Get the position of the tile in the level int xx = 0; int yy = 0; xx = tileCounter % width; xx = xx * tileWidth; yy = yy + (tileHeight * (tileCounter/width)); Vector2 finalTilePosition = Vector2(xx,yy); //Calculate the position of the tile in the tileset int tilesetWidth, tilesetHeight; SDL_QueryTexture(tls.Texture, NULL, NULL, &tilesetWidth, &tilesetHeight); int tsxx = gid % (tilesetWidth / tileWidth) - 1; tsxx = tsxx * tileWidth; int tsyy = 0; int amt = (gid / (tilesetWidth / tileWidth)); tsyy = tileHeight * amt; Vector2 finalTilesetPosition = Vector2(tsxx, tsyy); //Build the actual tile and add it to the level's tile list Tile tile(tls.Texture, Vector2(tileWidth, tileHeight), finalTilesetPosition, finalTilePosition); this->_tileList.push_back(tile); tileCounter++; pTile = pTile->NextSiblingElement("tile"); } } pData = pData->NextSiblingElement("data"); } } pLayer = pLayer->NextSiblingElement("layer"); } } //Parse out the collisions XMLElement* pObjectGroup = mapNode->FirstChildElement("objectgroup"); if(pObjectGroup != NULL){ while(pObjectGroup) { const char* name = pObjectGroup->Attribute("name"); std::stringstream ss; ss << name; if(ss.str() == "collisions") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if(pObject != NULL){ while(pObject) { float x, y, width, height; x = pObject->FloatAttribute("x"); y = pObject->FloatAttribute("y"); width = pObject->FloatAttribute("width"); height = pObject->FloatAttribute("height"); this->_collisionRects.push_back(Rectangle( std::ceil(x) * globals::SPRITE_SCALE, std::ceil(y) * globals::SPRITE_SCALE, std::ceil(width) * globals::SPRITE_SCALE, std::ceil(height) * globals::SPRITE_SCALE )); pObject = pObject->NextSiblingElement("object"); } } }else if(ss.str() == "spawn points") { XMLElement* pObject = pObjectGroup->FirstChildElement("object"); if(pObject != NULL) { while(pObject) { float x = pObject->FloatAttribute("x"); float y = pObject->FloatAttribute("y"); const char* name = pObject->Attribute("name"); std::stringstream ss; ss << name; if(ss.str() == "player") { this->_spawnPoint = Vector2(std::ceil(x) * globals::SPRITE_SCALE, std::ceil(y) * globals::SPRITE_SCALE); } pObject = pObject->NextSiblingElement("object"); } } } //Other objectgroups go here with an else if (ss.str() == "whatevs son") { pObjectGroup = pObjectGroup->NextSiblingElement("objectgroup"); } } }