CConfig类

#ifndef __CONFIG_H__

#define __CONFIG_H__

#include "GameFrameHead.h"

//图片信息

struct ImageInfo

{

    int        nId;        //ID标识

    string    strKey;        //key标识

    string    strFile;    //文件路径

};

//资源信息

struct ResourceInfo

{

};

//ui

//控件信息

struct CtrlInfo

{

    int nId;

    CCPoint tPos;        //坐标

    CCPoint tAnchor;    //锚点

    CCRect rRect;

    string strPic;        //图片

    string strText;        //文本内容

    string strFont;        //文本字体

    string strAudioFile;//声音文件

    unsigned int nFontSize; //文本字体大小

    unsigned int wLabelType; //文本类型

    string strItem;        //rollView条款

    unsigned short    wRollType;//roll控件类型

    float fBounds;    //拖动速率

    string strWord;        //

    unsigned short wType;//控件类型

    unsigned short wAlignment;//文本对齐方式

    unsigned short btnState;//按钮状态

    unsigned short btnType; //按钮类型

    ccColor3B       color3B; //文本颜色

    unsigned short notType;    //屏蔽消息框类型

    int               nPriority;//消息优先级

    enum WTYPE

    {

        _IDC_IMG = , //图片

        _IDC_STA = , //文本

        _IDC_BTN = , //按钮

        _IDC_SROLL = , //Sroll

        _IDC_NOT = , //屏蔽消息框

        _IDC_ROLL= , //滚动框

    };

    enum BTN_TYPE

    {

        _BT_Normal = , //正常

        _BT_Select = , //选择

    };

    enum LabelType

    {

        _LableTTF     = ,

        _LabelBMFont = ,

        _LabelAtlas  = ,

    };

};

//部件配置

struct WidgetInfo

{

    int nId;

    CCPoint tPos;        //坐标

    CCPoint tAnchor;    //锚点

    CCRect rRect;

    string strPic;        //图片

    vector<CtrlInfo> m_vecCtrlInfo;

};

//场景配置

struct SceneInfo

{

    int nId;

    int nPosX;

    int nPosY;

    unsigned short wType;        //条款(item)类型

    unsigned short order;        //层次

    string strFile;

    CCRect rRect;

    enum WTYPE

    {

        _ITEM_IMG = , //图片

        _ITEM_DLG = , //对话框

        _ITEM_EFT = , //效果

        _ITEM_STA = , //文本

        _ITEM_BTN = , //按钮

    };

};

//元素配置

struct PlistInfo

{

    string strPlist;

    string strImage;

};

struct ElementInfo

{

    int nItem;

    vector<PlistInfo> vecPlistInfo;

};

//动画配置

struct AnimationInfo

{

    int        nId;    //物体ID(动画相关的物体)

    int        nBegan;    //开始帧数

    int        nCount; //动画帧数

    int        nInterval;//帧之间的间隔

    string    strName;  //动画名字

    string    plistpath;  //plist路径

    string    texturePath;//静态贴图文件路径

    string    picPrefix;    //资源目录--默认（或空）为物体的ID

};

//文字配置

struct WordInfo

{

    string    strKey;

    string    strLetter;  //文字

};

//滚动项配置

//struct SrollInfo

//{

//    int        nId;

//    int        nPosX;

//    int        nPosY;

//    CCRect    rRect;

//    string    strPic;

//

//    CtrlInfo ctrlInfo;

//

//    unsigned short wType;//类型

//

//    vector<SrollInfo> vecRollSub;

//};

//

//struct SrollViewInfo

//{

//    string                strKey;

//    vector<SrollInfo>    vecRollInfo;

//};

//滚动项配置

struct  SrollInfo

{

    string                strKey;

    vector<WidgetInfo>    vecWidgetInfo;

};

//效果配置

struct EffectInfo

{

    string strKey;

    int nId;

    int nPosX;

    int nPosY;

    CCRect rRect;

