void Player::setTagPosition(int x, int y){ auto spriteSize = m_node->getContentSize(); Vec2 dstPos = Vec2(x + spriteSize.width / 2, y); Vec2 tiledPos = tileCoorForPosition(Vec2(dstPos.x, dstPos.y)); int tiledGid = meta->getTileGIDAt(tiledPos); if (tiledGid != 0){ Value properties = m_map->getPropertiesForGID(tiledGid); ValueMap propertiesMap = properties.asValueMap(); if (propertiesMap.find("Collidable") != propertiesMap.end()){ Value prop = propertiesMap.at("Collidable"); if (prop.asString().compare("true") == 0){ return; } } if (propertiesMap.find("food") != propertiesMap.end()){ Value prop = propertiesMap.at("food"); if (prop.asString().compare("true") == 0){ TMXLayer* barrier = m_map->getLayer("barrier"); barrier->removeTileAt(tiledPos); } } } Entity::setTagPosition(x, y); setViewPointByPlayer(); }
void AnimationCache::addAnimationsWithDictionary(const ValueMap& dictionary,const std::string& plist) { if ( dictionary.find("animations") == dictionary.end() ) { CCLOG("cocos2d: AnimationCache: No animations were found in provided dictionary."); return; } const Value& animations = dictionary.at("animations"); unsigned int version = 1; if( dictionary.find("properties") != dictionary.end() ) { const ValueMap& properties = dictionary.at("properties").asValueMap(); version = properties.at("format").asInt(); const ValueVector& spritesheets = properties.at("spritesheets").asValueVector(); for(const auto &value : spritesheets) { std::string path = FileUtils::getInstance()->fullPathFromRelativeFile(value.asString(),plist); SpriteFrameCache::getInstance()->addSpriteFramesWithFile(path); } } switch (version) { case 1: parseVersion1(animations.asValueMap()); break; case 2: parseVersion2(animations.asValueMap()); break; default: CCASSERT(false, "Invalid animation format"); } }
bool BrokableWall::init( const ValueMap &valueMap , const ValueMap &gidProperties ) { if (!BaseEntity::initWithMap(valueMap )) return false; //std::string img = Utils::getWallByType(this->m_nType); std::string img = gidProperties.find("source")->second.asString(); m_durability = gidProperties.find("durability")->second.asInt(); if (!BaseEntity::initWithFile(img)) return false; setPositionAndRotation(); this->setPhysicsBody(PhysicsBody::createEdgeBox(this->getContentSize(), PhysicsMaterial(1.0f, 0.4f, 1.0f), 0));//ÃÜ¶È µ¯Á¦ Ħ²ÁÁ¦ setContactTestBitmask(0x0002); setEntityType(Type_Brokable); return true; }
// // load file // void Configuration::loadConfigFile(const std::string& filename) { ValueMap dict = FileUtils::getInstance()->getValueMapFromFile(filename); CCASSERT(!dict.empty(), "cannot create dictionary"); // search for metadata bool validMetadata = false; auto metadataIter = dict.find("metadata"); if (metadataIter != dict.cend() && metadataIter->second.getType() == Value::Type::MAP) { const auto& metadata = metadataIter->second.asValueMap(); auto formatIter = metadata.find("format"); if (formatIter != metadata.cend()) { int format = formatIter->second.asInt(); // Support format: 1 if (format == 1) { validMetadata = true; } } } if (! validMetadata) { CCLOG("Invalid config format for file: %s", filename.c_str()); return; } auto dataIter = dict.find("data"); if (dataIter == dict.cend() || dataIter->second.getType() != Value::Type::MAP) { CCLOG("Expected 'data' dict, but not found. Config file: %s", filename.c_str()); return; } // Add all keys in the existing dictionary const auto& dataMap = dataIter->second.asValueMap(); for (auto dataMapIter = dataMap.cbegin(); dataMapIter != dataMap.cend(); ++dataMapIter) { if (_valueDict.find(dataMapIter->first) == _valueDict.cend()) _valueDict[dataMapIter->first] = dataMapIter->second; else CCLOG("Key already present. Ignoring '%s'",dataMapIter->first.c_str()); } }
EntityParameterLevel UserDataManager::getEntityParameterLevel(EntityType entityType) { this->load(); // Return initial params if there are no data for entity parameters if (this->userData.find(USER_DATA_ENTITY_PARAMETER) == this->userData.end()) { EntityParameterLevel parameterLevel = ENTITY_INITIAL_LEVEL_PARAMETER.at(entityType); return parameterLevel; } std::string entityTypeString = std::to_string((int)entityType); ValueMap entityListParameterMap = this->userData[USER_DATA_ENTITY_PARAMETER].asValueMap(); // Return initial params if there are no data for a selected entity if (entityListParameterMap.find(entityTypeString) == this->userData.end()) { EntityParameterLevel parameterLevel = ENTITY_INITIAL_LEVEL_PARAMETER.at(entityType); return parameterLevel; } ValueMap data = entityListParameterMap[entityTypeString].asValueMap(); return EntityParameterLevel { data["rank"].asInt(), data["levelHp"].asInt(), data["levelAttack"].asInt(), }; }
void UserDataManager::setEntityParameterLevel(EntityType entityType, EntityParameterLevel EntityParameterLevel) { ValueMap entityListParameterMap; if (this->userData.find(USER_DATA_ENTITY_PARAMETER) == this->userData.end()) { entityListParameterMap = ValueMap(); } else { entityListParameterMap = this->userData[USER_DATA_ENTITY_PARAMETER].asValueMap(); } std::string entityTypeString = this->getEntityTypeStringByEntityType(entityType); ValueMap entityParameterMap; if (entityListParameterMap.find(entityTypeString) == entityListParameterMap.end()) { entityParameterMap = ValueMap(); } else { entityParameterMap = entityListParameterMap[entityTypeString].asValueMap(); } entityParameterMap["rank"] = EntityParameterLevel.rank; entityParameterMap["levelHp"] = EntityParameterLevel.hp; entityParameterMap["levelAttack"] = EntityParameterLevel.attack; entityListParameterMap[entityTypeString] = entityParameterMap; this->userData[USER_DATA_ENTITY_PARAMETER] = entityListParameterMap; this->save(); }
void AppRequests::didFetchAppRequests(const Vector<screw::facebook::GraphRequest *> &requests) { for (GraphRequest *request : requests) { string dataStr = request->getDataString(); Value &v = request->getValue(); FB_LOG_INFO("AppRequests::didFetchAppRequests - data str = %s", dataStr.c_str()); if (dataStr.length()) { ValueMap m; if (JsonUtils::parse(dataStr, m)) { if (m.find(AppRequestsDataTypeKey) == m.end()) { FB_LOG("AppRequests::didFetchAppRequests - request data with no type (be aware) %s", v.getDescription().c_str()); } ValueSetter::set(v, "data", Value(m)); FB_LOG("AppRequests::didFetchAppRequests - parsed data = %s", Value(m).getDescription().c_str()); } else { FB_LOG("AppRequests::didFetchAppRequests - non JSON request data (cleared) %s", v.getDescription().c_str()); ValueSetter::clear(v, "data"); } } _data->set(AppRequestsRequestsKey + "/" + request->getId(), v); //Delete request Request::requestForDelete(request->getId(), nullptr)->execute(); } if (requests.size()) { _data->save(); } }
DayRecord* DayRecords::getDayRecord(int day) { if (_day_records.find(day) == _day_records.end()) { DayRecord* day_rec = new DayRecord(day); std::string filepath = DayRecords::getDataPath(); if (FileUtils::getInstance()->isFileExist(filepath)) { ValueMap data = FileUtils::getInstance()->getValueMapFromFile(filepath); std::string strday = StringUtils::format("%d", day); if (data.find(strday) != data.end()) { ValueMap daydata = data[strday].asValueMap(); day_rec->loadFromValueMap(daydata); _day_records[day] = *day_rec; return &_day_records[day]; } } } else { return &_day_records[day]; } DayRecord* day_rec = new DayRecord(day); _day_records[day] = *day_rec; return &_day_records[day]; }
bool SpriteFrameCache::reloadTexture(const std::string& plist) { CCASSERT(plist.size()>0, "plist filename should not be nullptr"); auto it = _loadedFileNames->find(plist); if (it != _loadedFileNames->end()) { _loadedFileNames->erase(it); } else { //If one plist has't be loaded, we don't load it here. return false; } std::string fullPath = FileUtils::getInstance()->fullPathForFilename(plist); ValueMap dict = FileUtils::getInstance()->getValueMapFromFile(fullPath); string texturePath(""); if (dict.find("metadata") != dict.end()) { ValueMap& metadataDict = dict["metadata"].asValueMap(); // try to read texture file name from meta data texturePath = metadataDict["textureFileName"].asString(); } if (!texturePath.empty()) { // build texture path relative to plist file texturePath = FileUtils::getInstance()->fullPathFromRelativeFile(texturePath, plist); } else { // build texture path by replacing file extension texturePath = plist; // remove .xxx size_t startPos = texturePath.find_last_of("."); texturePath = texturePath.erase(startPos); // append .png texturePath = texturePath.append(".png"); } Texture2D *texture = nullptr; if (Director::getInstance()->getTextureCache()->reloadTexture(texturePath)) texture = Director::getInstance()->getTextureCache()->getTextureForKey(texturePath); if (texture) { reloadSpriteFramesWithDictionary(dict, texture); _loadedFileNames->insert(plist); } else { CCLOG("cocos2d: SpriteFrameCache: Couldn't load texture"); } return true; }
/// UpdateCallGraphAfterInlining - Once we have cloned code over from a callee /// into the caller, update the specified callgraph to reflect the changes we /// made. Note that it's possible that not all code was copied over, so only /// some edges of the callgraph may remain. static void UpdateCallGraphAfterInlining(CallSite CS, Function::iterator FirstNewBlock, ValueMap<const Value*, Value*> &VMap, InlineFunctionInfo &IFI) { CallGraph &CG = *IFI.CG; const Function *Caller = CS.getInstruction()->getParent()->getParent(); const Function *Callee = CS.getCalledFunction(); CallGraphNode *CalleeNode = CG[Callee]; CallGraphNode *CallerNode = CG[Caller]; // Since we inlined some uninlined call sites in the callee into the caller, // add edges from the caller to all of the callees of the callee. CallGraphNode::iterator I = CalleeNode->begin(), E = CalleeNode->end(); // Consider the case where CalleeNode == CallerNode. CallGraphNode::CalledFunctionsVector CallCache; if (CalleeNode == CallerNode) { CallCache.assign(I, E); I = CallCache.begin(); E = CallCache.end(); } for (; I != E; ++I) { const Value *OrigCall = I->first; ValueMap<const Value*, Value*>::iterator VMI = VMap.find(OrigCall); // Only copy the edge if the call was inlined! if (VMI == VMap.end() || VMI->second == 0) continue; // If the call was inlined, but then constant folded, there is no edge to // add. Check for this case. Instruction *NewCall = dyn_cast<Instruction>(VMI->second); if (NewCall == 0) continue; // Remember that this call site got inlined for the client of // InlineFunction. IFI.InlinedCalls.push_back(NewCall); // It's possible that inlining the callsite will cause it to go from an // indirect to a direct call by resolving a function pointer. If this // happens, set the callee of the new call site to a more precise // destination. This can also happen if the call graph node of the caller // was just unnecessarily imprecise. if (I->second->getFunction() == 0) if (Function *F = CallSite(NewCall).getCalledFunction()) { // Indirect call site resolved to direct call. CallerNode->addCalledFunction(CallSite::get(NewCall), CG[F]); continue; } CallerNode->addCalledFunction(CallSite::get(NewCall), I->second); } // Update the call graph by deleting the edge from Callee to Caller. We must // do this after the loop above in case Caller and Callee are the same. CallerNode->removeCallEdgeFor(CS); }
void SpriteFrameCache::addSpriteFramesWithFile(const std::string& plist) { CCASSERT(plist.size()>0, "plist filename should not be nullptr"); std::string fullPath = FileUtils::getInstance()->fullPathForFilename(plist); if (fullPath.size() == 0) { // return if plist file doesn't exist CCLOG("cocos2d: SpriteFrameCache: can not find %s", plist.c_str()); return; } if (_loadedFileNames->find(plist) == _loadedFileNames->end()) { ValueMap dict = FileUtils::getInstance()->getValueMapFromFile(fullPath); string texturePath(""); if (dict.find("metadata") != dict.end()) { ValueMap& metadataDict = dict["metadata"].asValueMap(); // try to read texture file name from meta data texturePath = metadataDict["textureFileName"].asString(); } if (!texturePath.empty()) { // build texture path relative to plist file texturePath = FileUtils::getInstance()->fullPathFromRelativeFile(texturePath.c_str(), plist); } else { // build texture path by replacing file extension texturePath = plist; // remove .xxx size_t startPos = texturePath.find_last_of("."); texturePath = texturePath.erase(startPos); // append .png texturePath = texturePath.append(".png"); CCLOG("cocos2d: SpriteFrameCache: Trying to use file %s as texture", texturePath.c_str()); } Texture2D *texture = Director::getInstance()->getTextureCache()->addImage(texturePath.c_str()); if (texture) { addSpriteFramesWithDictionary(dict, texture); _loadedFileNames->insert(plist); } else { CCLOG("cocos2d: SpriteFrameCache: Couldn't load texture"); } } }
/// RemapInstruction - Convert the instruction operands from referencing the /// current values into those specified by VMap. static inline void RemapInstruction(Instruction *I, ValueMap<const Value *, Value*> &VMap) { for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { Value *Op = I->getOperand(op); ValueMap<const Value *, Value*>::iterator It = VMap.find(Op); if (It != VMap.end()) I->setOperand(op, It->second); } }
void *valmap_find(valmap_t map, LLVMValueRef v) { ValueMap<Value*,void*> *vmap = (ValueMap<Value*,void*>*)map; Value *val = unwrap(v); if(vmap->find(val)==vmap->end()) return NULL; return (*vmap)[val]; }
void WorldLayer::setPlayerPosition(Point position) { Point tileCoord = this->tileCoordForPosition(position); int tileFUCKEDUP = _meta->getTileGIDAt(tileCoord); if(tileFUCKEDUP) { Value shit = map->getPropertiesForGID(tileFUCKEDUP); ValueMap doubleShit = shit.asValueMap(); auto temp = doubleShit.find("Collidable"); CCLOG(( temp->second.asBool() ? "Yes" : "No" )); } p1->setPosition(position); }
void SpriteFrameCache::addSpriteFramesWithDictionary(ValueMap& dict, const std::string &texturePath) { std::string pixelFormatName; if (dict.find("metadata") != dict.end()) { ValueMap& metadataDict = dict.at("metadata").asValueMap(); if (metadataDict.find("pixelFormat") != metadataDict.end()) { pixelFormatName = metadataDict.at("pixelFormat").asString(); } } Texture2D *texture = nullptr; static std::unordered_map<std::string, Texture2D::PixelFormat> pixelFormats = { {"RGBA8888", Texture2D::PixelFormat::RGBA8888}, {"RGBA4444", Texture2D::PixelFormat::RGBA4444}, {"RGB5A1", Texture2D::PixelFormat::RGB5A1}, {"RGBA5551", Texture2D::PixelFormat::RGB5A1}, {"RGB565", Texture2D::PixelFormat::RGB565}, {"A8", Texture2D::PixelFormat::A8}, {"ALPHA", Texture2D::PixelFormat::A8}, {"I8", Texture2D::PixelFormat::I8}, {"AI88", Texture2D::PixelFormat::AI88}, {"ALPHA_INTENSITY", Texture2D::PixelFormat::AI88}, //{"BGRA8888", Texture2D::PixelFormat::BGRA8888}, no Image conversion RGBA -> BGRA {"RGB888", Texture2D::PixelFormat::RGB888} }; auto pixelFormatIt = pixelFormats.find(pixelFormatName); if (pixelFormatIt != pixelFormats.end()) { const Texture2D::PixelFormat pixelFormat = (*pixelFormatIt).second; const Texture2D::PixelFormat currentPixelFormat = Texture2D::getDefaultAlphaPixelFormat(); Texture2D::setDefaultAlphaPixelFormat(pixelFormat); texture = Director::getInstance()->getTextureCache()->addImage(texturePath); Texture2D::setDefaultAlphaPixelFormat(currentPixelFormat); } else { texture = Director::getInstance()->getTextureCache()->addImage(texturePath); } if (texture) { addSpriteFramesWithDictionary(dict, texture); } else { CCLOG("cocos2d: SpriteFrameCache: Couldn't load texture"); } }
void DayRecord::loadFromValueMap(ValueMap &map) { _day = map["day"].asInt(); _earned = map["earned"].asDouble(); _spent = map["spent"].asDouble(); _money = map["money"].asFloat(); _diamond = map["diamond"].asInt(); _reputation = map["reputation"].asFloat(); _soldItems.clear(); if (map.find("sold_items") != map.end()) { for (auto iter: map["sold_items"].asValueMap()) { _soldItems[iter.first] = iter.second.asInt(); } } _boughtItems.clear(); if (map.find("bought_items") != map.end()) { for (auto iter: map["bought_items"].asValueMap()) { _boughtItems[iter.first] = iter.second.asInt(); } } }
bool YellowWall::init( const ValueMap &valueMap, const ValueMap & gidProperties ) { if (!BaseEntity::initWithMap(valueMap)) return false; //std::string img = Utils::getWallByType(this->m_nType); std::string img = gidProperties.find("source")->second.asString(); if (!BaseEntity::initWithFile(img)) return false; setPositionAndRotation(); std::string type = gidProperties.find("type")->second.asString(); if (type == "target") { this->setPhysicsBody(PhysicsBody::createEdgeBox(this->getContentSize(), PhysicsMaterial(1.0f, 0.2f, 1.0f), 0)); this->setContactTestBitmask(0x0001); setEntityType(Type_Yellow); } else if (type == "flag") { this->playFlagAnimate(); this->setPhysicsBody(PhysicsBody::createEdgeBox(this->getContentSize())); this->setContactTestBitmask(0x0002); setEntityType(Type_Flag); } return true; }
void HelloWorld::setPlayerPosition(Point position) { // This part is completely different from version 2.X // There might be a better way to do this since this is what made sense // in the moment cocos2d::Point tileCoord = this->tileCoordForPosition(position); int tileFUCKEDUP = _meta->tileGIDAt(tileCoord); if(tileFUCKEDUP) { Value shit = _tileMap->propertiesForGID(tileFUCKEDUP); ValueMap doubleShit = shit.asValueMap(); auto temp = doubleShit.find("Collidable"); CCLOG(( temp->second.asBool() ? "Yes" : "No" )); } _player->setPosition(position); }
const std::string &getValue(const std::string &name, const std::string &defaultValue) const { ValueMap::const_iterator it = values.find(name); if(it == values.end()) { if ((flags & VALUEMAP_MASK_LOG_NONEXISTING) != 0) { std::string msg = std::string("ParserGroupData::getValue - Given key \""); msg += name; msg += std::string("\" does not exist, returning default value."); Logger::getInstance()->warning(msg.c_str()); } return defaultValue; } int *flag = const_cast<int *>(&((*it).second.second)); *flag |= VALUEMAP_MASK_REFERENCED; return (*it).second.first; }
string paramValueNumber(AstNode* nodep) { // Given a compilcated object create a number to use for param module assignment // Ideally would be relatively stable if design changes (not use pointer value), // and must return same value given same input node // Return must presently be numberic so doesn't collide with 'small' alphanumeric parameter names ValueMap::iterator it = m_valueMap.find(nodep); if (it != m_valueMap.end()) { return cvtToStr(it->second); } else { static int BUCKETS = 1000; V3Hash hash (nodep->name()); int bucket = hash.hshval() % BUCKETS; int offset = 0; NextValueMap::iterator it = m_nextValueMap.find(bucket); if (it != m_nextValueMap.end()) { offset = it->second; it->second = offset + 1; } else { m_nextValueMap.insert(make_pair(bucket, offset + 1)); } int num = bucket + offset * BUCKETS; m_valueMap.insert(make_pair(nodep, num)); return cvtToStr(num); } }
bool Session::snmpGet( const Identifier &identifier, Value &value, ErrorInfo *error ) { ValueMap vars; IdentifierList ids; ids << identifier; if ( !snmpGet( ids, vars, error ) ) return false; ValueMap::ConstIterator it = vars.find( identifier ); if ( it == vars.end() ) { if ( error ) *error = ErrorInfo( ErrorInfo::ErrMissingVariables ); return false; } value = it.data(); return true; }
// Try to clone everything in the llvm::Value hierarchy. LLVMValueRef CloneValue(LLVMValueRef Src) { // First, the value may be constant. if (LLVMIsAConstant(Src)) return clone_constant(Src, M); // Function argument should always be in the map already. auto i = VMap.find(Src); if (i != VMap.end()) return i->second; if (!LLVMIsAInstruction(Src)) report_fatal_error("Expected an instruction"); auto Ctx = LLVMGetModuleContext(M); auto Builder = LLVMCreateBuilderInContext(Ctx); auto BB = DeclareBB(LLVMGetInstructionParent(Src)); LLVMPositionBuilderAtEnd(Builder, BB); auto Dst = CloneInstruction(Src, Builder); LLVMDisposeBuilder(Builder); return Dst; }
bool EventTrigger::init( class MapLogic* map_logic, const ValueMap& event_data ) { this->setMapLogic( map_logic ); _current_trigger_index = 0; _should_recycle = false; _event_data = event_data; const ValueMap& meta_data = event_data.at( "trigger_meta" ).asValueMap(); auto itr = meta_data.find( "trigger_relation" ); if( itr == meta_data.end() ) { _relation = "then"; } else { _relation = itr->second.asString(); } itr = meta_data.find( "is_repeated" ); if( itr == meta_data.end() ) { _is_repeat = false; } else { _is_repeat = itr->second.asBool(); } itr = event_data.find( "enabled" ); if( itr != event_data.end() ) { this->setEnabled( itr->second.asBool() ); } else { this->setEnabled( true ); } const ValueVector& trigger_data = event_data.at( "triggers" ).asValueVector(); _total_trigger_count = (int)trigger_data.size(); for( auto itr = trigger_data.begin(); itr != trigger_data.end(); ++itr ) { Trigger* trigger = Trigger::create( itr->asValueMap() ); this->addTrigger( trigger ); } return true; }
void TmxMapHelper::objectToVertices(int mapHeihgt, int groupHeight, ValueMap &object, vector<float> &vertices) { auto it = object.find("points"); if (it == object.end()) return; Vec2 origin(object["x"].asInt(), object["y"].asInt()); origin.y = mapHeihgt - origin.y; ValueVector &points = it->second.asValueVector(); vertices.clear(); vertices.reserve(points.size() * 2); for (size_t i = 0; i < points.size(); ++i) { ValueMap &point = points[i].asValueMap(); float x = origin.x + point["x"].asInt(); float y = groupHeight - (origin.y + point["y"].asInt()); vertices.push_back(x); vertices.push_back(y); } }
const Value * AMDGPUDAGToDAGISel::getBasePointerValue(const Value *V) { if (!V) { return NULL; } const Value *ret = NULL; ValueMap<const Value *, bool> ValueBitMap; std::queue<const Value *, std::list<const Value *> > ValueQueue; ValueQueue.push(V); while (!ValueQueue.empty()) { V = ValueQueue.front(); if (ValueBitMap.find(V) == ValueBitMap.end()) { ValueBitMap[V] = true; if (dyn_cast<Argument>(V) && dyn_cast<PointerType>(V->getType())) { ret = V; break; } else if (dyn_cast<GlobalVariable>(V)) { ret = V; break; } else if (dyn_cast<Constant>(V)) { const ConstantExpr *CE = dyn_cast<ConstantExpr>(V); if (CE) { ValueQueue.push(CE->getOperand(0)); } } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { ret = AI; break; } else if (const Instruction *I = dyn_cast<Instruction>(V)) { uint32_t numOps = I->getNumOperands(); for (uint32_t x = 0; x < numOps; ++x) { ValueQueue.push(I->getOperand(x)); } } else { assert(!"Found a Value that we didn't know how to handle!"); } } ValueQueue.pop(); } return ret; }
bool ParticleSystem::initWithDictionary(ValueMap& dictionary, const std::string& dirname) { bool ret = false; unsigned char *buffer = nullptr; unsigned char *deflated = nullptr; Image *image = nullptr; do { int maxParticles = dictionary["maxParticles"].asInt(); // self, not super if(this->initWithTotalParticles(maxParticles)) { // Emitter name in particle designer 2.0 _configName = dictionary["configName"].asString(); // angle _angle = dictionary["angle"].asFloat(); _angleVar = dictionary["angleVariance"].asFloat(); // duration _duration = dictionary["duration"].asFloat(); // blend function if (_configName.length()>0) { _blendFunc.src = dictionary["blendFuncSource"].asFloat(); } else { _blendFunc.src = dictionary["blendFuncSource"].asInt(); } _blendFunc.dst = dictionary["blendFuncDestination"].asInt(); // color _startColor.r = dictionary["startColorRed"].asFloat(); _startColor.g = dictionary["startColorGreen"].asFloat(); _startColor.b = dictionary["startColorBlue"].asFloat(); _startColor.a = dictionary["startColorAlpha"].asFloat(); _startColorVar.r = dictionary["startColorVarianceRed"].asFloat(); _startColorVar.g = dictionary["startColorVarianceGreen"].asFloat(); _startColorVar.b = dictionary["startColorVarianceBlue"].asFloat(); _startColorVar.a = dictionary["startColorVarianceAlpha"].asFloat(); _endColor.r = dictionary["finishColorRed"].asFloat(); _endColor.g = dictionary["finishColorGreen"].asFloat(); _endColor.b = dictionary["finishColorBlue"].asFloat(); _endColor.a = dictionary["finishColorAlpha"].asFloat(); _endColorVar.r = dictionary["finishColorVarianceRed"].asFloat(); _endColorVar.g = dictionary["finishColorVarianceGreen"].asFloat(); _endColorVar.b = dictionary["finishColorVarianceBlue"].asFloat(); _endColorVar.a = dictionary["finishColorVarianceAlpha"].asFloat(); // particle size _startSize = dictionary["startParticleSize"].asFloat(); _startSizeVar = dictionary["startParticleSizeVariance"].asFloat(); _endSize = dictionary["finishParticleSize"].asFloat(); _endSizeVar = dictionary["finishParticleSizeVariance"].asFloat(); // position float x = dictionary["sourcePositionx"].asFloat(); float y = dictionary["sourcePositiony"].asFloat(); this->setPosition( Point(x,y) ); _posVar.x = dictionary["sourcePositionVariancex"].asFloat(); _posVar.y = dictionary["sourcePositionVariancey"].asFloat(); // Spinning _startSpin = dictionary["rotationStart"].asFloat(); _startSpinVar = dictionary["rotationStartVariance"].asFloat(); _endSpin= dictionary["rotationEnd"].asFloat(); _endSpinVar= dictionary["rotationEndVariance"].asFloat(); _emitterMode = (Mode) dictionary["emitterType"].asInt(); // Mode A: Gravity + tangential accel + radial accel if (_emitterMode == Mode::GRAVITY) { // gravity modeA.gravity.x = dictionary["gravityx"].asFloat(); modeA.gravity.y = dictionary["gravityy"].asFloat(); // speed modeA.speed = dictionary["speed"].asFloat(); modeA.speedVar = dictionary["speedVariance"].asFloat(); // radial acceleration modeA.radialAccel = dictionary["radialAcceleration"].asFloat(); modeA.radialAccelVar = dictionary["radialAccelVariance"].asFloat(); // tangential acceleration modeA.tangentialAccel = dictionary["tangentialAcceleration"].asFloat(); modeA.tangentialAccelVar = dictionary["tangentialAccelVariance"].asFloat(); // rotation is dir modeA.rotationIsDir = dictionary["rotationIsDir"].asBool(); } // or Mode B: radius movement else if (_emitterMode == Mode::RADIUS) { if (_configName.length()>0) { modeB.startRadius = dictionary["maxRadius"].asInt(); } else { modeB.startRadius = dictionary["maxRadius"].asFloat(); } modeB.startRadiusVar = dictionary["maxRadiusVariance"].asFloat(); if (_configName.length()>0) { modeB.endRadius = dictionary["minRadius"].asInt(); } else { modeB.endRadius = dictionary["minRadius"].asFloat(); } if (dictionary.find("minRadiusVariance") != dictionary.end()) { modeB.endRadiusVar = dictionary["minRadiusVariance"].asFloat(); } else { modeB.endRadiusVar = 0.0f; } if (_configName.length()>0) { modeB.rotatePerSecond = dictionary["rotatePerSecond"].asInt(); } else { modeB.rotatePerSecond = dictionary["rotatePerSecond"].asFloat(); } modeB.rotatePerSecondVar = dictionary["rotatePerSecondVariance"].asFloat(); } else { CCASSERT( false, "Invalid emitterType in config file"); CC_BREAK_IF(true); } // life span _life = dictionary["particleLifespan"].asFloat(); _lifeVar = dictionary["particleLifespanVariance"].asFloat(); // emission Rate _emissionRate = _totalParticles / _life; //don't get the internal texture if a batchNode is used if (!_batchNode) { // Set a compatible default for the alpha transfer _opacityModifyRGB = false; // texture // Try to get the texture from the cache std::string textureName = dictionary["textureFileName"].asString(); size_t rPos = textureName.rfind('/'); if (rPos != string::npos) { string textureDir = textureName.substr(0, rPos + 1); if (!dirname.empty() && textureDir != dirname) { textureName = textureName.substr(rPos+1); textureName = dirname + textureName; } } else if (!dirname.empty() && !textureName.empty()) { textureName = dirname + textureName; } Texture2D *tex = nullptr; if (textureName.length() > 0) { // set not pop-up message box when load image failed bool notify = FileUtils::getInstance()->isPopupNotify(); FileUtils::getInstance()->setPopupNotify(false); tex = Director::getInstance()->getTextureCache()->addImage(textureName); // reset the value of UIImage notify FileUtils::getInstance()->setPopupNotify(notify); } if (tex) { setTexture(tex); } else { std::string textureData = dictionary["textureImageData"].asString(); CCASSERT(!textureData.empty(), ""); auto dataLen = textureData.size(); if (dataLen != 0) { // if it fails, try to get it from the base64-gzipped data int decodeLen = base64Decode((unsigned char*)textureData.c_str(), (unsigned int)dataLen, &buffer); CCASSERT( buffer != nullptr, "CCParticleSystem: error decoding textureImageData"); CC_BREAK_IF(!buffer); ssize_t deflatedLen = ZipUtils::inflateMemory(buffer, decodeLen, &deflated); CCASSERT( deflated != nullptr, "CCParticleSystem: error ungzipping textureImageData"); CC_BREAK_IF(!deflated); // For android, we should retain it in VolatileTexture::addImage which invoked in Director::getInstance()->getTextureCache()->addUIImage() image = new Image(); bool isOK = image->initWithImageData(deflated, deflatedLen); CCASSERT(isOK, "CCParticleSystem: error init image with Data"); CC_BREAK_IF(!isOK); setTexture(Director::getInstance()->getTextureCache()->addImage(image, textureName.c_str())); image->release(); } } if (!_configName.empty()) { _yCoordFlipped = dictionary["yCoordFlipped"].asInt(); } CCASSERT( this->_texture != nullptr, "CCParticleSystem: error loading the texture"); } ret = true; } } while (0); free(buffer); free(deflated); return ret; }
void SpriteFrameCache::addSpriteFramesWithDictionary(ValueMap& dictionary, Texture2D* texture) { /* Supported Zwoptex Formats: ZWTCoordinatesFormatOptionXMLLegacy = 0, // Flash Version ZWTCoordinatesFormatOptionXML1_0 = 1, // Desktop Version 0.0 - 0.4b ZWTCoordinatesFormatOptionXML1_1 = 2, // Desktop Version 1.0.0 - 1.0.1 ZWTCoordinatesFormatOptionXML1_2 = 3, // Desktop Version 1.0.2+ */ ValueMap& framesDict = dictionary["frames"].asValueMap(); int format = 0; // get the format if (dictionary.find("metadata") != dictionary.end()) { ValueMap& metadataDict = dictionary["metadata"].asValueMap(); format = metadataDict["format"].asInt(); } // check the format CCASSERT(format >=0 && format <= 3, "format is not supported for SpriteFrameCache addSpriteFramesWithDictionary:textureFilename:"); for (auto iter = framesDict.begin(); iter != framesDict.end(); ++iter) { ValueMap& frameDict = iter->second.asValueMap(); std::string spriteFrameName = iter->first; SpriteFrame* spriteFrame = _spriteFrames.at(spriteFrameName); if (spriteFrame) { continue; } if(format == 0) { float x = frameDict["x"].asFloat(); float y = frameDict["y"].asFloat(); float w = frameDict["width"].asFloat(); float h = frameDict["height"].asFloat(); float ox = frameDict["offsetX"].asFloat(); float oy = frameDict["offsetY"].asFloat(); int ow = frameDict["originalWidth"].asInt(); int oh = frameDict["originalHeight"].asInt(); // check ow/oh if(!ow || !oh) { CCLOGWARN("cocos2d: WARNING: originalWidth/Height not found on the SpriteFrame. AnchorPoint won't work as expected. Regenrate the .plist"); } // abs ow/oh ow = abs(ow); oh = abs(oh); // create frame spriteFrame = SpriteFrame::createWithTexture(texture, Rect(x, y, w, h), false, Vec2(ox, oy), Size((float)ow, (float)oh) ); } else if(format == 1 || format == 2) { Rect frame = RectFromString(frameDict["frame"].asString()); bool rotated = false; // rotation if (format == 2) { rotated = frameDict["rotated"].asBool(); } Vec2 offset = PointFromString(frameDict["offset"].asString()); Size sourceSize = SizeFromString(frameDict["sourceSize"].asString()); // create frame spriteFrame = SpriteFrame::createWithTexture(texture, frame, rotated, offset, sourceSize ); } else if (format == 3) { // get values Size spriteSize = SizeFromString(frameDict["spriteSize"].asString()); Vec2 spriteOffset = PointFromString(frameDict["spriteOffset"].asString()); Size spriteSourceSize = SizeFromString(frameDict["spriteSourceSize"].asString()); Rect textureRect = RectFromString(frameDict["textureRect"].asString()); bool textureRotated = frameDict["textureRotated"].asBool(); // get aliases ValueVector& aliases = frameDict["aliases"].asValueVector(); for(const auto &value : aliases) { std::string oneAlias = value.asString(); if (_spriteFramesAliases.find(oneAlias) != _spriteFramesAliases.end()) { CCLOGWARN("cocos2d: WARNING: an alias with name %s already exists", oneAlias.c_str()); } _spriteFramesAliases[oneAlias] = Value(spriteFrameName); } // create frame spriteFrame = SpriteFrame::createWithTexture(texture, Rect(textureRect.origin.x, textureRect.origin.y, spriteSize.width, spriteSize.height), textureRotated, spriteOffset, spriteSourceSize); } // add sprite frame _spriteFrames.insert(spriteFrameName, spriteFrame); } }
int TransportRegistry::load_transport_configuration(const OPENDDS_STRING& file_name, ACE_Configuration_Heap& cf) { const ACE_Configuration_Section_Key &root = cf.root_section(); // Create a vector to hold configuration information so we can populate // them after the transports instances are created. typedef std::pair<TransportConfig_rch, OPENDDS_VECTOR(OPENDDS_STRING) > ConfigInfo; OPENDDS_VECTOR(ConfigInfo) configInfoVec; // Record the transport instances created, so we can place them // in the implicit transport configuration for this file. OPENDDS_LIST(TransportInst_rch) instances; ACE_TString sect_name; for (int index = 0; cf.enumerate_sections(root, index, sect_name) == 0; ++index) { if (ACE_OS::strcmp(sect_name.c_str(), TRANSPORT_SECTION_NAME) == 0) { // found the [transport/*] section, now iterate through subsections... ACE_Configuration_Section_Key sect; if (cf.open_section(root, sect_name.c_str(), 0, sect) != 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("failed to open section %s\n"), sect_name.c_str()), -1); } else { // Ensure there are no properties in this section ValueMap vm; if (pullValues(cf, sect, vm) > 0) { // There are values inside [transport] ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("transport sections must have a section name\n"), sect_name.c_str()), -1); } // Process the subsections of this section (the individual transport // impls). KeyList keys; if (processSections( cf, sect, keys ) != 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("too many nesting layers in [%s] section.\n"), sect_name.c_str()), -1); } for (KeyList::const_iterator it=keys.begin(); it != keys.end(); ++it) { OPENDDS_STRING transport_id = (*it).first; ACE_Configuration_Section_Key inst_sect = (*it).second; ValueMap values; if (pullValues( cf, (*it).second, values ) != 0) { // Get the factory_id for the transport. OPENDDS_STRING transport_type; ValueMap::const_iterator vm_it = values.find("transport_type"); if (vm_it != values.end()) { transport_type = (*vm_it).second; } else { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("missing transport_type in [transport/%C] section.\n"), transport_id.c_str()), -1); } // Create the TransportInst object and load the transport // configuration in ACE_Configuration_Heap to the TransportInst // object. TransportInst_rch inst = this->create_inst(transport_id, transport_type); if (inst == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("Unable to create transport instance in [transport/%C] section.\n"), transport_id.c_str()), -1); } instances.push_back(inst); inst->load(cf, inst_sect); } else { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("missing transport_type in [transport/%C] section.\n"), transport_id.c_str()), -1); } } } } else if (ACE_OS::strcmp(sect_name.c_str(), CONFIG_SECTION_NAME) == 0) { // found the [config/*] section, now iterate through subsections... ACE_Configuration_Section_Key sect; if (cf.open_section(root, sect_name.c_str(), 0, sect) != 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("failed to open section [%s]\n"), sect_name.c_str()), -1); } else { // Ensure there are no properties in this section ValueMap vm; if (pullValues(cf, sect, vm) > 0) { // There are values inside [config] ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("config sections must have a section name\n"), sect_name.c_str()), -1); } // Process the subsections of this section (the individual config // impls). KeyList keys; if (processSections( cf, sect, keys ) != 0) { // Don't allow multiple layers of nesting ([config/x/y]). ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("too many nesting layers in [%s] section.\n"), sect_name.c_str()), -1); } for (KeyList::const_iterator it=keys.begin(); it != keys.end(); ++it) { OPENDDS_STRING config_id = (*it).first; // Create a TransportConfig object. TransportConfig_rch config = this->create_config(config_id); if (config == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("Unable to create transport config in [config/%C] section.\n"), config_id.c_str()), -1); } ValueMap values; pullValues( cf, (*it).second, values ); ConfigInfo configInfo; configInfo.first = config; for (ValueMap::const_iterator it=values.begin(); it != values.end(); ++it) { OPENDDS_STRING name = (*it).first; if (name == "transports") { OPENDDS_STRING value = (*it).second; char delim = ','; size_t pos = 0; OPENDDS_STRING token; while ((pos = value.find(delim)) != OPENDDS_STRING::npos) { token = value.substr(0, pos); configInfo.second.push_back(token); value.erase(0, pos + 1); } configInfo.second.push_back(value); configInfoVec.push_back(configInfo); } else if (name == "swap_bytes") { OPENDDS_STRING value = (*it).second; if ((value == "1") || (value == "true")) { config->swap_bytes_ = true; } else if ((value != "0") && (value != "false")) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("Illegal value for swap_bytes (%C) in [config/%C] section.\n"), value.c_str(), config_id.c_str()), -1); } } else if (name == "passive_connect_duration") { OPENDDS_STRING value = (*it).second; if (!convertToInteger(value, config->passive_connect_duration_)) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("Illegal integer value for passive_connect_duration (%s) in [config/%C] section.\n"), value.c_str(), config_id.c_str()), -1); } } else { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("Unexpected entry (%C) in [config/%C] section.\n"), name.c_str(), config_id.c_str()), -1); } } if (configInfo.second.size() == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("No transport instances listed in [config/%C] section.\n"), config_id.c_str()), -1); } } } } else if (ACE_OS::strncmp(sect_name.c_str(), OLD_TRANSPORT_PREFIX.c_str(), OLD_TRANSPORT_PREFIX.length()) == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ") ACE_TEXT("Obsolete transport configuration found (%s).\n"), sect_name.c_str()), -1); } } // Populate the configurations with instances for (unsigned int i = 0; i < configInfoVec.size(); ++i) { TransportConfig_rch config = configInfoVec[i].first; OPENDDS_VECTOR(OPENDDS_STRING)& insts = configInfoVec[i].second; for (unsigned int j = 0; j < insts.size(); ++j) { TransportInst_rch inst = this->get_inst(insts[j]); if (inst == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("The inst (%C) in [config/%C] section is undefined.\n"), insts[j].c_str(), config->name().c_str()), -1); } config->instances_.push_back(inst); } } // Create and populate the default configuration for this // file with all the instances from this file. if (!instances.empty()) { TransportConfig_rch config = this->create_config(file_name); if (config == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) TransportRegistry::load_transport_configuration: ") ACE_TEXT("Unable to create default transport config.\n"), file_name.c_str()), -1); } instances.sort(predicate); for (OPENDDS_LIST(TransportInst_rch)::const_iterator it = instances.begin(); it != instances.end(); ++it) { config->instances_.push_back(*it); } } return 0; }
bool evaluate(AST_Identifier &exp, ValueMap &valmap) { if (valmap.find(exp.name) != valmap.end()) { return valmap[exp.name]; } return false; }
void ShapeCacher::addShapesWithDictionary(ValueMap &dictionary, PhysicsBody *body) { //decode the plist file int format = 0; // get the format if (dictionary.find("metadata") != dictionary.end()) { ValueMap& metadataDict = dictionary["metadata"].asValueMap(); format = metadataDict["format"].asInt(); } // check the format CCASSERT(format == 1, "format is not supported for #addShapesWithDictionary#:"); ValueMap& bodyDict = dictionary["bodies"].asValueMap(); for (auto iter = bodyDict.begin(); iter != bodyDict.end(); ++iter) { ValueMap& dataDict = iter->second.asValueMap(); /****************not used yet!***********************/ //set anchorpoint //Point anchorPoint = PointFromString(dataDict["anchorpoint"].asString()); ValueVector& fixtureVector = dataDict["fixtures"].asValueVector(); for (auto iter = fixtureVector.begin(); iter != fixtureVector.end(); ++iter) { ValueMap& fixtureDict =(ValueMap&)(*iter).asValueMap(); /****************not used yet!***********************/ /* //body->setCategoryBitmask(fixtureDict["filter_categoryBits"].asInt); /* //body->setCollisionBitmask(fixtureDict["filter_maskBits"].asInt); /* //body->setGroup(fixtureDict["filter_groupIndex"].asInt); /* //float friction = fixtureDict["friction"].asFloat; /* //float density = fixtureDict["density"].asFloat; /* //float restitution = fixtureDict["restitution"].asFloat; /* //int isSensor = fixtureDict["isSensor"].asInt; /* //std::string userdata = fixtureDict["userdataCbValue"].asString; /* /* //std::string fixtureType = fixtureDict["fixture_type"].asString(); /* /* if (fixtureType == "POLYGON") {*/ /****************not used yet!***********************/ ValueVector& polygonsVector = (fixtureDict["polygons"].asValueVector()); for (auto iter = polygonsVector.begin(); iter != polygonsVector.end(); ++iter) { int vertexNum = (*iter).asValueVector().size();; ValueVector polygonArray = (*iter).asValueVector(); Point *polyVertex = new Point[vertexNum]; int i = 0; for (auto piter = polygonArray.begin(); piter != polygonArray.end(), i < vertexNum; ++piter ,i++) { Point vertex = PointFromString((*piter).asString()); polyVertex[i] = vertex; } body->addShape(PhysicsShapePolygon::create(polyVertex, vertexNum)); CC_SAFE_DELETE_ARRAY(polyVertex); } } // else if (fixtureType == "CIRCLE") // { // continue; // //ObjectDict *circleData = (ObjectDict *)fixtureData->objectForKey("circle"); // //b2CircleShape *circleShape = new b2CircleShape(); // //circleShape->m_radius = static_cast<CCString *>(circleData->objectForKey("radius"))->toFloat() / ptmRatio; // //CCPoint p = CCPointFromString(static_cast<CCString *>(circleData->objectForKey("position"))->toStdString().c_str()); // //circleShape->m_p = b2Vec2(p.x / ptmRatio, p.y / ptmRatio); // //fix->fixture.shape = circleShape; // //// create a list // //*nextFixtureDef = fix; // //nextFixtureDef = &(fix->next); // } // else // { // CCAssert(0, "Unknown fixtureType"); // } //} } }