void SceneRender::comCallBack(cocos2d::CCObject *tar, void *dict)
{
if (dict == NULL || tar == NULL)
{
return;
}
CCArmature *pAr = dynamic_cast<CCArmature*>(tar);
if (pAr == NULL)
{
return;
}
rapidjson::Value *v = (rapidjson::Value *)dict;
bool isShowColliderRect = DICTOOL->getBooleanValue_json(*v, "isShowColliderRect");
if (isShowColliderRect == false)
{
return;
}
ColliderRectDrawer *drawer = ColliderRectDrawer::create(pAr);
if (pAr->getParent())
{
pAr->getParent()->addChild(drawer);
}
drawer->setVisible(true);
}
void CCTween::arriveKeyFrame(CCFrameData *keyFrameData)
{
if(keyFrameData)
{
CCDisplayManager *displayManager = m_pBone->getDisplayManager();
//! Change bone's display
int displayIndex = keyFrameData->displayIndex;
if (!displayManager->getForceChangeDisplay())
{
displayManager->changeDisplayByIndex(displayIndex, false);
}
//! Update bone zorder, bone's zorder is determined by frame zorder and bone zorder
m_pTweenData->zOrder = keyFrameData->zOrder;
m_pBone->updateZOrder();
//! Update blend type
m_pBone->setBlendFunc(keyFrameData->blendFunc);
//! Update child armature's movement
CCArmature *childAramture = m_pBone->getChildArmature();
if(childAramture)
{
if(keyFrameData->strMovement.length() != 0)
{
childAramture->getAnimation()->play(keyFrameData->strMovement.c_str());
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------
void PersonView::createUI(void)
{
mInfo->hp = mInfo->maxHp = mConfig->hp();
mInfo->defense = mConfig->defe();
mInfo->attack = mConfig->att();
mInfo->maxattack = mConfig->maxatt();
mInfo->attackDelay = (float)mConfig->delay() / 1000;
CCArmature* armature = CCArmature::create(mConfig->name().c_str());
setAvatar(armature);
//if (id == 3)
//{
// CCBone* bone = armature->getBone("staff");
// CCSpriteDisplayData displayData;
// displayData.setParam("Pastor-weapon-pastor_staff_1.png");
// bone->addDisplay(&displayData, 1);
// bone->changeDisplayByIndex(1, true);
//}
if (mBloodBar == NULL)
{
mBloodBar = BloodBar::create();
CCRect trect = CCRectApplyAffineTransform(armature->boundingBox(), armature->nodeToParentTransform()); // 获取模型的大小
mBloodBar->setPositionY(trect.getMaxY());
addChild(mBloodBar, 1);
}
}
CCArmature* AnimLoader::createAnimationOneTime(const char *resName, const char *animName)
{
CCArmature *armature = CCArmature::create(resName);
armature->getAnimation()->play(animName, 0, 0, 1, 0);
armature->getAnimation()->setMovementEventCallFunc(armature, movementEvent_selector(AnimLoader::removeAnim));
return armature;
}
cocos2d::CCNode* SceneEditorTestLayer::createGameScene()
{
CCNode *pNode = CCSSceneReader::sharedSceneReader()->createNodeWithSceneFile("scenetest/FishJoy2.json");
if (pNode == NULL)
{
return NULL;
}
m_pCurNode = pNode;
//fishes
CCArmature *pBlowFish = getFish(10008, "blowFish");
CCArmature *pButterFlyFish = getFish(10009, "butterFlyFish");
pBlowFish->getAnimation()->playByIndex(0);
pButterFlyFish->getAnimation()->playByIndex(0);
CCMenuItemFont *itemBack = CCMenuItemFont::create("Back", this, menu_selector(SceneEditorTestLayer::toExtensionsMainLayer));
itemBack->setColor(ccc3(255, 255, 255));
itemBack->setPosition(ccp(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
CCMenu *menuBack = CCMenu::create(itemBack, NULL);
menuBack->setPosition(CCPointZero);
menuBack->setZOrder(4);
pNode->addChild(menuBack);
//ui action
cocos2d::extension::UIActionManager::shareManager()->PlayActionByName("startMenu_1.json","Animation1");
return pNode;
}
cocos2d::CCNode* SceneEditorTestLayer::createGameScene()
{
CCNode *pNode = CCJsonReader::sharedJsonReader()->createNodeWithJsonFile("FishJoy2.json");
if (pNode == NULL)
{
return NULL;
}
m_pCurNode = pNode;
//play back music
CCComAudio *pAudio = (CCComAudio*)(pNode->getComponent("Audio"));
pAudio->playBackgroundMusic(pAudio->getFile(), pAudio->getIsLoop());
//fishes
CCArmature *pBlowFish = getFish(5, "blowFish");
CCArmature *pButterFlyFish = getFish(6, "butterFlyFish");
pBlowFish->getAnimation()->playByIndex(0);
pButterFlyFish->getAnimation()->playByIndex(0);
CCMenuItemFont *itemBack = CCMenuItemFont::create("Back", this, menu_selector(SceneEditorTestLayer::toExtensionsMainLayer));
itemBack->setColor(ccc3(255, 255, 255));
itemBack->setPosition(ccp(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
CCMenu *menuBack = CCMenu::create(itemBack, NULL);
menuBack->setPosition(CCPointZero);
menuBack->setZOrder(4);
pNode->addChild(menuBack);
//ui action
cocos2d::extension::UIActionManager::shareManager()->PlayActionByName("startMenu_1.json","Animation1");
return pNode;
}
void PlayScene::RunAction(CCPoint pos, const char* name) {
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo("Action/Action.ExportJson");
CCArmature *armature = CCArmature::create("Action");
armature->getAnimation()->play(name);
armature->setPosition(pos);
this->addChild(armature, 2, 102);
armature->getAnimation()->setMovementEventCallFunc(this,movementEvent_selector(PlayScene::ArmatureCallBack));
}
void CCBatchNode::addChild(CCNode *child, int zOrder, int tag)
{
CCNode::addChild(child, zOrder, tag);
CCArmature *armature = dynamic_cast<CCArmature *>(child);
if (armature != NULL)
{
armature->setBatchNode(this);
}
}
void CCDisplayFactory::updateArmatureDisplay(CCBone *bone, CCNode *display, float dt, bool dirty)
{
CCArmature *armature = (CCArmature *)display;
if(armature)
{
armature->sortAllChildren();
armature->update(dt);
}
}
LayerChanToast::LayerChanToast(string message){
vector<string> lstRegex;
for( int i = 1; i <= 16; i++ ){
lstRegex.push_back( CCString::createWithFormat("(%d)", i)->getCString() );
}
this->setAnchorPoint(ccp(0, 0));
// text
cocos2d::ui::RichText* label = cocos2d::ui::RichText::create();
label->setAnchorPoint(ccp(0, 0));
label->setPosition(ccp(0, HEIGHT_DESIGN / 3.5));
vector<string> lstContents = mUtils::splitStringByListRegex(message, lstRegex);
int wLabel = 0, hLabel = 0;
for( int i = 0; i < lstContents.size(); i++ ){
bool check = false;
int j = 0;
for( j = 0; j < lstRegex.size(); j++ )
if( lstRegex.at(j) == lstContents.at(i) ){
check = true;
break;
}
if( check ){
CCArmature *armature = CCArmature::create(CCString::createWithFormat("onion%d", 1)->getCString());
armature->getAnimation()->playByIndex(j);
cocos2d::ui::RichElementCustomNode* recustom = cocos2d::ui::RichElementCustomNode::create(1, ccWHITE, 255, armature);
label->pushBackElement(recustom);
wLabel += 50;
hLabel = 55;
}else{
CCLabelTTF *l = CCLabelTTF::create(lstContents.at(i).c_str(), "Arial", 16);
l->setColor(ccc3(204, 16, 85));
cocos2d::ui::RichElementText* re1 = cocos2d::ui::RichElementText::create(1, ccWHITE, 255, lstContents.at(i).c_str(), "Arial", 16);
label->pushBackElement(re1);
wLabel += l->getContentSize().width;
hLabel = hLabel > 50 ? 55 : l->getContentSize().height;
}
}
this->addChild(label, 1, 0);
CCSize sizeDesign = CCSize(169, 30);
CCSpriteBatchNode *batchNode = CCSpriteBatchNode::create("chats/framechat_a.png");
CCScale9Sprite *blocks = CCScale9Sprite::create();
blocks ->updateWithBatchNode(batchNode , CCRect(0, 0, sizeDesign.width, sizeDesign.height), false, CCRect(10, 10, sizeDesign.width - 20, sizeDesign.height - 20));
CCSize size = CCSizeMake(wLabel + 10, hLabel + 5);
blocks ->setContentSize(size);
blocks->setAnchorPoint(ccp(0.5, 0.5));
blocks->setPosition(ccp(label->getPositionX() + wLabel / 2, label->getPositionY() + hLabel / 2));
blocks->setColor(ccc3(84, 81, 69));
blocks->setOpacity(200);
this->setPosition(ccp((WIDTH_DESIGN - size.width) / 2, 100));
// add
this->addChild(blocks);
}
CCArmature *CCArmature::create()
{
CCArmature *armature = new CCArmature();
if (armature && armature->init())
{
armature->autorelease();
return armature;
}
CC_SAFE_DELETE(armature);
return NULL;
}
Player::Player(CCNode* playerNode)
:CCObject()
{
this->playerNode = playerNode;
CCArmature* animationNode = (CCArmature*)playerNode->getComponent("CCArmature")->getNode();
this->animation = animationNode->getAnimation();
this->animation->setMovementEventCallFunc(this, movementEvent_selector(Player::onAnimationEvent));
currentState = IDLE;
newState = IDLE;
lockState = false;
}
CCArmature *CCArmature::create(const char *name)
{
CCArmature *armature = new CCArmature();
if (armature && armature->init(name))
{
CC_SAFE_AUTORELEASE(armature);
return armature;
}
CC_SAFE_DELETE(armature);
return NULL;
}
CCArmature *CCArmature::create(const char *name, CCBone *parentBone)
{
CCArmature *armature = new CCArmature();
if (armature && armature->init(name, parentBone))
{
armature->autorelease();
return armature;
}
CC_SAFE_DELETE(armature);
return NULL;
}
void HelloWorld::animationEvent(CCArmature *pArmature,
MovementEventType movementType, const char *movementID)
{
CCArmature *pEnemy = (CCArmature*)(m_pGameScene->getChildByTag(10006)->getComponent("CCArmature")->getNode());
if (movementType == COMPLETE)
{
pEnemy->getAnimation()->play("death");
pArmature->getAnimation()->setMovementEventCallFunc(NULL, NULL);
m_bDead = true;
}
}
void ArmaturePlayAction::done()
{
do
{
CCNode *pNode = SceneReader::sharedSceneReader()->getNodeByTag(_nTag);
CC_BREAK_IF(pNode == NULL);
CCComRender *pRender = (CCComRender*)(pNode->getComponent(_comName.c_str()));
CC_BREAK_IF(pRender == NULL);
CCArmature *pAr = (CCArmature *)(pRender->getNode());
CC_BREAK_IF(pAr == NULL);
pAr->getAnimation()->play(_aniname.c_str());
} while (0);
}
void HelloWorld::update(float delta)
{
if(m_bStart)
{
CCArmature *pHero = (CCArmature*)(m_pGameScene->getChildByTag(10005)->getComponent("CCArmature")->getNode());
pHero->getParent()->setPositionX(pHero->getParent()->getPositionX() + m_fSpeed);
CCArmature *pEnemy = (CCArmature*)(m_pGameScene->getChildByTag(10006)->getComponent("CCArmature")->getNode());
if(ccpDistance(ccp(pHero->getParent()->getPositionX(), 0), ccp(pEnemy->getParent()->getPositionX(), 0)) < m_fAttackDis)
{
pHero->getAnimation()->play("attack");
pHero->getAnimation()->setMovementEventCallFunc(this,
movementEvent_selector(HelloWorld::animationEvent));
m_bStart = false;
}
}
if(m_bDead)
{
CCComRender *pUIRender = static_cast<CCComRender*>(m_pGameScene->getChildByTag(10007)->getComponent("GUIComponent"));
UILayer *pUILayer = static_cast<UILayer*>(pUIRender->getNode());
UILoadingBar *pHPLoadingBar = static_cast<UILoadingBar*>(pUILayer->getWidgetByName("hp02_LoadingBar"));
UILoadingBar *pMPLoadingBar = static_cast<UILoadingBar*>(pUILayer->getWidgetByName("mp02_LoadingBar"));
pHPLoadingBar->setPercent(m_fPercentage);
pMPLoadingBar->setPercent(m_fPercentage);
m_fPercentage -= 2.0f;
if (m_fPercentage < 0.0f) {
unscheduleUpdate();
}
}
}
void CCDisplayFactory::createArmatureDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{
CCArmatureDisplayData *displayData = (CCArmatureDisplayData *)decoDisplay->getDisplayData();
CCArmature *armature = CCArmature::create(displayData->displayName.c_str(), bone);
/*
* because this bone have called this name, so armature should change it's name, or it can't add to
* CCArmature's bone children.
*/
armature->setName((bone->getName() + "_armatureChild").c_str());
decoDisplay->setDisplay(armature);
}
void TestDirectLoading::onEnter()
{
ArmatureTestLayer::onEnter();
// remove sigle resource
CCArmatureDataManager::sharedArmatureDataManager()->removeArmatureFileInfo("armature/bear.ExportJson");
// load resource directly
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo("armature/bear.ExportJson");
CCArmature *armature = CCArmature::create("bear");
armature->getAnimation()->playByIndex(0);
armature->setPosition(ccp(VisibleRect::center().x, VisibleRect::center().y));
addChild(armature);
}
void CCDisplayFactory::createSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{
CCSkin *skin = NULL;
CCSpriteDisplayData *displayData = (CCSpriteDisplayData *)decoDisplay->getDisplayData();
std::string textureName = displayData->displayName;
size_t startPos = textureName.find_last_of(".");
if(startPos != std::string::npos)
{
textureName = textureName.erase(startPos);
}
//! create display
if(textureName.length() == 0)
{
skin = CCSkin::create();
}
else
{
skin = CCSkin::createWithSpriteFrameName((textureName + ".png").c_str());
}
decoDisplay->setDisplay(skin);
if (skin == NULL)
{
return;
}
skin->setBone(bone);
initSpriteDisplay(bone, decoDisplay, displayData->displayName.c_str(), skin);
CCArmature *armature = bone->getArmature();
if (armature)
{
if (armature->getArmatureData()->dataVersion >= VERSION_COMBINED)
{
skin->setSkinData(displayData->skinData);
}
else
{
skin->setSkinData(*bone->getBoneData());
}
}
}
void CCBatchNode::draw()
{
CC_NODE_DRAW_SETUP();
CCObject *object = NULL;
CCARRAY_FOREACH(m_pChildren, object)
{
CCArmature *armature = dynamic_cast<CCArmature *>(object);
if (armature)
{
armature->visit();
m_pAtlas = armature->getTextureAtlas();
}
else
{
((CCNode *)object)->visit();
}
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
/////////////////////////////
// 2. add a menu item with "X" image, which is clicked to quit the program
// you may modify it.
// add a "close" icon to exit the progress. it's an autorelease object
CCMenuItemImage *pCloseItem = CCMenuItemImage::create(
"CloseNormal.png",
"CloseSelected.png",
this,
menu_selector(HelloWorld::menuCloseCallback));
pCloseItem->setPosition(ccp(origin.x + visibleSize.width - pCloseItem->getContentSize().width/2 ,
origin.y + pCloseItem->getContentSize().height/2));
// create menu, it's an autorelease object
CCMenu* pMenu = CCMenu::create(pCloseItem, NULL);
pMenu->setPosition(CCPointZero);
this->addChild(pMenu, 1);
/////////////////////////////
// 3. add your codes below...
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo("hero/Hero.ExportJson");
CCArmature* armature = CCArmature::create("Hero");
armature->getAnimation()->play("attack");
armature->setScale(1.5);
armature->setPosition(ccp(visibleSize.width*0.25, visibleSize.height*0.25));
addChild(armature);
return true;
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
m_fTime = 0.0f;
m_bStart = false;
m_bDead = false;
m_fPercentage = 100.0f;
m_fSpeed = 4.0f;
m_fAttackDis = 120.0f;
m_pGameScene = NULL;
CCNode *pGameScene = SceneReader::sharedSceneReader()->createNodeWithSceneFile("FightScene.json");
m_pGameScene = pGameScene;
this->addChild(pGameScene);
CCComRender *render = (CCComRender*)(m_pGameScene->getChildByTag(10005)->getComponent("CCArmature"));
CCArmature *pArmature = (CCArmature*)(render->getNode());
pArmature->getAnimation()->play("run");
m_bStart = true;
CCMenuItemFont *itemBack = CCMenuItemFont::create("End", this, menu_selector(HelloWorld::menuCloseCallback));
itemBack->setColor(ccc3(255, 255, 255));
itemBack->setPosition(ccp(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
CCMenu *menuBack = CCMenu::create(itemBack, NULL);
menuBack->setPosition(CCPointZero);
menuBack->setZOrder(4);
this->addChild(menuBack);
scheduleUpdate();
return true;
}
void CCDisplayFactory::createSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{
CCSkin *skin = NULL;
CCSpriteDisplayData *displayData = (CCSpriteDisplayData *)decoDisplay->getDisplayData();
std::string textureName = displayData->displayName;
//! create display
if(textureName.length() == 0)
{
skin = CCSkin::create();
}
else
{
skin = CCSkin::createWithSpriteFrameName((textureName + ".png").c_str());
}
skin->setBone(bone);
skin->setFlipX(displayData->flipX);
initSpriteDisplay(bone, decoDisplay, displayData->displayName.c_str(), skin);
CCArmature *armature = bone->getArmature();
if (armature)
{
if (armature->getArmatureData()->dataVersion >= VERSION_COMBINED)
{
skin->setSkinData(displayData->skinData);
}
else
{
skin->setSkinData(*bone->getBoneData());
}
}
decoDisplay->setDisplay(skin);
}
bool MainMenuScene::init()
{
menuLayer = CCLayer::create();
CCSize size = CCDirector::sharedDirector()->getWinSize();
// Add backgrounbdPic
CCSprite* backGroundPic = CCSprite::create("pictures/mainMenuBackGround.png");
backGroundPic->setAnchorPoint(ccp(0, 0));
menuLayer->addChild(backGroundPic,0);
// Add ChenXiaoG welcome armature
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo("animations/ChenXiaoGeWelcome.ExportJson");
CCArmature *armature = CCArmature::create("ChenXiaoGeWelcome");
armature->getAnimation()->play("Animation1");
armature->getAnimation()->setSpeedScale(1.5f);
armature->setAnchorPoint(ccp(0,0));
armature->setPosition(ccp(size.width/8, size.height/6));
armature->setScale(0.5);
menuLayer->addChild(armature,1);
//Add StartBtn
CCSprite* start = CCSprite::create("pictures/startbtn.png");
CCSprite* startPush = CCSprite::create("pictures/startbtnPush.png");
CCMenuItemSprite * startBtn = CCMenuItemSprite::create(start, startPush, this, menu_selector(MainMenuScene::startBtnCallFunc));
//Add Menu
mainMenu = CCMenu::create(startBtn, NULL);
mainMenu->setAnchorPoint(ccp(0, 0));
mainMenu->setPosition(ccp(size.width/6, size.height/1.3));
menuLayer->addChild(mainMenu,2);
//Add snow particle
CCParticleSystem *particle = CCParticleSnow::create();
particle->setTexture(CCTextureCache::sharedTextureCache()->addImage("pictures/snow.png"));
menuLayer->addChild(particle,3);
this->addChild(menuLayer ,0);
return true;
}
CCNode* SceneReader::createObject(const rapidjson::Value &root, cocos2d::CCNode* parent)
{
const char *className = DICTOOL->getStringValue_json(root, "classname"); //inputFiles->getItemStringValue("classname");
if(strcmp(className, "CCNode") == 0)
{
CCNode* gb = NULL;
if(NULL == parent)
{
gb = CCNode::create();
}
else
{
gb = CCNode::create();
parent->addChild(gb);
}
setPropertyFromJsonDict(root, gb);
int count = DICTOOL->getArrayCount_json(root, "components");
for (int i = 0; i < count; i++)
{
const rapidjson::Value &subDict = DICTOOL->getSubDictionary_json(root, "components", i);
if (!DICTOOL->checkObjectExist_json(subDict))
{
break;
}
const char *comName = DICTOOL->getStringValue_json(subDict, "classname");
const char *pComName = DICTOOL->getStringValue_json(subDict, "name");
const rapidjson::Value &fileData = DICTOOL->getSubDictionary_json(subDict, "fileData");
std::string pPath;
std::string pPlistFile;
int nResType = 0;
//if (fileData != NULL)
if (DICTOOL->checkObjectExist_json(fileData))
{
const char *file = DICTOOL->getStringValue_json(fileData, "path");
nResType = DICTOOL->getIntValue_json(fileData, "resourceType", - 1);
const char *plistFile = DICTOOL->getStringValue_json(fileData, "plistFile");
if (file != NULL)
{
pPath.append(cocos2d::CCFileUtils::sharedFileUtils()->fullPathForFilename(file));
}
if (plistFile != NULL)
{
pPlistFile.append(cocos2d::CCFileUtils::sharedFileUtils()->fullPathForFilename(plistFile));
}
}
if (comName != NULL && strcmp(comName, "CCSprite") == 0)
{
cocos2d::CCSprite *pSprite = NULL;
if (nResType == 0)
{
if (pPath.find(".png") == pPath.npos)
{
continue;
}
pSprite = CCSprite::create(pPath.c_str());
}
else if (nResType == 1)
{
std::string pngFile = pPlistFile;
std::string::size_type pos = pngFile.find(".plist");
if (pos == pPath.npos)
{
continue;
}
pngFile.replace(pos, pngFile.length(), ".png");
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(pPlistFile.c_str(), pngFile.c_str());
pSprite = CCSprite::createWithSpriteFrameName(pPath.c_str());
}
else
{
continue;
}
CCComRender *pRender = CCComRender::create(pSprite, "CCSprite");
if (pComName != NULL)
{
pRender->setName(pComName);
}
gb->addComponent(pRender);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pSprite, (void*)(&subDict));
}
}
else if(comName != NULL && strcmp(comName, "CCTMXTiledMap") == 0)
{
cocos2d::CCTMXTiledMap *pTmx = NULL;
if (nResType == 0)
{
if (pPath.find(".tmx") == pPath.npos)
{
continue;
}
pTmx = CCTMXTiledMap::create(pPath.c_str());
}
else
{
continue;
}
CCComRender *pRender = CCComRender::create(pTmx, "CCTMXTiledMap");
if (pComName != NULL)
{
pRender->setName(pComName);
}
gb->addComponent(pRender);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pTmx, (void*)(&subDict));
}
}
else if(comName != NULL && strcmp(comName, "CCParticleSystemQuad") == 0)
{
std::string::size_type pos = pPath.find(".plist");
if (pos == pPath.npos)
{
continue;
}
cocos2d::CCParticleSystemQuad *pParticle = NULL;
if (nResType == 0)
{
pParticle = CCParticleSystemQuad::create(pPath.c_str());
}
else
{
CCLog("unknown resourcetype on CCParticleSystemQuad!");
}
pParticle->setPosition(0, 0);
CCComRender *pRender = CCComRender::create(pParticle, "CCParticleSystemQuad");
if (pComName != NULL)
{
pRender->setName(pComName);
}
gb->addComponent(pRender);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pParticle, (void*)(&subDict));
}
}
else if(comName != NULL && strcmp(comName, "CCArmature") == 0)
{
if (nResType != 0)
{
continue;
}
std::string reDir = pPath;
std::string file_path = "";
size_t pos = reDir.find_last_of('/');
if (pos != std::string::npos)
{
file_path = reDir.substr(0, pos+1);
}
rapidjson::Document jsonDict;
if(!readJson(pPath.c_str(), jsonDict))
{
CCLog("read json file[%s] error!\n", pPath.c_str());
continue;
}
int childrenCount = DICTOOL->getArrayCount_json(jsonDict, "armature_data");
const rapidjson::Value &subData = DICTOOL->getDictionaryFromArray_json(jsonDict, "armature_data", 0);
const char *name = DICTOOL->getStringValue_json(subData, "name");
childrenCount = DICTOOL->getArrayCount_json(jsonDict, "config_file_path");
for (int i = 0; i < childrenCount; ++i)
{
const char* plist = DICTOOL->getStringValueFromArray_json(jsonDict, "config_file_path", i);
if (plist == NULL)
{
continue;
}
std::string plistpath;
plistpath += file_path;
plistpath.append(plist);
cocos2d::CCDictionary *root = CCDictionary::createWithContentsOfFile(plistpath.c_str());
CCDictionary* metadata = DICTOOL->getSubDictionary(root, "metadata");
const char* textureFileName = DICTOOL->getStringValue(metadata, "textureFileName");
std::string textupath;
textupath += file_path;
textupath.append(textureFileName);
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo(textupath.c_str(), plistpath.c_str(), pPath.c_str());
}
CCArmature *pAr = CCArmature::create(name);
CCComRender *pRender = CCComRender::create(pAr, "CCArmature");
if (pComName != NULL)
{
pRender->setName(pComName);
}
gb->addComponent(pRender);
const char *actionName = DICTOOL->getStringValue_json(subDict, "selectedactionname");
if (actionName != NULL && pAr->getAnimation() != NULL)
{
pAr->getAnimation()->play(actionName);
}
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pAr, (void*)(&subDict));
}
}
else if(comName != NULL && strcmp(comName, "CCComAudio") == 0)
{
CCComAudio *pAudio = NULL;
if (nResType == 0)
{
pAudio = CCComAudio::create();
}
else
{
continue;
}
pAudio->preloadEffect(pPath.c_str());
gb->addComponent(pAudio);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pAudio, (void*)(&subDict));
}
}
else if(comName != NULL && strcmp(comName, "CCComAttribute") == 0)
{
CCComAttribute *pAttribute = NULL;
if (nResType == 0)
{
pAttribute = CCComAttribute::create();
unsigned long size = 0;
const char* pData = 0;
pData = (char*)(cocos2d::CCFileUtils::sharedFileUtils()->getFileData(pPath.c_str(), "r", &size));
if(pData != NULL && strcmp(pData, "") != 0)
{
pAttribute->parse(pData);
}
}
else
{
CCLog("unknown resourcetype on CCComAttribute!");
continue;
}
gb->addComponent(pAttribute);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pAttribute, (void*)(&subDict));
}
}
else if (comName != NULL && strcmp(comName, "CCBackgroundAudio") == 0)
{
CCComAudio *pAudio = NULL;
if (nResType == 0)
{
pAudio = CCComAudio::create();
}
else
{
continue;
}
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8)
// no MP3 support for CC_PLATFORM_WP8
std::string::size_type pos = pPath.find(".mp3");
if (pos == pPath.npos)
{
continue;
}
pPath.replace(pos, pPath.length(), ".wav");
#endif
pAudio->preloadBackgroundMusic(pPath.c_str());
pAudio->setFile(pPath.c_str());
bool bLoop = (bool)(DICTOOL->getIntValue_json(subDict, "loop"));
pAudio->setLoop(bLoop);
gb->addComponent(pAudio);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pAudio, (void*)(&subDict));
}
pAudio->playBackgroundMusic(pPath.c_str(), bLoop);
}
else if(comName != NULL && strcmp(comName, "GUIComponent") == 0)
{
cocos2d::extension::UILayer *pLayer = cocos2d::extension::UILayer::create();
pLayer->scheduleUpdate();
UIWidget* widget = cocos2d::extension::GUIReader::shareReader()->widgetFromJsonFile(pPath.c_str());
pLayer->addWidget(widget);
CCComRender *pRender = CCComRender::create(pLayer, "GUIComponent");
if (pComName != NULL)
{
pRender->setName(pComName);
}
gb->addComponent(pRender);
if (_pListener && _pfnSelector)
{
(_pListener->*_pfnSelector)(pLayer, (void*)(&subDict));
}
}
}
int length = DICTOOL->getArrayCount_json(root, "gameobjects");
for (int i = 0; i < length; ++i)
{
const rapidjson::Value &subDict = DICTOOL->getSubDictionary_json(root, "gameobjects", i);
if (!DICTOOL->checkObjectExist_json(subDict))
{
break;
}
createObject(subDict, gb);
}
return gb;
}
return NULL;
}
bool CCComRender::serialize(void* r)
{
bool bRet = false;
do
{
CC_BREAK_IF(r == NULL);
SerData *pSerData = (SerData *)(r);
const rapidjson::Value *v = pSerData->prData;
stExpCocoNode *pCocoNode = pSerData->pCocoNode;
const char *pClassName = NULL;
const char *pComName = NULL;
const char *pFile = NULL;
const char *pPlist = NULL;
std::string strFilePath;
std::string strPlistPath;
int nResType = 0;
if (v != NULL)
{
pClassName = DICTOOL->getStringValue_json(*v, "classname");
CC_BREAK_IF(pClassName == NULL);
pComName = DICTOOL->getStringValue_json(*v, "name");
const rapidjson::Value &fileData = DICTOOL->getSubDictionary_json(*v, "fileData");
CC_BREAK_IF(!DICTOOL->checkObjectExist_json(fileData));
pFile = DICTOOL->getStringValue_json(fileData, "path");
pPlist = DICTOOL->getStringValue_json(fileData, "plistFile");
CC_BREAK_IF(pFile == NULL && pPlist == NULL);
nResType = DICTOOL->getIntValue_json(fileData, "resourceType", -1);
}
else if(pCocoNode != NULL)
{
pClassName = pCocoNode[1].GetValue();
CC_BREAK_IF(pClassName == NULL);
pComName = pCocoNode[2].GetValue();
stExpCocoNode *pfileData = pCocoNode[4].GetChildArray();
CC_BREAK_IF(!pfileData);
pFile = pfileData[0].GetValue();
pPlist = pfileData[1].GetValue();
CC_BREAK_IF(pFile == NULL && pPlist == NULL);
nResType = atoi(pfileData[2].GetValue());
}
if (pComName != NULL)
{
setName(pComName);
}
else
{
setName(pClassName);
}
if (pFile != NULL)
{
strFilePath.assign(cocos2d::CCFileUtils::sharedFileUtils()->fullPathForFilename(pFile));
}
if (pPlist != NULL)
{
strPlistPath.assign(cocos2d::CCFileUtils::sharedFileUtils()->fullPathForFilename(pPlist));
}
if (nResType == 0)
{
if (strcmp(pClassName, "CCSprite") == 0 && (strFilePath.find(".png") != strFilePath.npos || strFilePath.find(".pvr.ccz") != strFilePath.npos))
{
m_pRender = CCSprite::create(strFilePath.c_str());
m_pRender->retain();
bRet = true;
}
else if(strcmp(pClassName, "CCTMXTiledMap") == 0 && strFilePath.find(".tmx") != strFilePath.npos)
{
m_pRender = CCTMXTiledMap::create(strFilePath.c_str());
m_pRender->retain();
bRet = true;
}
else if(strcmp(pClassName, "CCParticleSystemQuad") == 0 && strFilePath.find(".plist") != strFilePath.npos)
{
m_pRender = CCParticleSystemQuad::create(strFilePath.c_str());
m_pRender->setPosition(ccp(0.0f, 0.0f));
m_pRender->retain();
bRet = true;
}
else if(strcmp(pClassName, "CCArmature") == 0)
{
std::string file_extension = strFilePath;
size_t pos = strFilePath.find_last_of('.');
if (pos != std::string::npos)
{
file_extension = strFilePath.substr(pos, strFilePath.length());
std::transform(file_extension.begin(),file_extension.end(), file_extension.begin(), (int(*)(int))toupper);
}
if (file_extension == ".JSON" || file_extension == ".EXPORTJSON")
{
rapidjson::Document doc;
if(!readJson(strFilePath.c_str(), doc))
{
CCLog("read json file[%s] error!\n", strFilePath.c_str());
continue;
}
const rapidjson::Value &subData = DICTOOL->getDictionaryFromArray_json(doc, "armature_data", 0);
const char *name = DICTOOL->getStringValue_json(subData, "name");
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo(strFilePath.c_str());
CCArmature *pAr = CCArmature::create(name);
m_pRender = pAr;
m_pRender->retain();
const char *actionName = NULL;
if (pCocoNode != NULL)
{
actionName = pCocoNode[6].GetValue();//DICTOOL->getStringValue_json(*v, "selectedactionname");
}
else
{
actionName = DICTOOL->getStringValue_json(*v, "selectedactionname");
}
if (actionName != NULL && pAr->getAnimation() != NULL)
{
pAr->getAnimation()->play(actionName);
}
bRet = true;
}
else if (file_extension == ".CSB")
{
unsigned long size = 0;
unsigned char *pBytes = NULL;
std::string binaryFilePath = CCFileUtils::sharedFileUtils()->fullPathForFilename(strFilePath.c_str());
pBytes = cocos2d::CCFileUtils::sharedFileUtils()->getFileData(binaryFilePath.c_str(), "rb", &size);
CC_BREAK_IF(pBytes == NULL || strcmp((char*)pBytes, "") == 0);
CocoLoader tCocoLoader;
if (tCocoLoader.ReadCocoBinBuff((char*)pBytes))
{
stExpCocoNode *tpRootCocoNode = tCocoLoader.GetRootCocoNode();
rapidjson::Type tType = tpRootCocoNode->GetType(&tCocoLoader);
if (rapidjson::kObjectType == tType)
{
int count = tpRootCocoNode->GetChildNum();
stExpCocoNode *tpChildArray = tpRootCocoNode->GetChildArray();
for (int i = 0; i < count; ++i)
{
std::string key = tpChildArray[i].GetName(&tCocoLoader);
const char *str = tpChildArray[i].GetValue();
if (key.compare("armature_data") == 0)
{
int length = tpChildArray[i].GetChildNum();
stExpCocoNode *armature_dataArray = tpChildArray[i].GetChildArray();
if (length < 1)
{
continue;
}
length = armature_dataArray[0].GetChildNum();
stExpCocoNode *armature_data = armature_dataArray[0].GetChildArray();
for (int i = 0; i < length; ++i)
{
std::string key = armature_data[i].GetName(&tCocoLoader);
const char *str = armature_data[i].GetValue();
if (key.compare("name") == 0)
{
if (str != NULL)
{
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo(strFilePath.c_str());
CCArmature *pAr = CCArmature::create(str);
m_pRender = pAr;
m_pRender->retain();
const char *actionName = NULL;
if (pCocoNode != NULL)
{
actionName = pCocoNode[6].GetValue();//DICTOOL->getStringValue_json(*v, "selectedactionname");
}
else
{
actionName = DICTOOL->getStringValue_json(*v, "selectedactionname");
}
if (actionName != NULL && pAr->getAnimation() != NULL)
{
pAr->getAnimation()->play(actionName);
}
bRet = true;
}
}
}
}
}
}
}
else
{
continue;
}
}
else
{
continue;
}
}
else if(strcmp(pClassName, "GUIComponent") == 0)
{
std::string file_extension = strFilePath;
size_t pos = strFilePath.find_last_of('.');
if (pos != std::string::npos)
{
file_extension = strFilePath.substr(pos, strFilePath.length());
std::transform(file_extension.begin(),file_extension.end(), file_extension.begin(), (int(*)(int))toupper);
}
if (file_extension == ".JSON" || file_extension == ".EXPORTJSON")
{
cocos2d::ui::TouchGroup* tg = cocos2d::ui::TouchGroup::create();
cocos2d::ui::Widget* widget = cocos2d::extension::GUIReader::shareReader()->widgetFromJsonFile(strFilePath.c_str());
tg->addWidget(widget);
m_pRender = tg;
m_pRender->retain();
bRet = true;
}
else if (file_extension == ".CSB")
{
cocos2d::ui::TouchGroup* tg = cocos2d::ui::TouchGroup::create();
cocos2d::ui::Widget* widget = cocos2d::extension::GUIReader::shareReader()->widgetFromBinaryFile(strFilePath.c_str());
tg->addWidget(widget);
m_pRender = tg;
m_pRender->retain();
bRet = true;
}
}
else
{
CC_BREAK_IF(true);
}
}
else if (nResType == 1)
{
if (strcmp(pClassName, "CCSprite") == 0)
{
std::string strPngFile = strPlistPath;
std::string::size_type pos = strPngFile.find(".plist");
if (pos == strPngFile.npos)
{
continue;
}
strPngFile.replace(pos, strPngFile.length(), ".png");
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(strPlistPath.c_str(), strPngFile.c_str());
m_pRender = CCSprite::createWithSpriteFrameName(strFilePath.c_str());
m_pRender->retain();
bRet = true;
}
else
{
CC_BREAK_IF(true);
}
}
else
{
CC_BREAK_IF(true);
}
} while (0);
return bRet;
}
// on "init" you need to initialize your instance
bool LayerChatWindow::init()
{
//////////////////////////////
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
lstStringMessage.clear();
lstStringMessage.push_back("Nhanh lên nào (14)!");
lstStringMessage.push_back("Mạng lag quá (9)!");
lstStringMessage.push_back("Bài xấu quá (3)!");
lstStringMessage.push_back("Hehe, lên nóc nhà\nmà bắt con gà (6)");
lstStringMessage.push_back("Nhất rồi, haha (1)");
lstStringMessage.push_back("Đánh gà thế (11)!");
lstStringMessage.push_back("Đỏ vãi lúa (13)!");
lstStringMessage.push_back("Nhọ như chó mực (5)!");
//return true;
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
_count = 100;
layerButton = UILayer::create();
layerButton->addWidget(GUIReader::shareReader()->widgetFromJsonFile("LayerChatWindow_1.ExportJson"));
this->addChild(layerButton);
layerButton->setTouchPriority(-128);
this->setTouchEnabled(true);
//Get all chat button
for( int i = 1; i <= 8; i++ ){
UIButton* btnChat = dynamic_cast<UIButton*>(layerButton->getWidgetByName( CCString::createWithFormat("btnChat%d", i)->getCString() ));
btnChat->setTitleText( lstStringMessage.at(i-1).c_str() );
btnChat->addTouchEventListener(this,(SEL_TouchEvent)&LayerChatWindow::onButtonChats);
}
UIButton* btnClose = dynamic_cast<UIButton*>(layerButton->getWidgetByName("btnClose"));
btnClose->addTouchEventListener(this,(SEL_TouchEvent)&LayerChatWindow::onButtonClose);
//
UIButton* btnSend = dynamic_cast<UIButton*>(layerButton->getWidgetByName("btnSend"));
btnSend->addTouchEventListener(this,(SEL_TouchEvent)&LayerChatWindow::onButtonSend);
txtChat = dynamic_cast<UITextField*>(layerButton->getWidgetByName("txtChat"));
txtChat->setText("");
txtChat->setPlaceHolder("Noi dung");
txtChat->setTextHorizontalAlignment(kCCTextAlignmentCenter);
txtChat->setTextVerticalAlignment(kCCVerticalTextAlignmentCenter);
txtChat->addEventListenerTextField(this, textfieldeventselector(LayerChatWindow::textFieldEvent));
UIPanel* pEmo = dynamic_cast<UIPanel*>(layerButton->getWidgetByName("pEmo"));
UIImageView* pImg = dynamic_cast<UIImageView*>(layerButton->getWidgetByName("Image_25_0"));
//Add all emo to this
int i = 1;
// CCArmatureDataManager::sharedArmatureDataManager()->removeArmatureFileInfo(CCString::createWithFormat("onion%d.ExportJson", 1)->getCString());
// CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo(CCString::createWithFormat("onion%d.ExportJson", 1)->getCString());
int row=-1, col = 1;
int widthOfPage = 580;
int numOfCols = 9;
int space = 10;
int widthOfImage = 50;
int startPosX = widthOfPage/2 - (widthOfImage+space)*numOfCols/2 - 300;
int startPosY = space - 100;
lstEmo.clear();
for( int i = 1; i<=16; i++ ){
CCArmature *armature = CCArmature::create(CCString::createWithFormat("onion%d", 1)->getCString());
armature->getAnimation()->playByIndex(i-1);
RichElementCustomNode* recustom = RichElementCustomNode::create(1, ccWHITE, 255, armature);
RichText* _richText = RichText::create();
_richText->setContentSize( armature->getContentSize() );
_richText->pushBackElement(recustom);
if( col> numOfCols ){
row++;
col = 1;
}
_richText->setAnchorPoint(ccp(0, 1));
_richText->setPosition(ccp( startPosX + 60*(col-1)
, -1*row*50 - startPosY - (row+1)*space ));
_richText->addTouchEventListener(this,(SEL_TouchEvent)&LayerChatWindow::OnEmoClick);
lstEmo.push_back( armature );
UIButton* b = UIButton::create();
b->setPosition(ccp( startPosX + 60*(col-1)
, -1*row*50 - startPosY - (row+1)*space ));
b->setAnchorPoint(ccp(0, 1));
b->setContentSize( armature->getContentSize() );
b->addTouchEventListener(this,(SEL_TouchEvent)&LayerChatWindow::OnEmoClick);
b->loadTextures("emo_blank.png", "", "");
b->setTag(i);
pImg->addChild( _richText );
pImg->addChild( b );
//CCLOG("button w: %lf h: %lf", b->getContentSize().width, b->getContentSize().height);
col++;
}
return true;
}
CCArmature* AnimLoader::createAnimation(const char *resName, const char *animName)
{
CCArmature *armature = CCArmature::create(resName);
armature->getAnimation()->play(animName, 0, 0, -1, 0);
return armature;
}
bool CCComRender::serialize(void* r)
{
bool bRet = false;
do
{
CC_BREAK_IF(r == NULL);
rapidjson::Value *v = (rapidjson::Value *)r;
const char *pClassName = DICTOOL->getStringValue_json(*v, "classname");
CC_BREAK_IF(pClassName == NULL);
const char *pComName = DICTOOL->getStringValue_json(*v, "name");
if (pComName != NULL)
{
setName(pComName);
}
else
{
setName(pClassName);
}
const rapidjson::Value &fileData = DICTOOL->getSubDictionary_json(*v, "fileData");
CC_BREAK_IF(!DICTOOL->checkObjectExist_json(fileData));
const char *pFile = DICTOOL->getStringValue_json(fileData, "path");
const char *pPlist = DICTOOL->getStringValue_json(fileData, "plistFile");
CC_BREAK_IF(pFile == NULL && pPlist == NULL);
std::string strFilePath;
std::string strPlistPath;
if (pFile != NULL)
{
strFilePath.assign(cocos2d::CCFileUtils::sharedFileUtils()->fullPathForFilename(pFile));
}
if (pPlist != NULL)
{
strPlistPath.assign(cocos2d::CCFileUtils::sharedFileUtils()->fullPathForFilename(pPlist));
}
int nResType = DICTOOL->getIntValue_json(fileData, "resourceType", -1);
if (nResType == 0)
{
if (strcmp(pClassName, "CCSprite") == 0 && strFilePath.find(".png") != strFilePath.npos)
{
m_pRender = CCSprite::create(strFilePath.c_str());
}
else if(strcmp(pClassName, "CCTMXTiledMap") == 0 && strFilePath.find(".tmx") != strFilePath.npos)
{
m_pRender = CCTMXTiledMap::create(strFilePath.c_str());
}
else if(strcmp(pClassName, "CCParticleSystemQuad") == 0 && strFilePath.find(".plist") != strFilePath.npos)
{
m_pRender = CCParticleSystemQuad::create(strFilePath.c_str());
m_pRender->setPosition(ccp(0.0f, 0.0f));
}
else if(strcmp(pClassName, "CCArmature") == 0)
{
std::string reDir = strFilePath;
std::string file_path = "";
size_t pos = reDir.find_last_of('/');
if (pos != std::string::npos)
{
file_path = reDir.substr(0, pos+1);
}
rapidjson::Document doc;
if(!readJson(strFilePath.c_str(), doc))
{
CCLog("read json file[%s] error!\n", strFilePath.c_str());
continue;
}
const rapidjson::Value &subData = DICTOOL->getDictionaryFromArray_json(doc, "armature_data", 0);
const char *name = DICTOOL->getStringValue_json(subData, "name");
CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo(strFilePath.c_str());
CCArmature *pAr = CCArmature::create(name);
m_pRender = pAr;
const char *actionName = DICTOOL->getStringValue_json(*v, "selectedactionname");
if (actionName != NULL && pAr->getAnimation() != NULL)
{
pAr->getAnimation()->play(actionName);
}
}
else if(strcmp(pClassName, "GUIComponent") == 0)
{
cocos2d::gui::TouchGroup* tg = cocos2d::gui::TouchGroup::create();
cocos2d::gui::Widget* widget = cocos2d::extension::GUIReader::shareReader()->widgetFromJsonFile(strFilePath.c_str());
tg->addWidget(widget);
m_pRender = tg;
}
else
{
CC_BREAK_IF(true);
}
}
else if (nResType == 1)
{
if (strcmp(pClassName, "CCSprite") == 0)
{
std::string strPngFile = strPlistPath;
std::string::size_type pos = strPngFile.find(".plist");
if (pos == strPngFile.npos)
{
continue;
}
strPngFile.replace(pos, strPngFile.length(), ".png");
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(strPlistPath.c_str(), strPngFile.c_str());
m_pRender = CCSprite::createWithSpriteFrameName(strFilePath.c_str());
}
else
{
CC_BREAK_IF(true);
}
}
else
{
CC_BREAK_IF(true);
}
bRet = true;
} while (0);
return bRet;
}