    string strFile;

    unsigned int wType;

    vector<EffectInfo> vecEffectSub;

    enum WTYPE

    {

        _Particle = ,

        _Action      = ,

        _Animation = ,

    };

};

//动作配置

struct ActionInfo

{

    string strKey;

    int    nAction;

    string strDepict;    //动作名字

    string strParm;        //参数

    bool   bReverse;    //是否反动作

    string strFile;        //动作文件

    enum ActionType

    {

        _Particle = ,

        _Action      = ,

        _Animation = ,

    };

    ActionType eType; //动作类型

};

//音效配置

struct  AudioInfo

{

    string strKey;

    unsigned int wType;

    string strFile;

};

class GAMEFRAME_API CConfig

{

public:

    CConfig();

    ~CConfig();

    static CConfig* getInstance();

    static void destroy();

    void release();

    bool loadConfig();

    //读取配置文件

    bool loadResourceInfo();//

    bool loadImageInfo();//图片信息

    bool loadAnimationInfo();//动画信息

    bool loadSceneInfo();//场景信息

    bool loadElementInfo();//元素 （plist）文件形式

    bool loadWidgetInfo();// 控件信息

    bool loadSrollInfo();  //滚动项信息

    bool loadEffectInfo();//效果配置

    bool loadAudioInfo();//声音配置

    bool loadWordInfo();//文字配置

    bool loadActionInfo();//动作配置

    bool loadNumberInfo();//数字配置

    bool readConfig();

    //设置资源路径  一开始就要设定

    void setResourcePath(const char* psPath);

    string    getResourcePath();

    vector<ImageInfo>* getImageInfo();

    ImageInfo* getImageInfoById(int nId);

    ImageInfo* getImageInfoByKey(const char* psKey);

    vector<WidgetInfo>* getWidgetInfo();

    WidgetInfo* getWidgetInfoById(int nId);

    vector<ElementInfo>* getElementInfo();

    vector<PlistInfo>* getElementInfoByItem(int nId);

    map<int,vector<SceneInfo> >* getSceneInfo();

    vector<AnimationInfo>* getAnimationInfo();

    vector<EffectInfo>* getEffectInfo();

    EffectInfo* getEffectInfoByKey(const char* psKey);

    vector<WidgetInfo>* getSrollInfoByKey(const char* psKey);

    AudioInfo* getAudioInfoByKey(const char* psKey);

    WordInfo& getWordInfoByKey(const char* psKey);

    string getWordBykey(const char* psKey);

    ActionInfo* getActionInfoByKey(const char* psKey);

    float getNumberByKey(const char* psKey);

private:

    vector<string>    m_vceConfigStr;

    //资源路径

    string            m_strResourcePath;

    static CConfig*    g_pConfig;

    //图片资源配置标识

    vector<ImageInfo>    m_vecImageInfo;

    //场景配置标识

    map<int, vector<SceneInfo> > m_mapSceneInfoVec;

    //元素(plist)配置标识

    vector<ElementInfo>    m_vecElement;

    //windget配置标识

    vector<WidgetInfo>    m_vecWidgetInfo;

    //动画配置标识

    vector<AnimationInfo> m_vecAnimationInfo;

    //Sroll配置标识

    vector<SrollInfo> m_vecSrollInfo;

    //效果配置

    vector<EffectInfo> m_vecEffectInfo;

    //音效配置

    vector<AudioInfo>    m_vecAudioInfo;

    //文字配置

    map<string, WordInfo>  m_mapWordInfo;

    //动作配置

    vector<ActionInfo>        m_vecActionInfo;

    map<string, float>        m_mapNumber;

};

#endif //__XCONFIG_H__

#include "Config.h"

#include "XXmlReader.h"

CConfig* CConfig::g_pConfig = NULL;

CConfig::CConfig()

