bool HeroSkillLayer::init(){
if ( !CCLayer::init() )
{
return false;
}
this->setTouchEnabled(true);
this->setTouchPriority(-128);
this->setTouchMode(kCCTouchesAllAtOnce);
//加载cocosbuilder
CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary()->registerCCNodeLoader("HeroSkillccbi",HeroSkillccbiLoder::loader());
/* Create an autorelease CCBReader. */
CCBReader * ccbReader = new cocos2d::extension::CCBReader(CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary());
ccbReader->autorelease();
/* Read a ccbi file. */
node2 = ccbReader->readNodeGraphFromFile("ccbi/HeroSkillccbi.ccbi", this);
if(node2 != NULL) {
this->addChild(node2);
}
this->setVisible(false);
isSkillLayer = true;
layervisable = false;
curPage = 0;//当前页
addsprite();
changeData();
scheduleUpdate();
return true;
}
void HelloWorld::menuCloseCallback(CCObject* pSender)
{
//CCDirector::sharedDirector()->end();
//#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
//exit(0);
// CCNodeLoaderLibrary* ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
// CCBReader* reader = new CCBReader(ccNodeLoaderLibrary);
// CCScene* scene = reader->createSceneWithNodeGraphFromFile("TeLabels.ccbi");
// CCDirector::sharedDirector()->replaceScene(CCTransitionFade::transitionWithDuration(2.0f, scene));
CCLog("1");
CCNodeLoaderLibrary* ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
CCLog("2");
CCBReader* reader = new CCBReader(ccNodeLoaderLibrary);
CCLog("3");
CCNode* scene = reader->readNodeGraphFromFile("TestLabels.ccbi");
CCLog("4");
CCSize size = CCDirector::sharedDirector()->getWinSize();
scene->setPosition(ccp(size.width/2, size.height/2));
if(scene != NULL)
{
this->addChild(scene, 2);
scene->release();
}
CCLog("5");
//#endif
}
JSBool js_CocosBuilder_create(JSContext *cx, uint32_t argc, jsval *vp)
{
NodeLoaderLibrary * ccNodeLoaderLibrary = NodeLoaderLibrary::getInstance();
ccNodeLoaderLibrary->registerNodeLoader("", JSLayerLoader::loader());
CCBReader * ret = new CCBReader(ccNodeLoaderLibrary);
ret->autorelease();
jsval jsret;
if (ret) {
js_proxy_t *proxy = jsb_get_native_proxy(ret);
if (proxy) {
jsret = OBJECT_TO_JSVAL(proxy->obj);
} else {
// create a new js obj of that class
proxy = js_get_or_create_proxy<CCBReader>(cx, ret);
jsret = OBJECT_TO_JSVAL(proxy->obj);
}
} else {
jsret = JSVAL_NULL;
}
JS_SET_RVAL(cx, vp, jsret);
return JS_TRUE;
}
bool Unit::Init(enUnitType eType, enUnitIndex eIndex)
{
do
{
unitDataMap unitData = GlobalData::sharedDirector()->getUnitDefaultData();
m_unitData = unitData[eType];
m_nFireCd = m_unitData.nFireCD;
m_eUnitType = m_unitData.eType;
m_eUnitStatus = enUnitStatusPre;
m_nHp = m_unitData.nHp;
m_eUnitIndex = eIndex;
CCNodeLoaderLibrary * ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
CCBReader * ccbReader = new CCBReader(ccNodeLoaderLibrary);
CCNode * ccbNode = ccbReader->readNodeGraphFromFile(m_unitData.strCCBI.c_str(), this);
m_animationManager = ccbReader->getAnimationManager();
m_animationManager->runAnimationsForSequenceNamed("run");
m_animationManager->setAnimationCompletedCallback(this, callfunc_selector(Unit::AnimationCallBack));
ccbReader->release();
addChild(ccbNode);
return true;
} while (false);
CCLog("Function Unit::Init Error!");
return false;
}
void XFightView::SetBoard(const char* pszBoardName, const char* pszStartName)
{
CCBReader* pCCBReader = new CCBReader(NodeLoaderLibrary::getInstance());
CCNode* pNode = NULL;
XYLOG_FAILED_JUMP(pCCBReader);
pCCBReader->autorelease();
if(m_pBoard)
{
removeChild(m_pBoard);
}
if(m_pFangKuaiParent)
{
removeChild(m_pFangKuaiParent);
}
m_pBoard = g_UIManager->GetInstanceByRootName(pszBoardName);//(BasicPanel*)pCCBReader->readNodeGraphFromFile(pszCCBFile);
XYLOG_FAILED_JUMP(m_pBoard);
m_pFangKuaiParent = m_pBoard->m_mapMemberVariable[pszStartName];
Exit0:
return;
}
bool TitleScene::init()
{
CCLOG("TitleScene::init()");
if ( !Layer::init() )
{
return false;
}
// BGM・SEのプリロード
SimpleAudioEngine::getInstance()->preloadBackgroundMusic(BGM_TITLE);
SimpleAudioEngine::getInstance()->preloadEffect(SE_TOUCH_NORMAL);
// タイトルのccbiファイルを読み込む
auto nodeLoaderLibrary = NodeLoaderLibrary::getInstance();
CCBReader* reader = new CCBReader(nodeLoaderLibrary);
auto TitleNode = reader->readNodeGraphFromFile("ccbi/TitleScene.ccbi");
// 追加
this->addChild(TitleNode, 0);
// 開放
reader->release();
// シングルタップのみ受付
setTouchEnabled(true);
setTouchMode(Touch::DispatchMode::ONE_BY_ONE);
return true;
}
bool AppDelegate::applicationDidFinishLaunching() {
// initialize director
CCDirector* pDirector = CCDirector::sharedDirector();
CCEGLView* pEGLView = CCEGLView::sharedOpenGLView();
pDirector->setOpenGLView(pEGLView);
// デザインサイズの設定
pEGLView->setDesignResolutionSize(designResolutionSize.width, designResolutionSize.height, kResolutionNoBorder);
CCSize frameSize = pEGLView->getFrameSize();
std::vector<std::string> searchPath;
if (frameSize.height > largeResource.size.height)
{
// iPad Retina用リソースを使用
searchPath.push_back(xlargeResource.directory);
pDirector->setContentScaleFactor(MIN(xlargeResource.size.height / designResolutionSize.height, xlargeResource.size.width / designResolutionSize.width));
}
else if (frameSize.height > smallResource.size.height)
{
// iPad用リソースを使用
searchPath.push_back(largeResource.directory);
pDirector->setContentScaleFactor(MIN(largeResource.size.height / designResolutionSize.height, largeResource.size.width / designResolutionSize.width));
}
else
{
// iPhone用リソースを使用
searchPath.push_back(smallResource.directory);
pDirector->setContentScaleFactor(MIN(smallResource.size.height / designResolutionSize.height, smallResource.size.width / designResolutionSize.width));
}
// リソースディレクトリを指定
CCFileUtils::sharedFileUtils()->setSearchPaths(searchPath);
// turn on display FPS
pDirector->setDisplayStats(true);
// set FPS. the default value is 1.0/60 if you don't call this
pDirector->setAnimationInterval(1.0 / 60);
// CocosBuilderのファイルを読み込みゲーム画面を生成する
CCNodeLoaderLibrary* ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
ccNodeLoaderLibrary->registerCCNodeLoader("GameLayer", GameLayerLoader::loader());
CCBReader* ccbReader = new CCBReader(ccNodeLoaderLibrary);
CCNode* node = ccbReader->readNodeGraphFromFile("GameLayer.ccbi");
((GameLayer*)node)->setAnimationManager(ccbReader->getAnimationManager());
// シーンを用意し、ゲーム画面を設置する
CCScene* pScene = CCScene::create();
if (node != NULL)
pScene->addChild(node);
ccbReader->release();
// run
pDirector->runWithScene(pScene);
return true;
}
bool AppDelegate::applicationDidFinishLaunching()
{
LoadFunc::registerLoader();
// initialize director
CCDirector *pDirector = CCDirector::sharedDirector();
pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());
// turn on display FPS
pDirector->setDisplayStats(true);
// set FPS. the default value is 1.0/60 if you don't call this
pDirector->setAnimationInterval(1.0 / 60);
// set game window siz(1024x577)
CCEGLView::sharedOpenGLView()->setDesignResolutionSize(1024, 577, kResolutionShowAll);
// create a scene. it's an autorelease object
CCNodeLoaderLibrary* ccNodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
CCBReader * ccbReader = new CCBReader(ccNodeLoaderLibrary);
CCNode* node = ccbReader->readNodeGraphFromFile("CollisionTestLayer.ccbi");
CCScene *scene = CCScene::create();
scene->addChild(node);
CC_SAFE_DELETE(ccbReader);
// run
pDirector->runWithScene(scene);
return true;
}
bool AppDelegate::applicationDidFinishLaunching() {
// initialize director
auto director = Director::getInstance();
auto eglView = EGLView::getInstance();
director->setOpenGLView(eglView);
// turn on display FPS
director->setDisplayStats(true);
// set FPS. the default value is 1.0/60 if you don't call this
director->setAnimationInterval(1.0 / 60);
// create a scene. it's an autorelease object
auto scene = Scene::create();
#if 0
NodeLoaderLibrary *pLoaderLibrary = NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
CCBReader *ccbReader = new CCBReader(pLoaderLibrary);
pLoaderLibrary->registerNodeLoader("plane_figtht_main", XCMainMenuLoader::loader());
Node *pMainMenu = ccbReader->readNodeGraphFromFile("ccb/ccbi/plane_fight_main.ccbi");
dynamic_cast<XCMainMenu*>(pMainMenu)->setAnimationManager(ccbReader->getAnimationManager());
dynamic_cast<XCMainMenu*>(pMainMenu)->initPlaneMain();
ccbReader->release();
scene->addChild(pMainMenu);
#else
#endif
// run
director->runWithScene(scene);
return true;
}
void LayerChonBanChoi::onButtonCreate(CCObject* pSender)
{
CCLOG("onButtonUpdate ");
//Check
boost::shared_ptr<double> am, amf;
boost::shared_ptr<User> myself = GameServer::getSingleton().getSmartFox()->MySelf();
if( myself==NULL || myself->GetVariable("am")==NULL || myself->GetVariable("amf")==NULL ){
return;
}
amf = myself->GetVariable("amf")->GetDoubleValue();
if((*amf/4)<1000){
CCLOG("Không đủ tiền tạo phòng!");
Chat *toast = new Chat("Bạn không đủ tiền tạo phòng!!", -1);
this->addChild(toast);
return;
}
CCNodeLoaderLibrary* ccNodeLoaderLibrary = SceneManager::getSingleton().getNodeLoaderLibrary();
CCBReader* ccbReader = new cocos2d::extension::CCBReader(ccNodeLoaderLibrary);
LayerCreateRoom* mLayer;
if (ccbReader)
{
mLayer = (LayerCreateRoom *)ccbReader->readNodeGraphFromFile( "LayerCreateRoom.ccbi" );
this->addChild(mLayer, 1, 1);
ccbReader->release();
}
mLayer->setGameID(m_gID);
}
CCBReader* CCBProxy::createCCBReader()
{
NodeLoaderLibrary *ccNodeLoaderLibrary = NodeLoaderLibrary::getInstance();
CCBReader * pCCBReader = new (std::nothrow) CCBReader(ccNodeLoaderLibrary);
pCCBReader->autorelease();
return pCCBReader;
}
// Constructor for the enemy. The layer is initialized in Model's constructor.
Enemy::Enemy(int x, int y) : Model(x,y)
{
// Create a default NodeLoaderLibrary.
NodeLoaderLibrary* nodeLoaderLibrary;
nodeLoaderLibrary = NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
// Create a new CCBReader with a default NodeLoaderLibrary
// This can take a lot of parameters to use code connections and more
CCBReader* ccbReader = new CCBReader(nodeLoaderLibrary);
// Load the main node from the CocosBuilder file
modelNodes = ccbReader->readNodeGraphFromFile("Orc.ccbi");
// Get the animationmanager so we can animate the thing afterwards
animationManager = ccbReader->getAnimationManager();
modelNodes->setPosition( Point(x, y));
//modelNodes->setScale(0.5f);
Node* rShoulder = modelNodes->getChildByTag(1)->getChildByTag(4)->getChildByTag(1);
rShoulder->setZOrder(0);
Node* lHip = modelNodes->getChildByTag(1)->getChildByTag(1);
lHip->setZOrder(0);
Node* rHip = modelNodes->getChildByTag(1)->getChildByTag(2);
rHip->setZOrder(0);
Node* rUpperArm = rShoulder->getChildByTag(2);
rUpperArm->setZOrder(-1);
Node* chest = modelNodes->getChildByTag(1)->getChildByTag(4)->getChildByTag(2);
chest->setZOrder(0);
Node* hips = modelNodes->getChildByTag(1)->getChildByTag(3);
hips->setZOrder(0);
modelNodes->getChildByTag(1)->getChildByTag(4)->setZOrder(0);
Node* lShoulder = modelNodes->getChildByTag(1)->getChildByTag(4)->getChildByTag(4);
lShoulder->setZOrder(3);
Node* rElbow = rShoulder->getChildByTag(1);
rElbow->setZOrder(1);
Node* rLowerArm = rShoulder->getChildByTag(1)->getChildByTag(1);
rLowerArm->setZOrder(2);
Node* rHand = rShoulder->getChildByTag(1)->getChildByTag(2);
rHand->getChildByTag(1)->setVisible(true);
rHand->setZOrder(2);
Node* neck = modelNodes->getChildByTag(1)->getChildByTag(4)->getChildByTag(3);
neck->setZOrder(2);
this->addChild(modelNodes); // Add the loaded node to the scene (this)
healthStatus->setPosition(Point(x-500, y+100));
this->addChild(healthStatus);
initAttacks();
// As nobody called ccbReader->autoRelease(), returning now would cause
// a memory leak. We can call autoRelease or delete it ourselves.
delete ccbReader;
}
CCScene* MainScene::getMainScene() {
NodeLoaderLibrary * ccNodeLoaderLibrary = NodeLoaderLibrary::sharedNodeLoaderLibrary();
ccNodeLoaderLibrary->registerCCNodeLoader("MainScene", MainSceneLoader::loader());
CCBReader *ccbReader = new CCBReader(ccNodeLoaderLibrary);
return ccbReader->createSceneWithNodeGraphFromFile("ccb/MainScreen.ccbi");
}
bool BalloonRankDialog::init()
{
bool bRet = false;
do
{
CC_BREAK_IF(!DialogLayer::init());
CCNodeLoaderLibrary* pLoaderLib = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
CCBReader* pCCBReader = new CCBReader(pLoaderLib);
std::string strCCBFileName = "BalloonRankDialog.ccbi";
const std::vector<std::string> vSearchOrder = CCFileUtils::sharedFileUtils()->getSearchResolutionsOrder();
std::string strCCBRootPath = vSearchOrder[0];
pCCBReader->setCCBRootPath(strCCBRootPath.c_str());
CCNode* pNode = pCCBReader->readNodeGraphFromFile(strCCBFileName.c_str(), this);
if (pNode != NULL)
{
this->addChild(pNode);
}
pCCBReader->release();
setKeypadEnabled(true);
initLabelTTF();
initTableView();
initMenu();
// start fire
CCArray* pArrayFire = CCArray::createWithCapacity(6);
for (int idx = 1; idx <= 6; ++idx)
{
pArrayFire->addObject(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(CCString::createWithFormat("energy_fire%d.png", idx)->getCString()));
}
CCAnimation* pAnimation = CCAnimation::createWithSpriteFrames(pArrayFire, 0.1f);
CCAnimate* pAnimateFire = CCAnimate::create(pAnimation);
m_pSpriteScoreFire->runAction(CCRepeatForever::create(pAnimateFire));
// set animation onEnter and onExit
m_pMainBoard = m_pSpriteBoard;
m_pSpriteBoard->setScale(0.01f);
setOnEnterAction(CCEaseBounceOut::create(CCScaleTo::create(0.5f, 1.0f)));
setOnExitAction(CCEaseExponentialIn::create(CCScaleTo::create(0.5f, 0.01f)));
bRet = true;
} while(0);
return bRet;
}
bool CResultDlg::init()
{
CCLayer::init() ;
CCNodeLoaderLibrary* plib = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary() ;
CCBReader* pread = new CCBReader(plib);
CCNode* pnode = pread->readNodeGraphFromFile("ResultDlg.ccbi", this) ;
addChild(pnode) ;
return true ;
}
//---------------------------------------
// カスタムクラスのパーツの取得(クラス名指定あり)
//---------------------------------------
CCNode* SceneChanger::loadCustomParts(const char* className, const char* fileName, CCNodeLoader* loader) {
CCNodeLoaderLibrary* ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
ccNodeLoaderLibrary->registerCCNodeLoader(className, loader);
CCBReader* ccbReader = new CCBReader(ccNodeLoaderLibrary);
CCString* file = CCString::createWithFormat("%s.ccbi", fileName);
CCNode* node = ccbReader->readNodeGraphFromFile(file->getCString());
ccbReader->release();
return node;
}
CCBReader* CCBProxy::createCCBReader()
{
CCNodeLoaderLibrary *ccNodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
CCBReader * pCCBReader = new CCBReader(ccNodeLoaderLibrary);
pCCBReader->autorelease();
return pCCBReader;
}
Node *CCBHelper::createSimpleCCBLayer(const char *ccbFileName, Object* pOwner)
{
NodeLoaderLibrary *loaderLibrary = NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
CCBReader *reader = new CCBReader(loaderLibrary); // library, memberAssigner, selectorResolver
Node *node = reader->readNodeGraphFromFile(ccbFileName, pOwner);
delete reader;
return node;
}
static int tolua_cocos2d_CCBReader_getSubReaders(lua_State* tolua_S)
{
if (nullptr == tolua_S)
return 0;
int argc = 0;
CCBReader* self = nullptr;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,1,"cc.CCBReader",0,&tolua_err)) goto tolua_lerror;
#endif
self = static_cast<CCBReader*>(tolua_tousertype(tolua_S,1,0));
#if COCOS2D_DEBUG >= 1
if (nullptr == self) {
tolua_error(tolua_S,"invalid 'self' in function 'tolua_cocos2d_CCBReader_getSubReaders'\n", NULL);
return 0;
}
#endif
argc = lua_gettop(tolua_S) - 1;
if (argc == 0)
{
auto tolua_ret = self->getSubCCBFiles();
if (tolua_ret.empty()) {
return 0;
}
int i = 1;
lua_newtable(tolua_S);
for(auto item : tolua_ret)
{
auto reader = item;
int ID = (reader) ? (int)reader->_ID : -1;
int* luaID = (reader) ? &reader->_luaID : NULL;
toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)reader,"cc.CCBReader");
lua_rawseti(tolua_S, -2, i);
++i;
}
return 1;
}
CCLOG("'getSubReaders' function of CCBReader has wrong number of arguments: %d, was expecting %d\n", argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'getSubReaders'.",&tolua_err);
return 0;
#endif
}
CCBReader* CCBProxy::createCCBReader()
{
NodeLoaderLibrary *ccNodeLoaderLibrary = NodeLoaderLibrary::getInstance();
ccNodeLoaderLibrary->registerNodeLoader("", CCBLayerLoader::loader());
CCBReader * pCCBReader = new CCBReader(ccNodeLoaderLibrary);
pCCBReader->autorelease();
return pCCBReader;
}
void BattleScene::initPauseLayer(){
CCNodeLoaderLibrary *nodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
CCBReader *reader = new CCBReader(nodeLoaderLibrary);
pauseLayer = (PauseLayer *)reader->readNodeGraphFromFile("BattleScenePauseMenu.ccbi", this);
pauseLayer->setBattleLayer(battleLayer);
pauseLayer->hide();
this->addChild(pauseLayer, PAUSE_LAYER_Z);
reader->release();
}
// load ccnode from ccbi
CCNode* CCBLoaderManager::LoadFromCCBI(CCNodeLoader* loader, const char* className, const char* ccbFileName)
{
CCNodeLoaderLibrary * ccNodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
ccNodeLoaderLibrary->registerCCNodeLoader(className, loader);
CCBReader* ccbReader = new CCBReader(ccNodeLoaderLibrary);
std::string path = "ccbi/";
path.append(ccbFileName);
CCNode* node = ccbReader->readNodeGraphFromFile(path.c_str());
delete ccbReader;
return node;
}
CCBReader* CCBProxy::createCCBreader()
{
CCNodeLoaderLibrary *ccNodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
ccNodeLoaderLibrary->registerCCNodeLoader("", CCBLayerLoader::loader());
CCBReader * pCCBReader = new CCBReader(ccNodeLoaderLibrary);
pCCBReader->autorelease();
return pCCBReader;
}
CCScene* StoreBScene::getStoreBScene() {
CCNodeLoaderLibrary * ccNodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
ccNodeLoaderLibrary->registerCCNodeLoader("StoreBScene", StoreBSceneLoader::loader());
CCBReader *ccbReader = new CCBReader(ccNodeLoaderLibrary);
ccbReader->retain();
CCScene *pScene = ccbReader->createSceneWithNodeGraphFromFile("ccb/StoreBScene.ccbi");
ccbReader->release();
return pScene;
}
FruitObject* FruitObject::node(const char *ccbName,int color)
{
CCNodeLoaderLibrary *nodeLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
nodeLibrary->registerCCNodeLoader("FruitObject", FruitObjectLoader::loader());
CCBReader *ccbReader = new CCBReader(nodeLibrary);
FruitObject *node1 = (FruitObject *)ccbReader->readNodeGraphFromFile(ccbName);
node1->color = color;
node1->choose = false;
// ccbReader->release();
return node1;
}
CCScene* BattleScene::scene(){
CCNodeLoaderLibrary *nodeLoaderLibrary = CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary();
CCBReader *reader = new CCBReader(nodeLoaderLibrary);
// 'scene' is an autorelease object.
CCScene *scene = reader->createSceneWithNodeGraphFromFile("BattleScene.ccbi");
reader->release();
// return the scene
return scene;
}
bool GameDisplayNode::initWithDictionary(CCDictionary * tmpDict){
CCNode * _displayNode = NULL;
if (tmpDict) {
CCString * strValue = (CCString *)tmpDict->objectForKey(KStrType);
uint32_t typeValue = strValue->uintValue();
strValue = (CCString *)tmpDict->objectForKey(KStrFile);
switch (typeValue) {
case GameObject::K_SPRITE_FRAME:
{
_displayNode = CCSprite::createWithSpriteFrameName(strValue->getCString());
this->addChild(_displayNode);
_defaultFrame = strValue->getCString();
}
break;
case GameObject::K_SPRITE_FILE:
{
_displayNode = CCSprite::create(strValue->getCString());
this->addChild(_displayNode);
_defaultFrame = strValue->getCString();
}
break;
case GameObject::K_CCBI_FILE:
{
//动画加载
CC_SAFE_RELEASE_NULL(_animationManager);
string ccbifile = strValue->getCString();
CCNodeLoaderLibrary *ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
CCBReader * ccBReader = new CCBReader(ccNodeLoaderLibrary);
_displayNode = ccBReader->readNodeGraphFromFile(ccbifile.c_str(),this,&_animationManager);
_animationManager->retain();
_animationManager->setDelegate(this);
this->addChild(_displayNode);
CC_SAFE_RELEASE_NULL(ccBReader);
CCString * default_frame = (CCString *)tmpDict->objectForKey(KStrDefaultFrame);
if (default_frame) {
_defaultFrame = default_frame->getCString();
}
CCString * default_anim=(CCString *)tmpDict->objectForKey(KStrDefaultAnim);
if (default_anim) {
_defaultAnimation = default_anim->getCString();
}
}
break;
default:
break;
}
}
return true;
}
void LayerFriend::gotoFriendDetails(){
removeOldView();
CCNodeLoaderLibrary* ccNodeLoaderLibrary = SceneManager::getSingleton().getNodeLoaderLibrary();
CCBReader* ccbReader = new cocos2d::extension::CCBReader(ccNodeLoaderLibrary);
LayerFriendDetails* mLayer;
if (ccbReader)
{
mLayer = (LayerFriendDetails *)ccbReader->readNodeGraphFromFile( "LayerFriendDetails.ccbi" );
nodeChild->addChild(mLayer, 1, 1);
ccbReader->release();
}
currNodeView = mLayer;
}
//void MapMenu1Layer::tableCB( CCObject* pObject )
//{
// CCMenuItemImage *mi = (CCMenuItemImage*)pObject;
// int tag = mi->getTag();
// switch (tag) {
// case 1:
// m_table1->setVisible(true);
// m_table2->setVisible(false);
// break;
// case 2:
// m_table1->setVisible(false);
// m_table2->setVisible(true);
// break;
// default:
// break;
// }
//}
void MapMenu1Layer::loadCCBFile(int i)
{
CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary()->registerCCNodeLoader( "ReviewLayer", ReviewLayerLoader::loader());
CCBReader* reader = new CCBReader( CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary() );
reader->autorelease();
char str[255];
sprintf(str,"wkszReview/ReviewLayer%d.ccbi",i);
CCNode* node = reader->readNodeGraphFromFile(str);
this->getParent()->addChild(node);
this->closeCB(NULL);
}
CCNode* AbstractNodeProvider::getNodeFromCcbFile(const char* pCcbFileName) {
CCBReader* pReader = new CCBReader(CCNodeLoaderLibrary::sharedCCNodeLoaderLibrary());
pReader->setCCBResourcePostfix(getResourcePostfix());
CCNode* pNode = pReader->readNodeGraphFromFile(pCcbFileName);
AnimationManagerAssigner *pAnimationManagerAssigner = dynamic_cast<AnimationManagerAssigner *>(pNode);
if (pAnimationManagerAssigner != NULL) {
pAnimationManagerAssigner->setAnimationManagers(pReader->getAnimationManagers());
}
pReader->release();
return pNode;
}
