cocos2dx-深度解析plist文件(一)(游戏对象的数据如何从plist创建获取)
cocos2dx的精灵缓存在创建一组精灵帧，加载瓦片地图，普通动画的创建、骨骼动画等等都会通过plist(parameter list)文件获得需要的信息，建立器游戏中需要的类对象。本文从CCSpriteFrameCache读取plist创建精灵帧研究起。其中代码使用到了tinyXML2第三方库，以及SAX(simple api xml)。然后在从精灵帧创建精灵反向研究，plist文件数据的含义。
在分析前先介绍点东西
1、XML简介
下面是一个用于创建一组精灵帧的plist文件，里面描述了每个精灵帧的信息。
frames
1.png
frame
{{2,868},{110,102}}
offset
{1,-15}
rotated
sourceColorRect
{{24,39},{110,102}}
sourceSize
{156,150} 2、tinyXML2
tinyXML2是一个XML解析库，这是tinyXML2作者的官网：http://grinninglizard.com/tinyxml2docs/index.html，这是tinyXML2作者的git库：https://github.com/leethomason/tinyxml2 。tinyXML2只把节点解析为一颗树，每个节点存储的仍旧是原来的文本，没有提供把这些文本转化为其它类型值的接口，不过我们可以通过atoi等接口自己转换，如果你持久化了一个类对象，那么你需要自己实现转换方法根据存储的数据反向生成一个对象。游戏里的二进制也可以存在xml中的，不过没什么可阅读性，cocos用到的创建粒子节点的plist文件可以把图片与粒子描述信息一起存在plist中。
下面是一个对于上面XML文件的部分解析，cocos自带了tinyXML2,可以直接使用它，它们定义在名称空间tinyxml2。
void PlistTest::btnClick(CCObject* pSender, CCControlEvent event){
string filename = CCFileUtils::sharedFileUtils()->fullPathForFilename("shoe.plist");
XMLDocument doc;
doc.LoadFile(filename.c_str());
XMLElement *rootElement = doc.FirstChildElement();//root plist element
XMLElement *dicts = rootElement->FirstChildElement("dict")->FirstChildElement("dict");
XMLElement *child = dicts->FirstChildElement("dict")->FirstChildElement();
while (child) {
printf("%s\n", child->GetText());
child = child->NextSiblingElement();
}
}frame
{{2,868},{110,102}}
offset
{1,-15}
rotated
(null)
sourceColorRect
{{24,39},{110,102}}
sourceSize
{156,150}3、SAX(simple api xml)
上面tingXML2把plist解析为树结构T，可以通过T访问存在的任意节点。假如现在需要解析为需要的类型数据，可以遍历T，然后根据之前的key元素进行解析，对于树形结构，可以递归的编写方法解决，上面的XML遇到dict元素就递归解析，遇到非dict就进行解析，然后把遍历下个兄弟节点。cocos用到了SAX进行解析，SAX是一个高效的对xml解析的方式，它对xml进行一次扫描。上面的解析，第一次tingyXML扫描建立树结构包含字符串数据，第二次遍历XML生成实际的类型。显然这种操作要遍历两次XML了，一次XML文件，一次XML树结构，第二次应该比第一次快。SAX要解决的就是解析XML的速度问题，只进行一次解析，就得到实际类型。可能你觉得挺简单，就是扫描XML遇到某个元素做个判断，写个分支语句对所有的不同元素进行不同解析，可是XML是一个可以使用任意字符串命名元素的一种文件，怎么可能对所有元素进行解析呢。光cocos提供的标准库就用到好几种plist文件，里面就一堆不同命名的元素。有一种方法可以解决这个问题，解析方式不变，具体解析为什么交给用户自定义的处理程序去做，只要这个自定义程序实现了必须的接口就OK。常用的接口是文档进入处理、文档结束处理、元素进入处理、元素结束处理、元素文本处理、错误处理。上面这些方法作为一个接口，由客户实现，然后遍历XML的时候遇到元素的开始标签调用元素进入方法、遇到文本调用元素文本处理方法等等，这样只需要访问一次XML文件。SAX正是做这个的一个XML库。不幸的是，cocos里面的SAX具有解析时调用客户自定义的处理方法，但是没有XML解析能力，它借助tingXML2进行解析，等解析好了之后，再调用tinyXML的Accept方法，该方法遍历所有节点，然后调用SAX的处理方法，SAX的处理方法再调用代理的处理方法。cocos的SAX还是进行了2次访问操作，并没有如前一样的SAX的功能，可以自己尝试做一下这个东西，一次扫描就建立客户需要的数据结构。
4、CCSpriteFrameCache的addSpriteFramesWithFile(constchar *pszPlist)是如何如何读取plist以及创建CCSpriteFrame的
下面是创建精灵帧以及用精灵帧创建精灵的代码：
void PlistTest::btnClickCreateSpriteBySpriteFrame(CCObject* pSender, CCControlEvent event){
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile("shoe.plist");
CCSprite *sp = CCSprite::createWithSpriteFrameName("1.png");
sp->setPosition(ccp(320, 500));
this->addChild(sp);
}addSpriteFramesWithFile的代码如下：
void CCSpriteFrameCache::addSpriteFramesWithFile(const char *pszPlist)
{
CCAssert(pszPlist, "plist filename should not be NULL");
//not find pszPlist, so read plist
if (m_pLoadedFileNames->find(pszPlist) == m_pLoadedFileNames->end())
{
std::string fullPath = CCFileUtils::sharedFileUtils()->fullPathForFilename(pszPlist);
CCDictionary *dict = CCDictionary::createWithContentsOfFileThreadSafe(fullPath.c_str());
string texturePath("");
CCDictionary* metadataDict = (CCDictionary*)dict->objectForKey("metadata");
if (metadataDict)
{
// try to read texture file name from meta data
texturePath = metadataDict->valueForKey("textureFileName")->getCString();
}
if (! texturePath.empty())
{
// build texture path relative to plist file
texturePath = CCFileUtils::sharedFileUtils()->fullPathFromRelativeFile(texturePath.c_str(), pszPlist);
}
else//plist没有metadata key
{
// build texture path by replacing file extension
texturePath = pszPlist;
// remove .xxx remove .plst
size_t startPos = texturePath.find_last_of(".");
texturePath = texturePath.erase(startPos);
// append .png
texturePath = texturePath.append(".png");
CCLOG("cocos2d: CCSpriteFrameCache: Trying to use file %s as texture", texturePath.c_str());
}
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage(texturePath.c_str());
if (pTexture)
{
addSpriteFramesWithDictionary(dict, pTexture);
m_pLoadedFileNames->insert(pszPlist);
}
else
{
CCLOG("cocos2d: CCSpriteFrameCache: Couldn't load texture");
}
dict->release();
}
}CCDictionary* CCDictionary::createWithContentsOfFileThreadSafe(const char *pFileName)
{
return CCFileUtils::sharedFileUtils()->createCCDictionaryWithContentsOfFile(pFileName);
}CCDictionary* CCFileUtils::createCCDictionaryWithContentsOfFile(const std::string& filename)
{
std::string fullPath = fullPathForFilename(filename.c_str());
CCDictMaker tMaker;
return tMaker.dictionaryWithContentsOfFile(fullPath.c_str());
} CCDictionary* dictionaryWithContentsOfFile(const char *pFileName)//CCDictMaker方法
{
m_eResultType = SAX_RESULT_DICT;
CCSAXParser parser;
if (false == parser.init("UTF-8"))
{
return NULL;
}
parser.setDelegator(this);
parser.parse(pFileName);
return m_pRootDict;
}CCSAXParser，并把它自己设置为CCSAXParser的代理。CCSAXParser就是所谓的SAX，是服务端，CCDictMaker是客户它实现了SAX需要的处理程序，代码如下：
class CCDictMaker : public CCSAXDelegatorclass CC_DLL CCSAXDelegator
{
public:
virtual void startElement(void *ctx, const char *name, const char **atts) = 0;
virtual void endElement(void *ctx, const char *name) = 0;
virtual void textHandler(void *ctx, const char *s, int len) = 0;
};bool CCSAXParser::parse(const char *pszFile)
{
bool bRet = false;
unsigned long size = 0;
char* pBuffer = (char*)CCFileUtils::sharedFileUtils()->getFileData(pszFile, "rt", &size);
if (pBuffer != NULL && size > 0)
{
bRet = parse(pBuffer, size);
}
CC_SAFE_DELETE_ARRAY(pBuffer);
return bRet;
}bool CCSAXParser::parse(const char* pXMLData, unsigned int uDataLength)
{
tinyxml2::XMLDocument tinyDoc;
tinyDoc.Parse(pXMLData, uDataLength);
XmlSaxHander printer;
printer.setCCSAXParserImp(this);
return tinyDoc.Accept( &printer );
}文档节点的：
bool XMLDocument::Accept( XMLVisitor* visitor ) const
{
if ( visitor->VisitEnter( *this ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
break;
}
}
}
return visitor->VisitExit( *this );
}元素节点的：
bool XMLElement::Accept( XMLVisitor* visitor ) const
{
if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
break;
}
}
}
return visitor->VisitExit( *this );
}bool XMLText::Accept( XMLVisitor* visitor ) const
{
return visitor->Visit( *this );
}virtual bool Accept( XMLVisitor* visitor ) const = 0;XMLVisitor里面的这几种方法，代码如下：
class XmlSaxHander : public tinyxml2::XMLVisitor
{
public:
XmlSaxHander():m_ccsaxParserImp(0){};
virtual bool VisitEnter( const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* firstAttribute );
virtual bool VisitExit( const tinyxml2::XMLElement& element );
virtual bool Visit( const tinyxml2::XMLText& text );
virtual bool Visit( const tinyxml2::XMLUnknown&){ return true; }
void setCCSAXParserImp(CCSAXParser* parser)
{
m_ccsaxParserImp = parser;
}
private:
CCSAXParser *m_ccsaxParserImp;
};bool XmlSaxHander::VisitEnter( const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* firstAttribute )
{
//CCLog(" VisitEnter %s",element.Value());
std::vector attsVector;
for( const tinyxml2::XMLAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() )
{
//CCLog("%s", attrib->Name());
attsVector.push_back(attrib->Name());
//CCLog("%s",attrib->Value());
attsVector.push_back(attrib->Value());
}
// nullptr is used in c++11
//attsVector.push_back(nullptr);
attsVector.push_back(NULL);
CCSAXParser::startElement(m_ccsaxParserImp, (const CC_XML_CHAR *)element.Value(), (const CC_XML_CHAR **)(&attsVector[0]));
return true;
}
bool XmlSaxHander::VisitExit( const tinyxml2::XMLElement& element )
{
//CCLog("VisitExit %s",element.Value());
CCSAXParser::endElement(m_ccsaxParserImp, (const CC_XML_CHAR *)element.Value());
return true;
}
bool XmlSaxHander::Visit( const tinyxml2::XMLText& text )
{
//CCLog("Visit %s",text.Value());
CCSAXParser::textHandler(m_ccsaxParserImp, (const CC_XML_CHAR *)text.Value(), strlen(text.Value()));
return true;
} void CCSAXParser::startElement(void *ctx, const CC_XML_CHAR *name, const CC_XML_CHAR **atts)
{
((CCSAXParser*)(ctx))->m_pDelegator->startElement(ctx, (char*)name, (const char**)atts);
}
void CCSAXParser::endElement(void *ctx, const CC_XML_CHAR *name)
{
((CCSAXParser*)(ctx))->m_pDelegator->endElement(ctx, (char*)name);
}
void CCSAXParser::textHandler(void *ctx, const CC_XML_CHAR *name, int len)
{
((CCSAXParser*)(ctx))->m_pDelegator->textHandler(ctx, (char*)name, len);
} void startElement(void *ctx, const char *name, const char **atts)
{
CC_UNUSED_PARAM(ctx);
CC_UNUSED_PARAM(atts);
std::string sName((char*)name);
if( sName == "dict" )
{
m_pCurDict = new CCDictionary();
if(m_eResultType == SAX_RESULT_DICT && m_pRootDict == NULL)
{
// Because it will call m_pCurDict->release() later, so retain here.
m_pRootDict = m_pCurDict;
m_pRootDict->retain();
}
m_tState = SAX_DICT;
CCSAXState preState = SAX_NONE;
if (! m_tStateStack.empty())
{
preState = m_tStateStack.top();
}
if (SAX_ARRAY == preState)
{
// add the dictionary into the array
m_pArray->addObject(m_pCurDict);
}
else if (SAX_DICT == preState)
{
// add the dictionary into the pre dictionary
CCAssert(! m_tDictStack.empty(), "The state is wrong!");
CCDictionary* pPreDict = m_tDictStack.top();
pPreDict->setObject(m_pCurDict, m_sCurKey.c_str());
}
m_pCurDict->release();
// record the dict state
m_tStateStack.push(m_tState);
m_tDictStack.push(m_pCurDict);
}
else if(sName == "key")
{
m_tState = SAX_KEY;
}
else if(sName == "integer")
{
m_tState = SAX_INT;
}
else if(sName == "real")
{
m_tState = SAX_REAL;
}
else if(sName == "string")
{
m_tState = SAX_STRING;
}
else if (sName == "array")
{
m_tState = SAX_ARRAY;
m_pArray = new CCArray();
if (m_eResultType == SAX_RESULT_ARRAY && m_pRootArray == NULL)
{
m_pRootArray = m_pArray;
m_pRootArray->retain();
}
CCSAXState preState = SAX_NONE;
if (! m_tStateStack.empty())
{
preState = m_tStateStack.top();
}
if (preState == SAX_DICT)
{
m_pCurDict->setObject(m_pArray, m_sCurKey.c_str());
}
else if (preState == SAX_ARRAY)
{
CCAssert(! m_tArrayStack.empty(), "The state is wrong!");
CCArray* pPreArray = m_tArrayStack.top();
pPreArray->addObject(m_pArray);
}
m_pArray->release();
// record the array state
m_tStateStack.push(m_tState);
m_tArrayStack.push(m_pArray);
}void textHandler(void *ctx, const char *ch, int len)
{
CC_UNUSED_PARAM(ctx);
if (m_tState == SAX_NONE)
{
return;
}
CCSAXState curState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
CCString *pText = new CCString(std::string((char*)ch,0,len));
switch(m_tState)
{
case SAX_KEY:
m_sCurKey = pText->getCString();
break;
case SAX_INT:
case SAX_REAL:
case SAX_STRING:
{
if (curState == SAX_DICT)
{
CCAssert(!m_sCurKey.empty(), "key not found : ");
}
m_sCurValue.append(pText->getCString());
}
break;
default:
break;
}
pText->release();
}
else { m_tState = SAX_NONE; } } 上面是当遇到一个开始标签，调用处理程序进行解析工作。SAX_ARRAY先不分析，遇到这样的plist在分析。现在分析一般类型以及字典。m_tStateStack是一个状态栈，它读到一个字典把字典状态压栈，读到基本类型它们的状态由m_tState保存，但不压栈。sName == "dict"它会先创建一个字典m_pCurDict = new CCDictionary();。if(m_eResultType == SAX_RESULT_DICT && m_pRootDict == NULL)表示当前还没有建立根字典，把m_pCurDict给m_pRootDict。preState表示之前状态，建好字典后如果之前有个字典else if (SAX_DICT == preState)，CCDictionary* pPreDict = m_tDictStack.top();pPreDict->setObject(m_pCurDict, m_sCurKey.c_str());这几句代码意思是取出之前的字典(不出栈)，然后设置为字典的一个键值对，键是怎么得到的，等下分析。其它的开始标签只改变状态m_tState。开始标签的状态决定了怎么读取它的文本，代码如下：
void textHandler(void *ctx, const char *ch, int len)
{
CC_UNUSED_PARAM(ctx);
if (m_tState == SAX_NONE)
{
return;
}
CCSAXState curState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
CCString *pText = new CCString(std::string((char*)ch,0,len));
switch(m_tState)
{
case SAX_KEY:
m_sCurKey = pText->getCString();
break;
case SAX_INT:
case SAX_REAL:
case SAX_STRING:
{
if (curState == SAX_DICT)
{
CCAssert(!m_sCurKey.empty(), "key not found : ");
}
m_sCurValue.append(pText->getCString());
}
break;
default:
break;
}
pText->release();
}
void endElement(void *ctx, const char *name)
{
CC_UNUSED_PARAM(ctx);
CCSAXState curState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
std::string sName((char*)name);
if( sName == "dict" )
{
m_tStateStack.pop();
m_tDictStack.pop();
if ( !m_tDictStack.empty())
{
m_pCurDict = m_tDictStack.top();
}
}
else if (sName == "array")
{
m_tStateStack.pop();
m_tArrayStack.pop();
if (! m_tArrayStack.empty())
{
m_pArray = m_tArrayStack.top();
}
}
else if (sName == "true")
{
CCString *str = new CCString("1");
if (SAX_ARRAY == curState)
{
m_pArray->addObject(str);
}
else if (SAX_DICT == curState)
{
m_pCurDict->setObject(str, m_sCurKey.c_str());
}
str->release();
}
else if (sName == "false")
{
CCString *str = new CCString("0");
if (SAX_ARRAY == curState)
{
m_pArray->addObject(str);
}
else if (SAX_DICT == curState)
{
m_pCurDict->setObject(str, m_sCurKey.c_str());
}
str->release();
}
else if (sName == "string" || sName == "integer" || sName == "real")
{
CCString* pStrValue = new CCString(m_sCurValue);
if (SAX_ARRAY == curState)
{
m_pArray->addObject(pStrValue);
}
else if (SAX_DICT == curState)
{
m_pCurDict->setObject(pStrValue, m_sCurKey.c_str());
}
pStrValue->release();
m_sCurValue.clear();
}
m_tState = SAX_NONE;
}
m_sCurKey此时等于key标签的文本。上面遇到结束标签的处理就是把前面得到的m_sCurKey与m_sCurValue放入字典。m_sCurValue也是文本处理得到的。
上面解析的过程就是遇到字典就创建字典并压栈，然后作为栈顶元素，后面的解析出的key/value就加在栈顶元素字典上，遇到字典结束就弹出字典。利用栈这个结构完成了解析，栈的后进先出的与字典的创建与添加键值对有相同之点。
最后CCDictionary *dict = CCDictionary::createWithContentsOfFileThreadSafe(fullPath.c_str());建立好了字典。
5、CCDictionary
后面就是利用解析获得的CCDictionary获得各种必须的参数，加载纹理，创建精灵帧。下面先分析下CCDictionary。
CCDictionary是一个字典结构，它底层使用hash表建立的，正常情况可以在O(1)得到要找的关键字对象，差的情况可能像个链表，要花费O(n)的时间完成查找。不过设计良好的
hash表查找都挺快。下面分析CCDictionary的几个函数，代码如下：
const CCString* CCDictionary::valueForKey(const std::string& key)
{
CCString* pStr = dynamic_cast(objectForKey(key));
if (pStr == NULL)
{
pStr = CCString::create("");
}
return pStr;
} CCObject* CCDictionary::objectForKey(const std::string& key)
{
// if dictionary wasn't initialized, return NULL directly.
if (m_eDictType == kCCDictUnknown) return NULL;
// CCDictionary only supports one kind of key, string or integer.
//This method uses string as key, therefore we should make sure that the key type of this CCDictionary is string.
CCAssert(m_eDictType == kCCDictStr, "this dictionary does not use string as key.");
CCObject* pRetObject = NULL;
CCDictElement *pElement = NULL;
HASH_FIND_STR(m_pElements, key.c_str(), pElement);
if (pElement != NULL)
{
pRetObject = pElement->m_pObject;
}
return pRetObject;
}CCAssert(m_eDictType == kCCDictStr, "this dictionary does not use string as key.");表示字典的键是字符串，它的setObject方法决定m_eDictType为kCCDictStr还是kCCDictInt，可以看下代码，这里不贴了。CCDictElement是CCDictionary使用的类。它的数据成员如下：
private:
// The max length of string key.
#define MAX_KEY_LEN 256
// char array is needed for HASH_ADD_STR in UT_HASH.
// So it's a pain that all elements will allocate 256 bytes for this array.
char m_szKey[MAX_KEY_LEN]; // hash key of string type
intptr_t m_iKey; // hash key of integer type
CCObject* m_pObject; // hash value
public:
UT_hash_handle hh; // makes this class hashable
friend class CCDictionary; // declare CCDictionary as friend class/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
#define HASH_FIND_STR(head,findstr,out) \
HASH_FIND(hh,head,findstr,strlen(findstr),out)
#define HASH_ADD_STR(head,strfield,add) \
HASH_ADD(hh,head,strfield,strlen(add->strfield),add)
#define HASH_REPLACE_STR(head,strfield,add,replaced) \
HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)
#define HASH_FIND_INT(head,findint,out) \
HASH_FIND(hh,head,findint,sizeof(int),out)
#define HASH_ADD_INT(head,intfield,add) \
HASH_ADD(hh,head,intfield,sizeof(int),add)
#define HASH_REPLACE_INT(head,intfield,add,replaced) \
HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
#define HASH_FIND_PTR(head,findptr,out) \
HASH_FIND(hh,head,findptr,sizeof(void *),out)
#define HASH_ADD_PTR(head,ptrfield,add) \
HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
#define HASH_REPLACE_PTR(head,ptrfield,add) \
HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
#define HASH_DEL(head,delptr) \
HASH_DELETE(hh,head,delptr)CCDictElement* m_pElements;是CCDictionary的hash表的头结点。下面是CCDictionary添加相应key的对象的方法：
void CCDictionary::setObject(CCObject* pObject, const std::string& key)
{
CCAssert(key.length() > 0 && pObject != NULL, "Invalid Argument!");
if (m_eDictType == kCCDictUnknown)
{
m_eDictType = kCCDictStr;
}
CCAssert(m_eDictType == kCCDictStr, "this dictionary doesn't use string as key.");
CCDictElement *pElement = NULL;
HASH_FIND_STR(m_pElements, key.c_str(), pElement);
if (pElement == NULL)
{
setObjectUnSafe(pObject, key);
}
else if (pElement->m_pObject != pObject)
{
CCObject* pTmpObj = pElement->m_pObject;
pTmpObj->retain();
removeObjectForElememt(pElement);
setObjectUnSafe(pObject, key);
pTmpObj->release();
}
}void CCDictionary::removeObjectForElememt(CCDictElement* pElement)
{
if (pElement != NULL)
{
HASH_DEL(m_pElements, pElement);
pElement->m_pObject->release();
CC_SAFE_DELETE(pElement);
}
}setObjectUnSafe(pObject, key);代码如下：
void CCDictionary::setObjectUnSafe(CCObject* pObject, const std::string& key)
{
pObject->retain();
CCDictElement* pElement = new CCDictElement(key.c_str(), pObject);
HASH_ADD_STR(m_pElements, m_szKey, pElement);
}下面是CCDictionary已删除相应key对象的方法：
void CCDictionary::removeObjectForKey(const std::string& key)
{
if (m_eDictType == kCCDictUnknown)
{
return;
}
CCAssert(m_eDictType == kCCDictStr, "this dictionary doesn't use string as its key");
CCAssert(key.length() > 0, "Invalid Argument!");
CCDictElement *pElement = NULL;
HASH_FIND_STR(m_pElements, key.c_str(), pElement);
removeObjectForElememt(pElement);
}CCDictionary的功能主要如下：
CCDictionary* CCDictionary::create() 创建一个字典
CCDictionary* CCDictionary::createWithContentsOfFile(const char *pFileName)由plist创建CCDictionary。(用到了tinyXML2、SAX以及uthash)
bool CCDictionary::writeToFile(const char *fullPath)把CCDictionary输出到磁盘。(借助tinyxml2逆向生成XML文档)
key为字符串的接口
void CCDictionary::setObject(CCObject* pObject, const std::string& key)添加键值对
const CCString* CCDictionary::valueForKey(const std::string& key)获得值
void CCDictionary::removeObjectForKey(const std::string& key)移除键值对
key为整数的接口
void CCDictionary::setObject(CCObject* pObject, intptr_t key)
const CCString* CCDictionary::valueForKey(intptr_t key)
void CCDictionary::removeObjectForKey(intptr_t key)
所有cocos中可以可以直接用XML来存储数据，它是cocos原生支持的。用XML保存一些配置信息，小游戏可以保存物品等等信息，然后可以通过CCDictionary直接解析，这个比CCUserdata好多了，CCUserdata的路径不是我们指定的，而且只能写、修改，不能删除一个键值，用的底层的接口。
6、解析CCDictionary存储的数据
plist解析为CCDictionary后，是如何提取出实际类型数据的。继续查看代码如下：
CCDictionary* metadataDict = (CCDictionary*)dict->objectForKey("metadata");
if (metadataDict)
{
// try to read texture file name from meta data
texturePath = metadataDict->valueForKey("textureFileName")->getCString();
}下面代码是获得纹理最终路径
texturePath = CCFileUtils::sharedFileUtils()->fullPathFromRelativeFile(texturePath.c_str(), pszPlist);
const char* CCFileUtils::fullPathFromRelativeFile(const char *pszFilename, const char *pszRelativeFile)
{
std::string relativeFile = pszRelativeFile;
CCString *pRet = CCString::create("");
pRet->m_sString = relativeFile.substr(0, relativeFile.rfind('/')+1);
pRet->m_sString += getNewFilename(pszFilename);
return pRet->getCString();
}
先找出pszRelativeFile的相对路径，也就是0到/之间的路径，然后跟pszFilename拼接成一个新的路径。继续追踪如下
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage(texturePath.c_str());纹理创建好后会调用 addSpriteFramesWithDictionary (dict, pTexture);代码如下:
else if(format == 1 || format == 2)
{
CCRect frame = CCRectFromString(frameDict->valueForKey("frame")->getCString());
bool rotated = false;
// rotation
if (format == 2)
{
rotated = frameDict->valueForKey("rotated")->boolValue();
}
CCPoint offset = CCPointFromString(frameDict->valueForKey("offset")->getCString());
CCSize sourceSize = CCSizeFromString(frameDict->valueForKey("sourceSize")->getCString());
// create frame
spriteFrame = new CCSpriteFrame();
spriteFrame->initWithTexture(pobTexture,
frame,
rotated,
offset,
sourceSize
);
} CCRect frame = CCRectFromString(frameDict->valueForKey("frame")->getCString());代码如下：
CCRect CCRectFromString(const char* pszContent)
{
CCRect result = CCRectZero;
do
{
CC_BREAK_IF(!pszContent);
std::string content = pszContent;
// find the first '{' and the third '}'
int nPosLeft = content.find('{');
int nPosRight = content.find('}');
for (int i = 1; i < 3; ++i)
{
if (nPosRight == (int)std::string::npos)
{
break;
}
nPosRight = content.find('}', nPosRight + 1);
}
CC_BREAK_IF(nPosLeft == (int)std::string::npos || nPosRight == (int)std::string::npos);
content = content.substr(nPosLeft + 1, nPosRight - nPosLeft - 1);
int nPointEnd = content.find('}');
CC_BREAK_IF(nPointEnd == (int)std::string::npos);
nPointEnd = content.find(',', nPointEnd);
CC_BREAK_IF(nPointEnd == (int)std::string::npos);
// get the point string and size string
std::string pointStr = content.substr(0, nPointEnd);
std::string sizeStr = content.substr(nPointEnd + 1, content.length() - nPointEnd);
// split the string with ','
strArray pointInfo;
CC_BREAK_IF(!splitWithForm(pointStr.c_str(), pointInfo));
strArray sizeInfo;
CC_BREAK_IF(!splitWithForm(sizeStr.c_str(), sizeInfo));
float x = (float) atof(pointInfo[0].c_str());
float y = (float) atof(pointInfo[1].c_str());
float width = (float) atof(sizeInfo[0].c_str());
float height = (float) atof(sizeInfo[1].c_str());
result = CCRectMake(x, y, width, height);
} while (0);
return result;
}其它几个解析的函数就不贴了，本人准备另起一篇文章专门讲解析相关的内容，并且介绍一些解析文件的方法。
本文只讲了解析plist,没讲从plist解析出数据后怎么创建对象的，这个下篇文章讲。