{

    m_strResourcePath.clear();

    m_vecImageInfo.clear();

    m_mapSceneInfoVec.clear();

    m_vecElement.clear();

    m_vecWidgetInfo.clear();

    m_vecAnimationInfo.clear();

    m_vecEffectInfo.clear();

}

CConfig::~CConfig()

{

}

CConfig* CConfig::getInstance()

{

    if (!g_pConfig)

    {

        g_pConfig = new CConfig();

    }

    return g_pConfig;

}

void CConfig::destroy()

{

    g_pConfig->release();

    SAFE_DELETE(g_pConfig);

}

void CConfig::release()

{

    m_strResourcePath.clear();

    m_vecImageInfo.clear();

    m_mapSceneInfoVec.clear();

    m_vecElement.clear();

    m_vecWidgetInfo.clear();

    m_vecAnimationInfo.clear();

}

bool CConfig::loadConfig()

{

    return false;

}

void CConfig::setResourcePath( const char* psPath )

{

    m_strResourcePath = psPath;

}

string CConfig::getResourcePath()

{

    return m_strResourcePath;

}

bool CConfig::readConfig()

{

    return true;

}

bool CConfig::loadImageInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/image.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "images", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pCurNode = pRootNode->xmlChildrenNode;

        while (NULL != pCurNode)

        {

            if ( != xmlStrcmp(pCurNode->name, BAD_CAST "image"))

            {

                pCurNode = pCurNode->next;

                continue;

            }

            ImageInfo info;

            info.nId = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "id");

            info.strKey = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "key");

            info.strFile = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "file");

            m_vecImageInfo.push_back(info);

            pCurNode = pCurNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

vector<ImageInfo>* CConfig::getImageInfo()

{

    return &m_vecImageInfo;

}

bool CConfig::loadSceneInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/scene.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "scenes", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pElement = pRootNode->xmlChildrenNode;

        while (pElement)

        {

            if ( != xmlStrcmp(pElement->name, BAD_CAST "scene"))

            {

                pElement = pElement->next;

                continue;

            }

            xmlNodePtr pItemNode = pElement->xmlChildrenNode;

            vector<SceneInfo> vecSceneInfo;

            while (pItemNode)

            {

                if ( != xmlStrcmp(pItemNode->name, BAD_CAST "item"))

                {

                    pItemNode = pItemNode->next;

                    continue;

                }

                SceneInfo info;

                info.nId = CCXmlReader::getXMLNodeAttribInt(&pItemNode, "id");

                info.wType = CCXmlReader::getXMLNodeAttribInt(&pItemNode, "type");

                string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pItemNode, "pos");

                int nRectX = , nRectY = , nRectW = , nRectH = ;

                sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&info.nPosX,&info.nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                info.rRect.setRect(nRectX,nRectY,nRectW,nRectH);

                info.order = CCXmlReader::getXMLNodeAttribInt(&pItemNode, "order");

                info.strFile = CCXmlReader::getXMLNodeAttribStrs(&pItemNode, "file");

                vecSceneInfo.push_back(info);

                pItemNode = pItemNode->next;

            }

            int nKey = CCXmlReader::getXMLNodeAttribInt(&pElement, "id");

            m_mapSceneInfoVec[nKey] = vecSceneInfo;

            pElement = pElement->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

bool CConfig::loadElementInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/element.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "elements", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pItemNode = pRootNode->xmlChildrenNode;

        while (NULL != pItemNode)

        {

            if ( != xmlStrcmp(pItemNode->name, BAD_CAST "item"))

            {

                pItemNode = pItemNode->next;

                continue;

            }

            ElementInfo elemInfo;

            elemInfo.nItem = CCXmlReader::getXMLNodeAttribInt(&pItemNode, "id");

            xmlNodePtr pElemNode = pItemNode->xmlChildrenNode;

            while(pElemNode)

            {

                if ( != xmlStrcmp(pElemNode->name, BAD_CAST "element"))

                {

                    pElemNode = pElemNode->next;

                    continue;

                }

                PlistInfo info;

                info.strPlist = CCXmlReader::getXMLNodeAttribStrs(&pElemNode, "plist");

                info.strImage = CCXmlReader::getXMLNodeAttribStrs(&pElemNode, "image");

                elemInfo.vecPlistInfo.push_back(info);

                pElemNode = pElemNode->next;

            }

            m_vecElement.push_back(elemInfo);

            pItemNode = pItemNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

bool CConfig::loadWidgetInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/widget.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "widgets", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pElement = pRootNode->xmlChildrenNode;

        while (NULL != pElement)

        {

            if ( != xmlStrcmp(pElement->name, BAD_CAST "widget"))

            {

                pElement = pElement->next;

                continue;

            }

            WidgetInfo widgetInfo;

            widgetInfo.nId = CCXmlReader::getXMLNodeAttribInt(&pElement, "id");

            string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pElement,"pos");

            int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

            sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

            widgetInfo.tPos.setPoint(nPosX, nPosY);

            widgetInfo.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

            strBuf = CCXmlReader::getXMLNodeAttribStrs(&pElement, "anchor");

            float fAnchorX = , fAnchorY = ;

            sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

            widgetInfo.tAnchor.setPoint(fAnchorX, fAnchorY);

            widgetInfo.strPic = CCXmlReader::getXMLNodeAttribStrs(&pElement, "pic");

            xmlNodePtr pCtrlNode = pElement->xmlChildrenNode;

            while (pCtrlNode)

            {

                //图片控件

                if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "img"))

                {

                    CtrlInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                    int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                    info.tPos.setPoint(nPosX, nPosY);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    info.strPic = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "pic");

                    strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                    float fAnchorX = , fAnchorY = ;

                    sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                    info.tAnchor.setPoint(fAnchorX, fAnchorY);

                    info.wType = CtrlInfo::_IDC_IMG;

                    widgetInfo.m_vecCtrlInfo.push_back(info);

                }

                //按钮控件

                if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "btn"))

                {

                    CtrlInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                    int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                    info.tPos.setPoint(nPosX, nPosY);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                    float fAnchorX = , fAnchorY = ;

                    sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                    info.wType = CtrlInfo::_IDC_BTN;

                    info.btnType = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "type");

                    info.btnState = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "state");

                    info.strPic = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "pic");

                    info.strAudioFile = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "audio");

                    widgetInfo.m_vecCtrlInfo.push_back(info);

                }

                //文本控件

                if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "sta"))

                {

                    CtrlInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                    int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                    info.tPos.setPoint(nPosX, nPosY);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                    float fAnchorX = , fAnchorY = ;

                    sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                    info.tAnchor.setPoint(fAnchorX, fAnchorY);

                    info.wType = CtrlInfo::_IDC_STA;

                    info.wLabelType = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "type");

                    info.strText = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "text");

                    info.nFontSize = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "fontsize");

                    info.strFont = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "font");

                    info.wAlignment = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "aligning");

                    strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "color");

                    int nR = , nG = , nB = ;

                    sscanf(strBuf.c_str(), "%d %d %d",&nR, &nG, &nB);

                    info.color3B.r = (char)nR;

                    info.color3B.g = (char)nG;

                    info.color3B.b = (char)nB;

                    widgetInfo.m_vecCtrlInfo.push_back(info);

                }

                //Sroll控件

                if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "srl"))

                {

                    CtrlInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                    int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                    info.tPos.setPoint(nPosX, nPosY);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                    float fAnchorX = , fAnchorY = ;

                    sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                    info.tAnchor.setPoint(fAnchorX, fAnchorY);

                    info.strItem = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "item");

                    info.wRollType = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "type");

                    info.fBounds = CCXmlReader::getXMLNodeAttribfloat(&pCtrlNode, "bounds");

                    info.wType = CtrlInfo::_IDC_SROLL;

                    widgetInfo.m_vecCtrlInfo.push_back(info);

                }

                //禁用触摸控件

                if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "not"))

                {

                    CtrlInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                    info.notType = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "type");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                    int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                    info.tPos.setPoint(nPosX, nPosY);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                    float fAnchorX = , fAnchorY = ;

                    sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                    info.tAnchor.setPoint(fAnchorX, fAnchorY);

                    info.nPriority = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "priority");

                    info.wType = CtrlInfo::_IDC_NOT;

                    widgetInfo.m_vecCtrlInfo.push_back(info);

                }

                pCtrlNode = pCtrlNode->next;

            }

            m_vecWidgetInfo.push_back(widgetInfo);

            pElement = pElement->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

vector<WidgetInfo>* CConfig::getWidgetInfo()

{

    return& m_vecWidgetInfo;

}

vector<ElementInfo>* CConfig::getElementInfo()

{

    return& m_vecElement;

}

map<int,vector<SceneInfo> >* CConfig::getSceneInfo()

{

    return& m_mapSceneInfoVec;

}

bool CConfig::loadAnimationInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/animation.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "animations", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pCurNode = pRootNode->xmlChildrenNode;

        while (NULL != pCurNode)

        {

            if ( != xmlStrcmp(pCurNode->name, BAD_CAST "animation"))

            {

                pCurNode = pCurNode->next;

                continue;

            }

            AnimationInfo info;

            info.nId = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "id");

            info.nBegan = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "began");

            info.nCount = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "count");

            info.nInterval = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "interval");

            info.strName = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "name");

            m_vecAnimationInfo.push_back(info);

            pCurNode = pCurNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

vector<AnimationInfo>* CConfig::getAnimationInfo()

{

    return &m_vecAnimationInfo;

}

ImageInfo* CConfig::getImageInfoById( int nId )

{

    for (vector<ImageInfo>::iterator it = m_vecImageInfo.begin(); it != m_vecImageInfo.end(); it++)

    {

        if (it->nId == nId)

        {

            return &(*it);

        }

    }

    CCLog("error: CConfig::getPlanInfoById");

    return NULL;

}

WidgetInfo* CConfig::getWidgetInfoById( int nId )

{

    for (vector<WidgetInfo>::iterator it = m_vecWidgetInfo.begin(); it != m_vecWidgetInfo.end(); it++)

    {

        if (it->nId == nId)

        {

            return &(*it);

        }

    }

    CCLog("error: CConfig::getWidgetInfoById");

    return NULL;

}

bool CConfig::loadSrollInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/sroll.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "srolls", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pElement = pRootNode->xmlChildrenNode;

        while (NULL != pElement)

        {

            if ( == xmlStrcmp(pElement->name, BAD_CAST "item"))

            {

                SrollInfo srollInfo;

                srollInfo.strKey = CCXmlReader::getXMLNodeAttribStrs(&pElement, "key");

                xmlNodePtr pWidgetNode = pElement->xmlChildrenNode;

                while(pWidgetNode)

                {

                    if ( == xmlStrcmp(pWidgetNode->name, BAD_CAST "widget"))

                    {

                        WidgetInfo widgetInfo;

                        widgetInfo.nId = CCXmlReader::getXMLNodeAttribInt(&pWidgetNode, "id");

                        string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pWidgetNode,"pos");

                        int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                        sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                        widgetInfo.tPos.setPoint(nPosX, nPosY);

                        widgetInfo.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                        widgetInfo.strPic = CCXmlReader::getXMLNodeAttribStrs(&pWidgetNode, "pic");

                        xmlNodePtr pCtrlNode = pWidgetNode->xmlChildrenNode;

                        while(pCtrlNode)

                        {

                            if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "btn"))

                            {

                                CtrlInfo info;

                                info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                                string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                                int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                                sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                                info.tPos.setPoint(nPosX, nPosY);

                                info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                                strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                                float fAnchorX = , fAnchorY = ;

                                sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                                info.wType = CtrlInfo::_IDC_BTN;

                                info.btnType = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "type");

                                info.btnState = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "state");

                                info.strPic = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "pic");

                                info.strAudioFile = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "audio");

                                widgetInfo.m_vecCtrlInfo.push_back(info);

                            }

                            //图片控件

                            if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "img"))

                            {

                                CtrlInfo info;

                                info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                                string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                                int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                                sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                                info.tPos.setPoint(nPosX, nPosY);

                                info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                                info.strPic = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "pic");

                                strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                                float fAnchorX = , fAnchorY = ;

                                sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                                info.tAnchor.setPoint(fAnchorX, fAnchorY);

                                info.wType = CtrlInfo::_IDC_IMG;

                                widgetInfo.m_vecCtrlInfo.push_back(info);

                            }

                            //文本控件

                            if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "sta"))

                            {

                                CtrlInfo info;

                                info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                                string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                                int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                                sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                                info.tPos.setPoint(nPosX, nPosY);

                                info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                                strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                                float fAnchorX = , fAnchorY = ;

                                sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                                info.tAnchor.setPoint(fAnchorX, fAnchorY);

                                info.wType = CtrlInfo::_IDC_STA;

                                info.wLabelType = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "type");

                                info.strText = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "text");

                                info.nFontSize = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "fontsize");

                                info.strFont = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "font");

                                info.wAlignment = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "aligning");

                                strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "color");

                                int nR = , nG = , nB = ;

                                sscanf(strBuf.c_str(), "%d %d %d",&nR, &nG, &nB);

                                info.color3B.r = (char)nR;

                                info.color3B.g = (char)nG;

                                info.color3B.b = (char)nB;

                                widgetInfo.m_vecCtrlInfo.push_back(info);

                            }

                            //禁用触摸控件

                            if ( == xmlStrcmp(pCtrlNode->name, BAD_CAST "not"))

                            {

                                CtrlInfo info;

                                info.nId = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "id");

                                string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode,"pos");

                                int nPosX = , nPosY = , nRectX = , nRectY = , nRectW = , nRectH = ;

                                sscanf(strBuf.c_str(),"%d %d %d %d %d %d",&nPosX,&nPosY,&nRectX,&nRectY,&nRectW,&nRectH);

                                info.tPos.setPoint(nPosX, nPosY);

                                info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                                strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCtrlNode, "anchor");

                                float fAnchorX = , fAnchorY = ;

                                sscanf(strBuf.c_str(),"%f %f",&fAnchorX, &fAnchorY);

                                info.tAnchor.setPoint(fAnchorX, fAnchorY);

                                info.nPriority = CCXmlReader::getXMLNodeAttribInt(&pCtrlNode, "priority");

                                info.wType = CtrlInfo::_IDC_NOT;

                                widgetInfo.m_vecCtrlInfo.push_back(info);

                            }

                            pCtrlNode = pCtrlNode->next;

                        }

                        srollInfo.vecWidgetInfo.push_back(widgetInfo);

                    }

                    pWidgetNode = pWidgetNode->next;

                }

                m_vecSrollInfo.push_back(srollInfo);

            }

            pElement = pElement->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    }while();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

bool CConfig::loadEffectInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/effect.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "effects", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pElement = pRootNode->xmlChildrenNode;

        while (NULL != pElement)

        {

            if ( != xmlStrcmp(pElement->name, BAD_CAST "effect"))

            {

                pElement = pElement->next;

                continue;

            }

            EffectInfo effectInfo;

            effectInfo.strKey = CCXmlReader::getXMLNodeAttribStrs(&pElement, "key");

            string strEffectPosBuf = CCXmlReader::getXMLNodeAttribStrs(&pElement, "pos");

            int nRectX = , nRectY = , nRectW = , nRectH = ;

            sscanf(strEffectPosBuf.c_str(), "%d %d %d %d %d %d", &effectInfo.nPosX, &effectInfo.nPosY,

                &nRectX, &nRectY, &nRectW, &nRectH);

            effectInfo.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

            xmlNodePtr pCurNode = pElement->xmlChildrenNode;

            while (pCurNode)

            {

                if ( == xmlStrcmp(pCurNode->name, BAD_CAST "particle"))

                {

                    EffectInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "id");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "pos");

                    int nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(), "%d %d %d %d %d %d", &info.nPosX, &info.nPosY,

                        &nRectX, &nRectY, &nRectW, &nRectH);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    info.wType = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "type");

                    info.strFile = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "file");

                    effectInfo.vecEffectSub.push_back(info);

                }

                if ( == xmlStrcmp(pCurNode->name, BAD_CAST "action"))

                {

                }

                if ( == xmlStrcmp(pCurNode->name, BAD_CAST "Animate"))

                {

                    EffectInfo info;

                    info.nId = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "id");

                    string strBuf = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "pos");

                    int nRectX = , nRectY = , nRectW = , nRectH = ;

                    sscanf(strBuf.c_str(), "%d %d %d %d %d %d", &info.nPosX, &info.nPosY,

                        &nRectX, &nRectY, &nRectW, &nRectH);

                    info.rRect.setRect(nRectX, nRectY, nRectW, nRectH);

                    info.wType = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "type");

                    info.strFile = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "file");

                    effectInfo.vecEffectSub.push_back(info);

                }

                pCurNode = pCurNode->next;

            }

            m_vecEffectInfo.push_back(effectInfo);

            pElement = pElement->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

EffectInfo* CConfig::getEffectInfoByKey(const char* psKey)

{

    for (vector<EffectInfo>::iterator it = m_vecEffectInfo.begin(); it != m_vecEffectInfo.end(); it++)

    {

        if ( == strcmp(it->strKey.c_str(), psKey))

        {

            return &(*it);

        }

    }

    CCLog("error: CConfig::getEffectInfoByKey");

    return NULL;

}

vector<EffectInfo>* CConfig::getEffectInfo()

{

    return &m_vecEffectInfo;

}

vector<WidgetInfo>* CConfig::getSrollInfoByKey( const char* psKey )

{

    for (vector<SrollInfo>::iterator it = m_vecSrollInfo.begin(); it != m_vecSrollInfo.end(); it++)

    {

        if (it->strKey == psKey)

        {

            return & it->vecWidgetInfo;

        }

    }

    CCLog("error: CConfig::getSrollInfoByKey");

    return NULL;

}

bool CConfig::loadAudioInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/audio.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "audios", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pCurNode = pRootNode->xmlChildrenNode;

        while (NULL != pCurNode)

        {

            if ( != xmlStrcmp(pCurNode->name, BAD_CAST "audio"))

            {

                pCurNode = pCurNode->next;

                continue;

            }

            AudioInfo info;

            info.strKey = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "key");

            info.wType = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "type");

            info.strFile = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "file");

            m_vecAudioInfo.push_back(info);

            pCurNode = pCurNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

AudioInfo* CConfig::getAudioInfoByKey( const char* psKey )

{

    for (vector<AudioInfo>::iterator it = m_vecAudioInfo.begin(); it != m_vecAudioInfo.end(); it++)

    {

        if ( == strcmp(it->strKey.c_str(), psKey))

        {

            return &(*it);

        }

    }

    CCLog("error: CConfig::getAudioInfoByKey");

    return NULL;

}

vector<PlistInfo>* CConfig::getElementInfoByItem( int nId )

{

    for (vector<ElementInfo>::iterator it = m_vecElement.begin(); it != m_vecElement.end(); it++)

    {

        if (it->nItem == nId)

        {

            return &it->vecPlistInfo;

        }

    }

    CCLog("error: CConfig::getElementInfoById");

    return NULL;

}

ImageInfo* CConfig::getImageInfoByKey( const char* psKey )

{

    for (vector<ImageInfo>::iterator it = m_vecImageInfo.begin(); it != m_vecImageInfo.end(); it++)

    {

        if ( it->strKey == psKey)

        {

            return &(*it);

        }

    }

    CCLog("error: CConfig::getImageInfoByKey");

    return NULL;

}

bool CConfig::loadWordInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/word.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "words", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pCurNode = pRootNode->xmlChildrenNode;

        while (NULL != pCurNode)

        {

            if ( != xmlStrcmp(pCurNode->name, BAD_CAST "word"))

            {

                pCurNode = pCurNode->next;

                continue;

            }

            WordInfo info;

            info.strKey = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "key");

            info.strLetter = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "letter");

            m_mapWordInfo[info.strKey] = info;

            pCurNode = pCurNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

WordInfo& CConfig::getWordInfoByKey( const char* psKey )

{

    return m_mapWordInfo[psKey];

}

string CConfig::getWordBykey( const char* psKey )

{

    for (map<string, WordInfo>::iterator it = m_mapWordInfo.begin(); it != m_mapWordInfo.end(); it++)

    {

        if (it->first == psKey)

        {

            return it->second.strLetter;

        }

    }

    CCLog("warning: CConfig::getWordByKey");

    return "";

}

bool CConfig::loadActionInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/action.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "actions", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pCurNode = pRootNode->xmlChildrenNode;

        while (NULL != pCurNode)

        {

            if ( == xmlStrcmp(pCurNode->name, BAD_CAST "action"))

            {

                ActionInfo info;

                info.strKey = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "key");

                info.nAction = CCXmlReader::getXMLNodeAttribInt(&pCurNode, "type");

                info.strParm = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "parm");

                info.eType = ActionInfo::_Action;

                m_vecActionInfo.push_back(info);

            }

            if ( == xmlStrcmp(pCurNode->name, BAD_CAST "particle"))

            {

                ActionInfo info;

                info.strKey = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "key");

                info.strFile = CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "file");

                info.eType = ActionInfo::_Particle;

                m_vecActionInfo.push_back(info);

            }

            pCurNode = pCurNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

ActionInfo* CConfig::getActionInfoByKey( const char* psKey )

{

    for (vector<ActionInfo>::iterator it = m_vecActionInfo.begin(); it != m_vecActionInfo.end(); it++)

    {

        if (it->strKey == psKey)

        {

            return &(*it);

        }

    }

    CCLog("error: CConfig::getActionInfoByKey");

    return NULL;

}

bool CConfig::loadNumberInfo()

{

    string strFile = m_strResourcePath;

    strFile += "/config/number.xml";

    //读取文档

    xmlDocPtr pDoc = NULL;

    LOAD_XML_DOC(strFile.c_str(), pDoc);

    if (NULL == pDoc)

    {

        CCLog("can not read %s", strFile.c_str());

        return false;

    }

    do

    {

        xmlNodePtr pRootNode = xmlDocGetRootElement(pDoc);

        if (NULL == pRootNode)

        {

            break;

        }

        if( != xmlStrcmp(BAD_CAST "numbers", pRootNode->name))

        {

            break;

        }

        //读取节点

        xmlNodePtr pCurNode = pRootNode->xmlChildrenNode;

        while (NULL != pCurNode)

        {

            if ( == xmlStrcmp(pCurNode->name, BAD_CAST "number"))

            {

                m_mapNumber[CCXmlReader::getXMLNodeAttribStrs(&pCurNode, "key")]

                = CCXmlReader::getXMLNodeAttribfloat(&pCurNode, "num");

            }

            pCurNode = pCurNode->next;

        }

        xmlFreeDoc(pDoc);

        return true;

    } while ();

    xmlFreeDoc(pDoc);

    CCLog("read xml error : %s", strFile.c_str());

    return false;

}

float CConfig::getNumberByKey( const char* psKey )

{

    return m_mapNumber[psKey];

}