Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

issue #3480 

1.  add SceneReader Tests.
                  2.  Modify class member name.
This commit is contained in:
chengstory 2014-01-03 01:14:12 +08:00
parent 0fe73f3a5d
commit 6892d8cf6a
10 changed files with 1159 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cocos/editor-support/cocostudio/CCComAttribute.cpp
View File

@ -29,7 +29,7 @@ namespace cocostudio {
ComAttribute::ComAttribute(void) ComAttribute::ComAttribute(void)
{ {
_name = "ComAttribute"; _name = "CCComAttribute";
} }
ComAttribute::~ComAttribute(void) ComAttribute::~ComAttribute(void)

83
cocos/editor-support/cocostudio/CCSSceneReader.cpp
View File

@ -24,6 +24,7 @@
#include "cocostudio/CocoStudio.h" #include "cocostudio/CocoStudio.h"
#include "gui/CocosGUI.h" #include "gui/CocosGUI.h"
#include "SimpleAudioEngine.h"
using namespace cocos2d; using namespace cocos2d;
using namespace gui; using namespace gui;
@ -33,9 +34,9 @@ namespace cocostudio {
SceneReader* SceneReader::s_sharedReader = nullptr; SceneReader* SceneReader::s_sharedReader = nullptr;
SceneReader::SceneReader() SceneReader::SceneReader()
: _pListener(NULL) : _listener(NULL)
, _pfnSelector(NULL) , _fnSelector(NULL)
, _pNode(NULL) , _node(NULL)
{ {
} }
@ -48,24 +49,23 @@ namespace cocostudio {
return "1.0.0.0"; return "1.0.0.0";
} }
cocos2d::Node* SceneReader::createNodeWithSceneFile(const char* pszFileName) cocos2d::Node* SceneReader::createNodeWithSceneFile(const std::string &fileName)
{ {
rapidjson::Document jsonDict; rapidjson::Document jsonDict;
do { do {
CC_BREAK_IF(!readJson(pszFileName, jsonDict)); CC_BREAK_IF(!readJson(fileName, jsonDict));
_pNode = createObject(jsonDict, NULL); _node = createObject(jsonDict, NULL);
TriggerMng::getInstance()->parse(jsonDict); TriggerMng::getInstance()->parse(jsonDict);
} while (0); } while (0);
return _pNode; return _node;
} }
bool SceneReader::readJson(const char *pszFileName, rapidjson::Document &doc) bool SceneReader::readJson(const std::string &fileName, rapidjson::Document &doc)
{ {
bool bRet = false; bool bRet = false;
do { do {
CC_BREAK_IF(pszFileName == NULL); std::string jsonpath = FileUtils::getInstance()->fullPathForFilename(fileName);
std::string jsonpath = CCFileUtils::getInstance()->fullPathForFilename(pszFileName);
std::string contentStr = FileUtils::getInstance()->getStringFromFile(jsonpath); std::string contentStr = FileUtils::getInstance()->getStringFromFile(jsonpath);
doc.Parse<0>(contentStr.c_str()); doc.Parse<0>(contentStr.c_str());
CC_BREAK_IF(doc.HasParseError()); CC_BREAK_IF(doc.HasParseError());
@ -74,26 +74,26 @@ namespace cocostudio {
return bRet; return bRet;
} }
Node* SceneReader::nodeByTag(Node *pParent, int nTag) Node* SceneReader::nodeByTag(Node *parent, int tag)
{ {
if (pParent == NULL) if (parent == NULL)
{ {
return NULL; return NULL;
} }
Node *_retNode = NULL; Node *_retNode = NULL;
Vector<Node*>& Children = pParent->getChildren(); Vector<Node*>& Children = parent->getChildren();
Vector<Node*>::iterator iter = Children.begin(); Vector<Node*>::iterator iter = Children.begin();
while (iter != Children.end()) while (iter != Children.end())
{ {
Node* pNode = *iter; Node* pNode = *iter;
if(pNode != NULL && pNode->getTag() == nTag) if(pNode != NULL && pNode->getTag() == tag)
{ {
_retNode = pNode; _retNode = pNode;
break; break;
} }
else else
{ {
_retNode = nodeByTag(pNode, nTag); _retNode = nodeByTag(pNode, tag);
if (_retNode != NULL) if (_retNode != NULL)
{ {
break; break;
@ -200,9 +200,9 @@ namespace cocostudio {
} }
gb->addComponent(pRender); gb->addComponent(pRender);
if (_pListener && _pfnSelector) if (_listener && _fnSelector)
{ {
(_pListener->*_pfnSelector)(pSprite, (void*)(&subDict)); (_listener->*_fnSelector)(pSprite, (void*)(&subDict));
} }
} }
else if(comName != nullptr && strcmp(comName, "CCTMXTiledMap") == 0) else if(comName != nullptr && strcmp(comName, "CCTMXTiledMap") == 0)
@ -227,9 +227,9 @@ namespace cocostudio {
pRender->setName(pComName); pRender->setName(pComName);
} }
gb->addComponent(pRender); gb->addComponent(pRender);
if (_pListener && _pfnSelector) if (_listener && _fnSelector)
{ {
(_pListener->*_pfnSelector)(pTmx, (void*)(&subDict)); (_listener->*_fnSelector)(pTmx, (void*)(&subDict));
} }
} }
else if(comName != nullptr && strcmp(comName, "CCParticleSystemQuad") == 0) else if(comName != nullptr && strcmp(comName, "CCParticleSystemQuad") == 0)
@ -257,9 +257,9 @@ namespace cocostudio {
pRender->setName(pComName); pRender->setName(pComName);
} }
gb->addComponent(pRender); gb->addComponent(pRender);
if (_pListener && _pfnSelector) if (_listener && _fnSelector)
{ {
(_pListener->*_pfnSelector)(pParticle, (void*)(&subDict)); (_listener->*_fnSelector)(pParticle, (void*)(&subDict));
} }
} }
else if(comName != nullptr && strcmp(comName, "CCArmature") == 0) else if(comName != nullptr && strcmp(comName, "CCArmature") == 0)
@ -301,9 +301,9 @@ namespace cocostudio {
{ {
pAr->getAnimation()->play(actionName); pAr->getAnimation()->play(actionName);
} }
if (_pListener && _pfnSelector) if (_listener && _fnSelector)
{ {
(_pListener->*_pfnSelector)(pAr, (void*)(&subDict)); (_listener->*_fnSelector)(pAr, (void*)(&subDict));
} }
} }
else if(comName != nullptr && strcmp(comName, "CCComAudio") == 0) else if(comName != nullptr && strcmp(comName, "CCComAudio") == 0)
@ -318,10 +318,14 @@ namespace cocostudio {
continue; continue;
} }
pAudio->preloadEffect(pPath.c_str()); pAudio->preloadEffect(pPath.c_str());
gb->addComponent(pAudio); if (pComName != NULL)
if (_pListener && _pfnSelector)
{ {
(_pListener->*_pfnSelector)(pAudio, (void*)(&subDict)); pAudio->setName(pComName);
}
gb->addComponent(pAudio);
if (_listener && _fnSelector)
{
(_listener->*_fnSelector)(pAudio, (void*)(&subDict));
} }
} }
else if(comName != nullptr && strcmp(comName, "CCComAttribute") == 0) else if(comName != nullptr && strcmp(comName, "CCComAttribute") == 0)
@ -337,9 +341,9 @@ namespace cocostudio {
continue; continue;
} }
gb->addComponent(pAttribute); gb->addComponent(pAttribute);
if (_pListener && _pfnSelector) if (_listener && _fnSelector)
{ {
(_pListener->*_pfnSelector)(pAttribute, (void*)(&subDict)); (_listener->*_fnSelector)(pAttribute, (void*)(&subDict));
} }
} }
else if (comName != nullptr && strcmp(comName, "CCBackgroundAudio") == 0) else if (comName != nullptr && strcmp(comName, "CCBackgroundAudio") == 0)
@ -358,6 +362,10 @@ namespace cocostudio {
const bool bLoop = (DICTOOL->getIntValue_json(subDict, "loop") != 0); const bool bLoop = (DICTOOL->getIntValue_json(subDict, "loop") != 0);
pAudio->setLoop(bLoop); pAudio->setLoop(bLoop);
gb->addComponent(pAudio); gb->addComponent(pAudio);
if (pComName != NULL)
{
pAudio->setName(pComName);
}
pAudio->playBackgroundMusic(pPath.c_str(), bLoop); pAudio->playBackgroundMusic(pPath.c_str(), bLoop);
} }
else if(comName != nullptr && strcmp(comName, "GUIComponent") == 0) else if(comName != nullptr && strcmp(comName, "GUIComponent") == 0)
@ -369,9 +377,9 @@ namespace cocostudio {
pRender->setName(pComName); pRender->setName(pComName);
} }
gb->addComponent(pRender); gb->addComponent(pRender);
if (_pListener && _pfnSelector) if (_listener && _fnSelector)
{ {
(_pListener->*_pfnSelector)(widget, (void*)(&subDict)); (_listener->*_fnSelector)(widget, (void*)(&subDict));
} }
} }
} }
@ -395,21 +403,21 @@ namespace cocostudio {
void SceneReader::setTarget(Object *rec, SEL_CallFuncOD selector) void SceneReader::setTarget(Object *rec, SEL_CallFuncOD selector)
{ {
_pListener = rec; _listener = rec;
_pfnSelector = selector; _fnSelector = selector;
} }
Node* SceneReader::getNodeByTag(int nTag) Node* SceneReader::getNodeByTag(int nTag)
{ {
if (_pNode == NULL) if (_node == NULL)
{ {
return NULL; return NULL;
} }
if (_pNode->getTag() == nTag) if (_node->getTag() == nTag)
{ {
return _pNode; return _node;
} }
return nodeByTag(_pNode, nTag); return nodeByTag(_node, nTag);
} }
void SceneReader::setPropertyFromJsonDict(const rapidjson::Value &root, cocos2d::Node *node) void SceneReader::setPropertyFromJsonDict(const rapidjson::Value &root, cocos2d::Node *node)
@ -449,6 +457,9 @@ namespace cocostudio {
{ {
DictionaryHelper::destroyInstance(); DictionaryHelper::destroyInstance();
TriggerMng::destroyInstance(); TriggerMng::destroyInstance();
_fnSelector = nullptr;
_listener = nullptr;
CocosDenshion::SimpleAudioEngine::end();
CC_SAFE_DELETE(s_sharedReader); CC_SAFE_DELETE(s_sharedReader);
} }

14
cocos/editor-support/cocostudio/CCSSceneReader.h
View File

@ -53,21 +53,21 @@ public:
* @js purge * @js purge
* @lua destroySceneReader * @lua destroySceneReader
*/ */
static void destroyInstance(); void destroyInstance();
static const char* sceneReaderVersion(); static const char* sceneReaderVersion();
cocos2d::Node* createNodeWithSceneFile(const char *pszFileName); cocos2d::Node* createNodeWithSceneFile(const std::string &fileName);
void setTarget(cocos2d::Object *rec, SEL_CallFuncOD selector); void setTarget(cocos2d::Object *rec, SEL_CallFuncOD selector);
cocos2d::Node* getNodeByTag(int nTag); cocos2d::Node* getNodeByTag(int nTag);
private: private:
cocos2d::Node* createObject(const rapidjson::Value& dict, cocos2d::Node* parent); cocos2d::Node* createObject(const rapidjson::Value& dict, cocos2d::Node* parent);
void setPropertyFromJsonDict(const rapidjson::Value& dict, cocos2d::Node *node); void setPropertyFromJsonDict(const rapidjson::Value& dict, cocos2d::Node *node);
bool readJson(const char *pszFileName, rapidjson::Document &doc); bool readJson(const std::string &fileName, rapidjson::Document& doc);
cocos2d::Node* nodeByTag(cocos2d::Node *pParent, int nTag); cocos2d::Node* nodeByTag(cocos2d::Node *parent, int tag);
private: private:
static SceneReader* s_sharedReader; static SceneReader* s_sharedReader;
cocos2d::Object* _pListener; cocos2d::Object* _listener;
SEL_CallFuncOD _pfnSelector; SEL_CallFuncOD _fnSelector;
cocos2d::Node* _pNode; cocos2d::Node* _node;
}; };

4
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioComponentsTest/SceneController.cpp
View File

@ -91,9 +91,9 @@ void SceneController::spriteMoveFinished(Node* sender)
void SceneController::increaseKillCount() void SceneController::increaseKillCount()
{ {
int nProjectilesDestroyed = ((ComAttribute*)(_owner->getComponent("ComAttribute")))->getInt("KillCount"); int nProjectilesDestroyed = ((ComAttribute*)(_owner->getComponent("CCComAttribute")))->getInt("KillCount");
ComAttribute *p = (ComAttribute*)(_owner->getComponent("ComAttribute")); ComAttribute *p = (ComAttribute*)(_owner->getComponent("CCComAttribute"));
p->setInt("KillCount", ++nProjectilesDestroyed); p->setInt("KillCount", ++nProjectilesDestroyed);
if (nProjectilesDestroyed >= 5) if (nProjectilesDestroyed >= 5)

826
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/SceneEditorTest.cpp
View File

@ -5,57 +5,770 @@
#include "cocostudio/CocoStudio.h" #include "cocostudio/CocoStudio.h"
#include "gui/CocosGUI.h" #include "gui/CocosGUI.h"
#include "TriggerCode/EventDef.h" #include "TriggerCode/EventDef.h"
#include "../../testResource.h"
using namespace cocos2d; using namespace cocos2d;
using namespace cocostudio; using namespace cocostudio;
using namespace gui; using namespace gui;
SceneEditorTestLayer::~SceneEditorTestLayer() Layer *Next();
Layer *Back();
Layer *Restart();
static int s_nIdx = -1;
Layer *createTests(int index)
{ {
ArmatureDataManager::destroyInstance(); Layer *layer = nullptr;
SceneReader::destroyInstance(); switch(index)
ActionManagerEx::destroyInstance(); {
auto dispatcher = Director::getInstance()->getEventDispatcher(); case TEST_LOADSCENEEDITORFILE:
dispatcher->removeEventListener(_touchListener); layer = new loadSceneEdtiorFileTest();
break;
case TEST_SPIRTECOMPONENT:
layer = new SpriteComponentTest();
break;
case TEST_ARMATURECOMPONENT:
layer = new ArmatureComponentTest();
break;
case TEST_UICOMPONENT:
layer = new UIComponentTest();
break;
case TEST_TMXMAPCOMPONENT:
layer = new TmxMapComponentTest();
break;
case TEST_PARTICLECOMPONENT:
layer = new ParticleComponentTest();
break;
case TEST_EFEECTCOMPONENT:
layer = new EffectComponentTest();
break;
case TEST_BACKGROUNDCOMPONENT:
layer = new BackgroundComponentTest();
break;
case TEST_ATTRIBUTECOMPONENT:
layer = new AttributeComponentTest();
break;
case TEST_TRIGGER:
layer = new TriggerTest();
layer->init();
break;
default:
break;
}
return layer;
} }
SceneEditorTestLayer::SceneEditorTestLayer() Layer *Next()
{ {
_curNode = nullptr; ++s_nIdx;
_touchListener = nullptr; s_nIdx = s_nIdx % TEST_SCENEEDITOR_COUNT;
Layer *layer = createTests(s_nIdx);
layer->autorelease();
return layer;
} }
Scene* SceneEditorTestLayer::scene() Layer *Back()
{ {
Scene * scene = nullptr; --s_nIdx;
do if( s_nIdx < 0 )
{ s_nIdx += TEST_SCENEEDITOR_COUNT;
// 'scene' is an autorelease object
scene = Scene::create();
CC_BREAK_IF(! scene);
// 'layer' is an autorelease object Layer *layer = createTests(s_nIdx);
SceneEditorTestLayer *layer = SceneEditorTestLayer::create(); layer->autorelease();
CC_BREAK_IF(! layer);
// add layer as a child to scene return layer;
scene->addChild(layer);
} while (0);
// return the scene
return scene;
} }
// on "init" you need to initialize your instance Layer *Restart()
bool SceneEditorTestLayer::init()
{ {
Layer *layer = createTests(s_nIdx);
layer->autorelease();
return layer;
}
SceneEditorTestScene::SceneEditorTestScene(bool bPortrait)
{
TestScene::init();
}
void SceneEditorTestScene::runThisTest()
{
s_nIdx = -1;
addChild(Next());
CCDirector::getInstance()->replaceScene(this);
}
void SceneEditorTestScene::MainMenuCallback(Object *pSender)
{
removeAllChildren();
}
void SceneEditorTestLayer::onEnter()
{
CCLayer::onEnter();
// add title and subtitle
std::string str = title();
const char *pTitle = str.c_str();
LabelTTF *label = LabelTTF::create(pTitle, "Arial", 18);
label->setColor(Color3B(255, 255, 255));
addChild(label, 1, 10000);
label->setPosition( Point(VisibleRect::center().x, VisibleRect::top().y - 30) );
std::string strSubtitle = subtitle();
if( ! strSubtitle.empty() )
{
LabelTTF *l = LabelTTF::create(strSubtitle.c_str(), "Arial", 18);
l->setColor(Color3B(0, 0, 0));
addChild(l, 1, 10001);
l->setPosition(Point(VisibleRect::center().x, VisibleRect::top().y - 60) );
}
// add menu
backItem = MenuItemImage::create(s_pathB1, s_pathB2, CC_CALLBACK_1(SceneEditorTestLayer::backCallback, this) );
restartItem = MenuItemImage::create(s_pathR1, s_pathR2, CC_CALLBACK_1(SceneEditorTestLayer::restartCallback, this) );
nextItem = MenuItemImage::create(s_pathF1, s_pathF2, CC_CALLBACK_1(SceneEditorTestLayer::nextCallback, this) );
Menu *menu = Menu::create(backItem, restartItem, nextItem, nullptr);
float fScale = 0.5f;
menu->setPosition(Point(0, 0));
backItem->setPosition(Point(VisibleRect::center().x - restartItem->getContentSize().width * 2 * fScale, VisibleRect::bottom().y + restartItem->getContentSize().height / 2));
backItem->setScale(fScale);
restartItem->setPosition(Point(VisibleRect::center().x, VisibleRect::bottom().y + restartItem->getContentSize().height / 2));
restartItem->setScale(fScale);
nextItem->setPosition(Point(VisibleRect::center().x + restartItem->getContentSize().width * 2 * fScale, VisibleRect::bottom().y + restartItem->getContentSize().height / 2));
nextItem->setScale(fScale);
addChild(menu, 100);
setShaderProgram(ShaderCache::getInstance()->getProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR));
}
void SceneEditorTestLayer::onExit()
{
removeAllChildren();
backItem = restartItem = nextItem = nullptr;
Layer::onExit();
}
std::string SceneEditorTestLayer::title()
{
return "SceneReader Test LoadSceneEditorFile";
}
std::string SceneEditorTestLayer::subtitle()
{
return "";
}
void SceneEditorTestLayer::restartCallback(Object *pSender)
{
Scene *s = new SceneEditorTestScene();
s->addChild(Restart());
Director::getInstance()->replaceScene(s);
s->release();
}
void SceneEditorTestLayer::nextCallback(Object *pSender)
{
Scene *s = new SceneEditorTestScene();
s->addChild(Next());
Director::getInstance()->replaceScene(s);
s->release();
}
void SceneEditorTestLayer::backCallback(Object *pSender)
{
Scene *s = new SceneEditorTestScene();
s->addChild(Back());
Director::getInstance()->replaceScene(s);
s->release();
}
void SceneEditorTestLayer::draw()
{
Layer::draw();
}
loadSceneEdtiorFileTest::loadSceneEdtiorFileTest()
{
}
loadSceneEdtiorFileTest::~loadSceneEdtiorFileTest()
{
}
std::string loadSceneEdtiorFileTest::title()
{
return "loadSceneEdtiorFile Test";
}
void loadSceneEdtiorFileTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false; bool bRet = false;
do do
{ {
Node *root = createGameScene(); Node *root = createGameScene();
CC_BREAK_IF(!root); CC_BREAK_IF(!root);
this->addChild(root, 0, 1); this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void loadSceneEdtiorFileTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* loadSceneEdtiorFileTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/loadSceneEdtiorFileTest/FishJoy2.json");
if (node == nullptr)
{
return nullptr;
}
ActionManagerEx::getInstance()->playActionByName("startMenu_1.json","Animation1");
return node;
}
SpriteComponentTest::SpriteComponentTest()
{
}
SpriteComponentTest::~SpriteComponentTest()
{
}
std::string SpriteComponentTest::title()
{
return "Sprite Component Test";
}
void SpriteComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void SpriteComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* SpriteComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/SpriteComponentTest/SpriteComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
ActionInterval* action1 = CCBlink::create(2, 10);
ActionInterval* action2 = CCBlink::create(2, 5);
Sprite *pSister1 = static_cast<Sprite*>(node->getChildByTag(10003)->getComponent("CCSprite")->getNode());
pSister1->runAction(action1);
Sprite *pSister2 = static_cast<Sprite*>(node->getChildByTag(10004)->getComponent("CCSprite")->getNode());
pSister2->runAction(action2);
return node;
}
ArmatureComponentTest::ArmatureComponentTest()
{
}
ArmatureComponentTest::~ArmatureComponentTest()
{
}
std::string ArmatureComponentTest::title()
{
return "Armature Component Test";
}
void ArmatureComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void ArmatureComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* ArmatureComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/ArmatureComponentTest/ArmatureComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
Armature *pBlowFish = static_cast<Armature*>(node->getChildByTag(10007)->getComponent("Armature")->getNode());
pBlowFish->runAction(CCMoveBy::create(10.0f, Point(-1000.0f, 0)));
Armature *pButterflyfish = static_cast<Armature*>(node->getChildByTag(10008)->getComponent("Armature")->getNode());
pButterflyfish->runAction(CCMoveBy::create(10.0f, Point(-1000.0f, 0)));
return node;
}
UIComponentTest::UIComponentTest()
: _node(nullptr)
{
}
UIComponentTest::~UIComponentTest()
{
}
std::string UIComponentTest::title()
{
return "UI Component Test";
}
void UIComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void UIComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* UIComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/UIComponentTest/UIComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
_node = node;
cocos2d::gui::TouchGroup* touchGroup = static_cast<cocos2d::gui::TouchGroup*>(_node->getChildByTag(10025)->getComponent("GUIComponent")->getNode());
UIWidget* widget = static_cast<UIWidget*>(touchGroup->getWidgetByName("Panel_154"));
UIButton* button = static_cast<UIButton*>(widget->getChildByName("Button_156"));
button->addTouchEventListener(this, toucheventselector(UIComponentTest::touchEvent));
return node;
}
void UIComponentTest::touchEvent(CCObject *pSender, TouchEventType type)
{
switch (type)
{
case TOUCH_EVENT_BEGAN:
{
Armature *pBlowFish = static_cast<Armature*>(_node->getChildByTag(10010)->getComponent("Armature")->getNode());
pBlowFish->runAction(CCMoveBy::create(10.0f, ccp(-1000.0f, 0)));
Armature *pButterflyfish = static_cast<Armature*>(_node->getChildByTag(10011)->getComponent("Armature")->getNode());
pButterflyfish->runAction(CCMoveBy::create(10.0f, ccp(-1000.0f, 0)));
}
break;
default:
break;
}
}
TmxMapComponentTest::TmxMapComponentTest()
{
}
TmxMapComponentTest::~TmxMapComponentTest()
{
}
std::string TmxMapComponentTest::title()
{
return "TmxMap Component Test";
}
void TmxMapComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void TmxMapComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* TmxMapComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/TmxMapComponentTest/TmxMapComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
TMXTiledMap *tmxMap = static_cast<TMXTiledMap*>(node->getChildByTag(10015)->getComponent("TMXTiledMap")->getNode());
ActionInterval *actionTo = SkewTo::create(2, 0.f, 2.f);
ActionInterval *rotateTo = RotateTo::create(2, 61.0f);
ActionInterval *actionScaleTo = ScaleTo::create(2, -0.44f, 0.47f);
ActionInterval *actionScaleToBack = ScaleTo::create(2, 1.0f, 1.0f);
ActionInterval *rotateToBack = RotateTo::create(2, 0);
ActionInterval *actionToBack = SkewTo::create(2, 0, 0);
tmxMap->runAction(Sequence::create(actionTo, actionToBack, nullptr));
tmxMap->runAction(Sequence::create(rotateTo, rotateToBack, nullptr));
tmxMap->runAction(Sequence::create(actionScaleTo, actionScaleToBack, nullptr));
return node;
}
ParticleComponentTest::ParticleComponentTest()
{
}
ParticleComponentTest::~ParticleComponentTest()
{
}
std::string ParticleComponentTest::title()
{
return "Particle Component Test";
}
void ParticleComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void ParticleComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* ParticleComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/ParticleComponentTest/ParticleComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
ParticleSystemQuad* Particle = static_cast<ParticleSystemQuad*>(node->getChildByTag(10020)->getComponent("CCParticleSystemQuad")->getNode());
ActionInterval* jump = JumpBy::create(5, Point(-500,0), 50, 4);
FiniteTimeAction* action = Sequence::create( jump, jump->reverse(), nullptr);
Particle->runAction(action);
return node;
}
EffectComponentTest::EffectComponentTest()
: _node(nullptr)
{
}
EffectComponentTest::~EffectComponentTest()
{
}
std::string EffectComponentTest::title()
{
return "Effect Component Test";
}
void EffectComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void EffectComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* EffectComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/EffectComponentTest/EffectComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
_node = node;
Armature *pAr = static_cast<Armature*>(_node->getChildByTag(10015)->getComponent("Armature")->getNode());
pAr->getAnimation()->setMovementEventCallFunc(this, movementEvent_selector(EffectComponentTest::animationEvent));
return node;
}
void EffectComponentTest::animationEvent(Armature *armature, MovementEventType movementType, const std::string& movementID)
{
std::string id = movementID;
if (movementType == LOOP_COMPLETE)
{
if (id.compare("Fire") == 0)
{
ComAudio *pAudio = static_cast<ComAudio*>(_node->getChildByTag(10015)->getComponent("CCComAudio"));
pAudio->playEffect();
}
}
}
BackgroundComponentTest::BackgroundComponentTest()
{
}
BackgroundComponentTest::~BackgroundComponentTest()
{
}
std::string BackgroundComponentTest::title()
{
return "Background Component Test";
}
void BackgroundComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void BackgroundComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
cocos2d::Node* BackgroundComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/BackgroundComponentTest/BackgroundComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
ActionManagerEx::getInstance()->playActionByName("startMenu_1.json","Animation1");
ComAudio *Audio = static_cast<ComAudio*>(node->getComponent("CCBackgroundAudio"));
Audio->playBackgroundMusic();
return node;
}
AttributeComponentTest::AttributeComponentTest()
: _node(nullptr)
{
}
AttributeComponentTest::~AttributeComponentTest()
{
}
std::string AttributeComponentTest::title()
{
return "Attribute Component Test";
}
void AttributeComponentTest::onEnter()
{
SceneEditorTestLayer::onEnter();
bool bRet = false;
do
{
Node *root = createGameScene();
CC_BREAK_IF(!root);
initData();
this->addChild(root, 0, 1);
bRet = true;
} while (0);
}
void AttributeComponentTest::onExit()
{
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
}
bool AttributeComponentTest::initData()
{
bool bRet = false;
unsigned long size = 0;
unsigned char *pBytes = nullptr;
rapidjson::Document jsonDict;
do {
CC_BREAK_IF(_node == nullptr);
ComAttribute *pAttribute = static_cast<ComAttribute*>(_node->getChildByTag(10015)->getComponent("CCComAttribute"));
CC_BREAK_IF(pAttribute == nullptr);
std::string jsonpath = FileUtils::getInstance()->fullPathForFilename(pAttribute->getJsonName());
std::string contentStr = FileUtils::getInstance()->getStringFromFile(jsonpath);
doc.Parse<0>(contentStr.c_str());
CC_BREAK_IF(doc.HasParseError());
std::string playerName = DICTOOL->getStringValue_json(jsonDict, "name");
float maxHP = DICTOOL->getFloatValue_json(jsonDict, "maxHP");
float maxMP = DICTOOL->getFloatValue_json(jsonDict, "maxMP");
pAttribute->setCString("Name", playerName.c_str());
pAttribute->setFloat("MaxHP", maxHP);
pAttribute->setFloat("MaxMP", maxMP);
log("Name: %s, HP: %f, MP: %f", pAttribute->getCString("Name"), pAttribute->getFloat("MaxHP"), pAttribute->getFloat("MaxMP"));
bRet = true;
} while (0);
return bRet;
}
cocos2d::Node* AttributeComponentTest::createGameScene()
{
Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/AttributeComponentTest/AttributeComponentTest.json");
if (node == nullptr)
{
return nullptr;
}
_node = node;
return node;
}
TriggerTest::TriggerTest()
: _node(nullptr)
, _touchListener(nullptr)
{
}
TriggerTest::~TriggerTest()
{
}
std::string TriggerTest::title()
{
return "Trigger Test";
}
bool TriggerTest::init()
{
sendEvent(TRIGGEREVENT_INITSCENE); sendEvent(TRIGGEREVENT_INITSCENE);
return true;
}
// on "init" you need to initialize your instance
bool SceneEditorTestLayer::onEnter()
{
SceneEditorTestLayer::onEnter();
Node *root = createGameScene();
this->addChild(root, 0, 1);
this->schedule(schedule_selector(SceneEditorTestLayer::gameLogic)); this->schedule(schedule_selector(SceneEditorTestLayer::gameLogic));
auto dispatcher = Director::getInstance()->getEventDispatcher(); auto dispatcher = Director::getInstance()->getEventDispatcher();
auto listener = EventListenerTouchOneByOne::create(); auto listener = EventListenerTouchOneByOne::create();
@ -66,23 +779,22 @@ bool SceneEditorTestLayer::init()
listener->onTouchCancelled = CC_CALLBACK_2(SceneEditorTestLayer::onTouchCancelled, this); listener->onTouchCancelled = CC_CALLBACK_2(SceneEditorTestLayer::onTouchCancelled, this);
dispatcher->addEventListenerWithFixedPriority(listener, 1); dispatcher->addEventListenerWithFixedPriority(listener, 1);
_touchListener = listener; _touchListener = listener;
bRet = true;
} while (0);
return bRet;
}
void SceneEditorTestLayer::onEnter()
{
Layer::onEnter();
sendEvent(TRIGGEREVENT_ENTERSCENE); sendEvent(TRIGGEREVENT_ENTERSCENE);
} }
void SceneEditorTestLayer::onExit() void SceneEditorTestLayer::onExit()
{ {
Layer::onExit();
sendEvent(TRIGGEREVENT_LEAVESCENE); sendEvent(TRIGGEREVENT_LEAVESCENE);
this->unschedule(schedule_selector(TriggerTest::gameLogic));
auto dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->removeEventListener(_touchListener);
Device::setAccelerometerEnabled(false);
ArmatureDataManager::getInstance()->destroyInstance();
SceneReader::getInstance()->destroyInstance();
ActionManagerEx::getInstance()->destroyInstance();
GUIReader::shareReader()->purgeGUIReader();
SceneEditorTestLayer::onExit();
} }
bool SceneEditorTestLayer::onTouchBegan(Touch *touch, Event *unused_event) bool SceneEditorTestLayer::onTouchBegan(Touch *touch, Event *unused_event)
@ -111,45 +823,15 @@ void SceneEditorTestLayer::gameLogic(float dt)
sendEvent(TRIGGEREVENT_UPDATESCENE); sendEvent(TRIGGEREVENT_UPDATESCENE);
} }
static ActionObject* actionObject = nullptr;
cocos2d::Node* SceneEditorTestLayer::createGameScene() cocos2d::Node* SceneEditorTestLayer::createGameScene()
{ {
Node *pNode = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/FishJoy2.json"); Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/TriggerTest/TriggerTest.json");
if (pNode == nullptr) if (node == nullptr)
{ {
return nullptr; return nullptr;
} }
_curNode = pNode; _node = node;
MenuItemFont *itemBack = MenuItemFont::create("Back", CC_CALLBACK_1(SceneEditorTestLayer::toExtensionsMainLayer, this)); return node;
itemBack->setColor(Color3B(255, 255, 255));
itemBack->setPosition(Point(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
Menu *menuBack = Menu::create(itemBack, nullptr);
menuBack->setPosition(Point(0.0f, 0.0f));
menuBack->setZOrder(4);
pNode->addChild(menuBack);
return pNode;
}
void SceneEditorTestLayer::toExtensionsMainLayer(cocos2d::Object *sender)
{
if (actionObject)
{
actionObject->stop();
}
ComAudio *pBackMusic = (ComAudio*)(_curNode->getComponent("CCBackgroundAudio"));
pBackMusic->stopBackgroundMusic();
ExtensionsTestScene *pScene = new ExtensionsTestScene();
pScene->runThisTest();
pScene->release();
}
void runSceneEditorTestLayer()
{
Scene *pScene = SceneEditorTestLayer::scene();
Director::getInstance()->replaceScene(pScene);
} }

193
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/SceneEditorTest.h
View File

@ -4,22 +4,182 @@
#include "cocos2d.h" #include "cocos2d.h"
#include "extensions/cocos-ext.h" #include "extensions/cocos-ext.h"
void runSceneEditorTestLayer(); class SceneEditorTestScene : public TestScene
{
public:
SceneEditorTestScene(bool bPortrait = false);
virtual void runThisTest();
// The CallBack for back to the main menu scene
virtual void MainMenuCallback(cocos2d::Object* pSender);
};
enum {
TEST_LOADSCENEEDITORFILE = 0,
TEST_SPIRTECOMPONENT,
TEST_ARMATURECOMPONENT,
TEST_UICOMPONENT,
TEST_TMXMAPCOMPONENT,
TEST_PARTICLECOMPONENT,
TEST_EFEECTCOMPONENT,
TEST_BACKGROUNDCOMPONENT,
TEST_ATTRIBUTECOMPONENT,
TEST_TRIGGER,
TEST_SCENEEDITOR_COUNT
};
class SceneEditorTestLayer : public cocos2d::Layer class SceneEditorTestLayer : public cocos2d::Layer
{ {
public: public:
SceneEditorTestLayer();
~SceneEditorTestLayer();
// Here's a difference. Method 'init' in cocos2d-x returns bool,
// instead of returning 'id' in cocos2d-iphone
virtual bool init();
// callback of Scene Enter
virtual void onEnter(); virtual void onEnter();
virtual void onExit();
// callback of Scene Exit virtual std::string title();
virtual std::string subtitle();
virtual void restartCallback(cocos2d::Object* pSender);
virtual void nextCallback(cocos2d::Object* pSender);
virtual void backCallback(cocos2d::Object* pSender);
virtual void draw();
protected:
MenuItemImage *restartItem;
MenuItemImage *nextItem;
MenuItemImage *backItem;
};
class loadSceneEdtiorFileTest : public SceneEditorTestLayer
{
public:
loadSceneEdtiorFileTest();
~loadSceneEdtiorFileTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
};
class SpriteComponentTest : public SceneEditorTestLayer
{
public:
SpriteComponentTest();
~SpriteComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
};
class ArmatureComponentTest : public SceneEditorTestLayer
{
public:
ArmatureComponentTest();
~ArmatureComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
};
class UIComponentTest : public SceneEditorTestLayer
{
public:
UIComponentTest();
~UIComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
void touchEvent(cocos2d::Object *pSender, cocos2d::gui::TouchEventType type);
private:
cocos2d::Node* _node;
};
class TmxMapComponentTest : public SceneEditorTestLayer
{
public:
TmxMapComponentTest();
~TmxMapComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
};
class ParticleComponentTest : public SceneEditorTestLayer
{
public:
ParticleComponentTest();
~ParticleComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
};
class EffectComponentTest : public SceneEditorTestLayer
{
public:
EffectComponentTest();
~EffectComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
void animationEvent(cocostudio::Armature *armature, cocostudio::MovementEventType movementType, const std::string& movementID);
private:
cocos2d::Node* _node;
};
class BackgroundComponentTest : public SceneEditorTestLayer
{
public:
BackgroundComponentTest();
~BackgroundComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
cocos2d::Node* createGameScene();
};
class AttributeComponentTest : public SceneEditorTestLayer
{
public:
AttributeComponentTest();
~AttributeComponentTest();
virtual std::string title();
virtual void onEnter();
virtual void onExit();
bool initData();
cocos2d::Node* createGameScene();
private:
cocos2d::Node* _node;
};
class TriggerTest : public SceneEditorTestLayer
{
public:
TriggerTest();
~TriggerTest();
virtual std::string title();
virtual bool init();
virtual void onEnter();
virtual void onExit(); virtual void onExit();
// default implements are used to call script callback if exist // default implements are used to call script callback if exist
@ -31,20 +191,11 @@ public:
// update of game // update of game
void gameLogic(float dt); void gameLogic(float dt);
// there's no 'id' in cpp, so we recommand to return the exactly class pointer // create scene
static cocos2d::Scene* scene();
// implement the "static node()" method manually
CREATE_FUNC(SceneEditorTestLayer);
// init scene
cocos2d::Node* createGameScene(); cocos2d::Node* createGameScene();
//back to Extensions Main Layer
void toExtensionsMainLayer(cocos2d::Object *sender);
private: private:
cocos2d::Node *_curNode; cocos2d::Node *_node;
cocos2d::EventListener* _touchListener; cocos2d::EventListener* _touchListener;
}; };

187
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/TriggerCode/acts.cpp
View File

@ -7,7 +7,7 @@ using namespace cocostudio;
IMPLEMENT_CLASS_INFO(PlayMusic) IMPLEMENT_CLASS_INFO(PlayMusic)
PlayMusic::PlayMusic(void) PlayMusic::PlayMusic(void)
:_nTag(-1) :_tag(-1)
{ {
} }
@ -24,15 +24,15 @@ void PlayMusic::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ComAudio *audio = (ComAudio*)(pNode->getComponent(_comName.c_str())); ComAudio *audio = (ComAudio*)(pNode->getComponent(_comName.c_str()));
CC_BREAK_IF(audio == nullptr); CC_BREAK_IF(audio == nullptr);
if (_nType == 0) if (_type == 0)
{ {
audio->playBackgroundMusic(); audio->playBackgroundMusic();
} }
else if (_nType == 1) else if (_type == 1)
{ {
audio->playEffect(); audio->playEffect();
} }
@ -49,7 +49,7 @@ void PlayMusic::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "componentName") else if (key == "componentName")
@ -59,7 +59,7 @@ void PlayMusic::serialize(const rapidjson::Value &val)
} }
else if (key == "type") else if (key == "type")
{ {
_nType = DICTOOL->getIntValue_json(subDict, "value"); _type = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
} }
@ -71,8 +71,8 @@ void PlayMusic::removeAll()
IMPLEMENT_CLASS_INFO(TMoveTo) IMPLEMENT_CLASS_INFO(TMoveTo)
TMoveTo::TMoveTo(void) TMoveTo::TMoveTo(void)
:_nTag(-1) :_tag(-1)
,_fDuration(0.0f) ,_duration(0.0f)
{ {
} }
@ -89,9 +89,9 @@ void TMoveTo::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionTo = MoveTo::create(_fDuration, _pos); ActionInterval* actionTo = MoveTo::create(_duration, _pos);
CC_BREAK_IF(actionTo == nullptr); CC_BREAK_IF(actionTo == nullptr);
pNode->runAction(actionTo); pNode->runAction(actionTo);
} while (0); } while (0);
@ -106,12 +106,12 @@ void TMoveTo::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "x") else if (key == "x")
@ -129,13 +129,15 @@ void TMoveTo::serialize(const rapidjson::Value &val)
void TMoveTo::removeAll() void TMoveTo::removeAll()
{ {
Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TMoveBy) IMPLEMENT_CLASS_INFO(TMoveBy)
TMoveBy::TMoveBy(void) TMoveBy::TMoveBy(void)
:_nTag(-1) :_tag(-1)
,_fDuration(0.0f) ,_duration(0.0f)
,_bReverse(false) ,_reverse(false)
{ {
} }
@ -152,11 +154,11 @@ void TMoveBy::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionBy = MoveBy::create(_fDuration, _pos); ActionInterval* actionBy = MoveBy::create(_duration, _pos);
CC_BREAK_IF(actionBy == nullptr); CC_BREAK_IF(actionBy == nullptr);
if (_bReverse == true) if (_reverse == true)
{ {
ActionInterval* actionByBack = actionBy->reverse(); ActionInterval* actionByBack = actionBy->reverse();
pNode->runAction( CCSequence::create(actionBy, actionByBack, nullptr)); pNode->runAction( CCSequence::create(actionBy, actionByBack, nullptr));
@ -177,12 +179,12 @@ void TMoveBy::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "x") else if (key == "x")
@ -197,7 +199,7 @@ void TMoveBy::serialize(const rapidjson::Value &val)
} }
else if (key == "IsReverse") else if (key == "IsReverse")
{ {
_bReverse = (bool)(DICTOOL->getIntValue_json(subDict, "value")); _reverse = (bool)(DICTOOL->getIntValue_json(subDict, "value"));
continue; continue;
} }
} }
@ -205,16 +207,17 @@ void TMoveBy::serialize(const rapidjson::Value &val)
void TMoveBy::removeAll() void TMoveBy::removeAll()
{ {
CCLOG("TMoveBy::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TRotateTo) IMPLEMENT_CLASS_INFO(TRotateTo)
TRotateTo::TRotateTo(void) TRotateTo::TRotateTo(void)
: _nTag(-1) : _tag(-1)
, _fDuration(0.0f) , _duration(0.0f)
, _fDeltaAngle(0.0f) , _deltaAngle(0.0f)
{ {
} }
@ -231,9 +234,9 @@ void TRotateTo::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionTo = RotateTo::create(_fDuration, _fDeltaAngle); ActionInterval* actionTo = RotateTo::create(_duration, _deltaAngle);
CC_BREAK_IF(actionTo == nullptr); CC_BREAK_IF(actionTo == nullptr);
pNode->runAction(actionTo); pNode->runAction(actionTo);
} while (0); } while (0);
@ -248,17 +251,17 @@ void TRotateTo::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "DeltaAngle") else if (key == "DeltaAngle")
{ {
_fDeltaAngle = DICTOOL->getFloatValue_json(subDict, "value"); _deltaAngle = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
} }
@ -266,17 +269,18 @@ void TRotateTo::serialize(const rapidjson::Value &val)
void TRotateTo::removeAll() void TRotateTo::removeAll()
{ {
CCLOG("TRotateTo::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TRotateBy) IMPLEMENT_CLASS_INFO(TRotateBy)
TRotateBy::TRotateBy(void) TRotateBy::TRotateBy(void)
: _nTag(-1) : _tag(-1)
, _fDuration(0.0f) , _duration(0.0f)
, _fDeltaAngle(0.0f) , _deltaAngle(0.0f)
, _bReverse(false) , _reverse(false)
{ {
} }
@ -293,11 +297,11 @@ void TRotateBy::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionBy = RotateBy::create(_fDuration, _fDeltaAngle); ActionInterval* actionBy = RotateBy::create(_duration, _deltaAngle);
CC_BREAK_IF(actionBy == nullptr); CC_BREAK_IF(actionBy == nullptr);
if (_bReverse == true) if (_reverse == true)
{ {
ActionInterval* actionByBack = actionBy->reverse(); ActionInterval* actionByBack = actionBy->reverse();
pNode->runAction( Sequence::create(actionBy, actionByBack, nullptr)); pNode->runAction( Sequence::create(actionBy, actionByBack, nullptr));
@ -318,22 +322,22 @@ void TRotateBy::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "DeltaAngle") else if (key == "DeltaAngle")
{ {
_fDeltaAngle = DICTOOL->getFloatValue_json(subDict, "value"); _deltaAngle = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "IsReverse") else if (key == "IsReverse")
{ {
_bReverse = (int)(DICTOOL->getIntValue_json(subDict, "value")); _reverse = (int)(DICTOOL->getIntValue_json(subDict, "value"));
continue; continue;
} }
} }
@ -341,15 +345,16 @@ void TRotateBy::serialize(const rapidjson::Value &val)
void TRotateBy::removeAll() void TRotateBy::removeAll()
{ {
CCLOG("TRotateBy::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TScaleTo) IMPLEMENT_CLASS_INFO(TScaleTo)
TScaleTo::TScaleTo(void) TScaleTo::TScaleTo(void)
: _nTag(-1) : _tag(-1)
, _fDuration(0.0f) , _duration(0.0f)
{ {
} }
@ -366,9 +371,9 @@ void TScaleTo::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionTo = ScaleTo::create(_fDuration, _scale.x, _scale.y); ActionInterval* actionTo = ScaleTo::create(_duration, _scale.x, _scale.y);
CC_BREAK_IF(actionTo == nullptr); CC_BREAK_IF(actionTo == nullptr);
pNode->runAction(actionTo); pNode->runAction(actionTo);
} while (0); } while (0);
@ -383,12 +388,12 @@ void TScaleTo::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "ScaleX") else if (key == "ScaleX")
@ -406,16 +411,17 @@ void TScaleTo::serialize(const rapidjson::Value &val)
void TScaleTo::removeAll() void TScaleTo::removeAll()
{ {
CCLOG("TScaleTo::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TScaleBy) IMPLEMENT_CLASS_INFO(TScaleBy)
TScaleBy::TScaleBy(void) TScaleBy::TScaleBy(void)
: _nTag(-1) : _tag(-1)
, _fDuration(0.0f) , _duration(0.0f)
, _bReverse(false) , _reverse(false)
{ {
} }
@ -432,11 +438,11 @@ void TScaleBy::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionBy = ScaleBy::create(_fDuration, _scale.x, _scale.y); ActionInterval* actionBy = ScaleBy::create(_duration, _scale.x, _scale.y);
CC_BREAK_IF(actionBy == nullptr); CC_BREAK_IF(actionBy == nullptr);
if (_bReverse == true) if (_reverse == true)
{ {
ActionInterval* actionByBack = actionBy->reverse(); ActionInterval* actionByBack = actionBy->reverse();
pNode->runAction(Sequence::create(actionBy, actionByBack, nullptr)); pNode->runAction(Sequence::create(actionBy, actionByBack, nullptr));
@ -457,12 +463,12 @@ void TScaleBy::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "ScaleX") else if (key == "ScaleX")
@ -477,7 +483,7 @@ void TScaleBy::serialize(const rapidjson::Value &val)
} }
else if (key == "IsReverse") else if (key == "IsReverse")
{ {
_bReverse = (bool)(DICTOOL->getIntValue_json(subDict, "value")); _reverse = (bool)(DICTOOL->getIntValue_json(subDict, "value"));
continue; continue;
} }
} }
@ -485,15 +491,16 @@ void TScaleBy::serialize(const rapidjson::Value &val)
void TScaleBy::removeAll() void TScaleBy::removeAll()
{ {
CCLOG("TScaleBy::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TSkewTo) IMPLEMENT_CLASS_INFO(TSkewTo)
TSkewTo::TSkewTo(void) TSkewTo::TSkewTo(void)
: _nTag(-1) : _tag(-1)
, _fDuration(0.0f) , _duration(0.0f)
{ {
} }
@ -510,9 +517,9 @@ void TSkewTo::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionTo = SkewTo::create(_fDuration, _skew.x, _skew.y); ActionInterval* actionTo = SkewTo::create(_duration, _skew.x, _skew.y);
CC_BREAK_IF(actionTo == nullptr); CC_BREAK_IF(actionTo == nullptr);
pNode->runAction(actionTo); pNode->runAction(actionTo);
} while (0); } while (0);
@ -527,12 +534,12 @@ void TSkewTo::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "SkewX") else if (key == "SkewX")
@ -550,16 +557,17 @@ void TSkewTo::serialize(const rapidjson::Value &val)
void TSkewTo::removeAll() void TSkewTo::removeAll()
{ {
CCLOG("TSkewTo::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TSkewBy) IMPLEMENT_CLASS_INFO(TSkewBy)
TSkewBy::TSkewBy(void) TSkewBy::TSkewBy(void)
: _nTag(-1) : _tag(-1)
, _fDuration(0.0f) , _duration(0.0f)
, _bReverse(false) , _reverse(false)
{ {
} }
@ -576,11 +584,11 @@ void TSkewBy::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ActionInterval* actionBy = SkewBy::create(_fDuration, _skew.x, _skew.y); ActionInterval* actionBy = SkewBy::create(_duration, _skew.x, _skew.y);
CC_BREAK_IF(actionBy == nullptr); CC_BREAK_IF(actionBy == nullptr);
if (_bReverse == true) if (_reverse == true)
{ {
ActionInterval* actionByBack = actionBy->reverse(); ActionInterval* actionByBack = actionBy->reverse();
pNode->runAction(Sequence::create(actionBy, actionByBack, nullptr)); pNode->runAction(Sequence::create(actionBy, actionByBack, nullptr));
@ -601,12 +609,12 @@ void TSkewBy::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Duration") else if (key == "Duration")
{ {
_fDuration = DICTOOL->getFloatValue_json(subDict, "value"); _duration = DICTOOL->getFloatValue_json(subDict, "value");
continue; continue;
} }
else if (key == "SKewX") else if (key == "SKewX")
@ -621,22 +629,23 @@ void TSkewBy::serialize(const rapidjson::Value &val)
} }
else if (key == "IsReverse") else if (key == "IsReverse")
{ {
_bReverse = (bool)(DICTOOL->getIntValue_json(subDict, "value")); _reverse = (bool)(DICTOOL->getIntValue_json(subDict, "value"));
} }
} }
} }
void TSkewBy::removeAll() void TSkewBy::removeAll()
{ {
CCLOG("TSkewBy::removeAll"); Node *node = SceneReader::getInstance()->getNodeByTag(_tag);
node->getActionManager()->removeAllActions();
} }
IMPLEMENT_CLASS_INFO(TriggerState) IMPLEMENT_CLASS_INFO(TriggerState)
TriggerState::TriggerState(void) TriggerState::TriggerState(void)
:_nID(-1) :_id(-1)
,_nState(0) ,_state(0)
{ {
} }
@ -651,20 +660,20 @@ bool TriggerState::init()
void TriggerState::done() void TriggerState::done()
{ {
TriggerObj *obj = TriggerMng::getInstance()->getTriggerObj(_nID); TriggerObj *obj = TriggerMng::getInstance()->getTriggerObj(_id);
if (obj != nullptr) if (obj != nullptr)
{ {
if (_nState == 0) if (_state == 0)
{ {
obj->setEnabled(false); obj->setEnabled(false);
} }
else if (_nState == 1) else if (_state == 1)
{ {
obj->setEnabled(true); obj->setEnabled(true);
} }
else if (_nState == 2) else if (_state == 2)
{ {
TriggerMng::getInstance()->removeTriggerObj(_nID); TriggerMng::getInstance()->removeTriggerObj(_id);
} }
} }
@ -680,12 +689,12 @@ void TriggerState::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "ID") if (key == "ID")
{ {
_nID = DICTOOL->getIntValue_json(subDict, "value"); _id = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "State") else if (key == "State")
{ {
_nState = DICTOOL->getIntValue_json(subDict, "value"); _state = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
} }
@ -698,7 +707,7 @@ void TriggerState::removeAll()
IMPLEMENT_CLASS_INFO(ArmaturePlayAction) IMPLEMENT_CLASS_INFO(ArmaturePlayAction)
ArmaturePlayAction::ArmaturePlayAction(void) ArmaturePlayAction::ArmaturePlayAction(void)
: _nTag(-1) : _tag(-1)
{ {
} }
@ -715,7 +724,7 @@ void ArmaturePlayAction::done()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ComRender *pRender = (ComRender*)(pNode->getComponent(_ComName.c_str())); ComRender *pRender = (ComRender*)(pNode->getComponent(_ComName.c_str()));
CC_BREAK_IF(pRender == nullptr); CC_BREAK_IF(pRender == nullptr);
@ -734,7 +743,7 @@ void ArmaturePlayAction::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "componentName") else if (key == "componentName")

54
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/TriggerCode/acts.h
View File

@ -17,9 +17,9 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
std::string _comName; std::string _comName;
int _nType; int _type;
}; };
class TMoveTo: public cocostudio::BaseTriggerAction class TMoveTo: public cocostudio::BaseTriggerAction
@ -34,8 +34,8 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
cocos2d::Point _pos; cocos2d::Point _pos;
}; };
@ -52,10 +52,10 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
cocos2d::Point _pos; cocos2d::Point _pos;
bool _bReverse; bool _reverse;
}; };
@ -71,9 +71,9 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
float _fDeltaAngle; float _deltaAngle;
}; };
@ -89,10 +89,10 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
float _fDeltaAngle; float _deltaAngle;
bool _bReverse; bool _reverse;
}; };
@ -108,8 +108,8 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
cocos2d::Point _scale; cocos2d::Point _scale;
}; };
@ -126,10 +126,10 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
cocos2d::Point _scale; cocos2d::Point _scale;
bool _bReverse; bool _reverse;
}; };
@ -146,8 +146,8 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
cocos2d::Point _skew; cocos2d::Point _skew;
}; };
@ -164,10 +164,10 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
float _fDuration; float _duration;
cocos2d::Point _skew; cocos2d::Point _skew;
bool _bReverse; bool _reverse;
}; };
@ -183,8 +183,8 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nID; int _id;
int _nState; int _state;
}; };
class ArmaturePlayAction : public cocostudio::BaseTriggerAction class ArmaturePlayAction : public cocostudio::BaseTriggerAction
@ -199,7 +199,7 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
std::string _ComName; std::string _ComName;
std::string _aniname; std::string _aniname;
}; };

68
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/TriggerCode/cons.cpp
View File

@ -8,29 +8,29 @@ using namespace cocostudio;
IMPLEMENT_CLASS_INFO(TimeElapsed) IMPLEMENT_CLASS_INFO(TimeElapsed)
TimeElapsed::TimeElapsed(void) TimeElapsed::TimeElapsed(void)
:_fTotalTime(0.0f) :_totalTime(0.0f)
,_fTmpTime(0.0f) ,_tmpTime(0.0f)
,_pScheduler(nullptr) ,_scheduler(nullptr)
,_bSuc(false) ,_suc(false)
{ {
_pScheduler = Director::getInstance()->getScheduler(); _scheduler = Director::getInstance()->getScheduler();
_pScheduler->retain(); _scheduler->retain();
} }
TimeElapsed::~TimeElapsed(void) TimeElapsed::~TimeElapsed(void)
{ {
CC_SAFE_RELEASE(_pScheduler); CC_SAFE_RELEASE(_scheduler);
} }
bool TimeElapsed::init() bool TimeElapsed::init()
{ {
_pScheduler->scheduleSelector(schedule_selector(TimeElapsed::update), this, 0.0f , kRepeatForever, 0.0f, false); _scheduler->scheduleSelector(schedule_selector(TimeElapsed::update), this, 0.0f , kRepeatForever, 0.0f, false);
return true; return true;
} }
bool TimeElapsed::detect() bool TimeElapsed::detect()
{ {
return _bSuc; return _suc;
} }
void TimeElapsed::serialize(const rapidjson::Value &val) void TimeElapsed::serialize(const rapidjson::Value &val)
@ -42,31 +42,31 @@ void TimeElapsed::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "TotalTime") if (key == "TotalTime")
{ {
_fTotalTime = DICTOOL->getFloatValue_json(subDict, "value"); _totalTime = DICTOOL->getFloatValue_json(subDict, "value");
} }
} }
} }
void TimeElapsed::removeAll() void TimeElapsed::removeAll()
{ {
_pScheduler->unscheduleUpdateForTarget(this); _scheduler->unscheduleUpdateForTarget(this);
} }
void TimeElapsed::update(float dt) void TimeElapsed::update(float dt)
{ {
_fTmpTime += dt; _tmpTime += dt;
if (_fTmpTime > _fTotalTime) if (_tmpTime > _totalTime)
{ {
_fTmpTime = 0.0f; _tmpTime = 0.0f;
_bSuc = true; _suc = true;
} }
} }
IMPLEMENT_CLASS_INFO(ArmatureActionState) IMPLEMENT_CLASS_INFO(ArmatureActionState)
ArmatureActionState::ArmatureActionState(void) ArmatureActionState::ArmatureActionState(void)
: _nTag(-1) : _tag(-1)
, _nState(-1) , _state(-1)
, _bSuc(false) , _suc(false)
{ {
} }
@ -78,7 +78,7 @@ bool ArmatureActionState::init()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ComRender *pRender = (ComRender*)(pNode->getComponent(_comName.c_str())); ComRender *pRender = (ComRender*)(pNode->getComponent(_comName.c_str()));
CC_BREAK_IF(pRender == nullptr); CC_BREAK_IF(pRender == nullptr);
@ -92,7 +92,7 @@ bool ArmatureActionState::init()
bool ArmatureActionState::detect() bool ArmatureActionState::detect()
{ {
return _bSuc; return _suc;
} }
void ArmatureActionState::serialize(const rapidjson::Value &val) void ArmatureActionState::serialize(const rapidjson::Value &val)
@ -104,7 +104,7 @@ void ArmatureActionState::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "componentName") else if (key == "componentName")
@ -119,7 +119,7 @@ void ArmatureActionState::serialize(const rapidjson::Value &val)
} }
else if (key == "ActionType") else if (key == "ActionType")
{ {
_nState = DICTOOL->getIntValue_json(subDict, "value"); _state = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
} }
@ -129,7 +129,7 @@ void ArmatureActionState::removeAll()
{ {
do do
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
CC_BREAK_IF(pNode == nullptr); CC_BREAK_IF(pNode == nullptr);
ComRender *pRender = (ComRender*)(pNode->getComponent(_comName.c_str())); ComRender *pRender = (ComRender*)(pNode->getComponent(_comName.c_str()));
CC_BREAK_IF(pRender == nullptr); CC_BREAK_IF(pRender == nullptr);
@ -142,15 +142,15 @@ void ArmatureActionState::removeAll()
void ArmatureActionState::animationEvent(cocostudio::Armature *armature, cocostudio::MovementEventType movementType, const std::string& movementID) void ArmatureActionState::animationEvent(cocostudio::Armature *armature, cocostudio::MovementEventType movementType, const std::string& movementID)
{ {
std::string id = movementID; std::string id = movementID;
if (movementType == _nState && id.compare(_aniname) == 0) if (movementType == _state && id.compare(_aniname) == 0)
{ {
_bSuc = true; _suc = true;
} }
} }
IMPLEMENT_CLASS_INFO(NodeInRect) IMPLEMENT_CLASS_INFO(NodeInRect)
NodeInRect::NodeInRect(void) NodeInRect::NodeInRect(void)
:_nTag(-1) :_tag(-1)
{ {
} }
@ -166,7 +166,7 @@ bool NodeInRect::init()
bool NodeInRect::detect() bool NodeInRect::detect()
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
if (pNode != nullptr && abs(pNode->getPositionX() - _origin.x) <= _size.width && abs(pNode->getPositionY() - _origin.y) <= _size.height) if (pNode != nullptr && abs(pNode->getPositionX() - _origin.x) <= _size.width && abs(pNode->getPositionY() - _origin.y) <= _size.height)
{ {
return true; return true;
@ -183,7 +183,7 @@ void NodeInRect::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "originX") else if (key == "originX")
@ -217,8 +217,8 @@ void NodeInRect::removeAll()
IMPLEMENT_CLASS_INFO(NodeVisible) IMPLEMENT_CLASS_INFO(NodeVisible)
NodeVisible::NodeVisible(void) NodeVisible::NodeVisible(void)
: _nTag(-1) : _tag(-1)
, _bVisible(false) , _visible(false)
{ {
} }
@ -233,8 +233,8 @@ bool NodeVisible::init()
bool NodeVisible::detect() bool NodeVisible::detect()
{ {
Node *pNode = SceneReader::getInstance()->getNodeByTag(_nTag); Node *pNode = SceneReader::getInstance()->getNodeByTag(_tag);
if (pNode != nullptr && pNode->isVisible() == _bVisible) if (pNode != nullptr && pNode->isVisible() == _visible)
{ {
return true; return true;
} }
@ -250,12 +250,12 @@ void NodeVisible::serialize(const rapidjson::Value &val)
std::string key = DICTOOL->getStringValue_json(subDict, "key"); std::string key = DICTOOL->getStringValue_json(subDict, "key");
if (key == "Tag") if (key == "Tag")
{ {
_nTag = DICTOOL->getIntValue_json(subDict, "value"); _tag = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
else if (key == "Visible") else if (key == "Visible")
{ {
_bVisible = DICTOOL->getIntValue_json(subDict, "value"); _visible = DICTOOL->getIntValue_json(subDict, "value");
continue; continue;
} }
} }

20
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/TriggerCode/cons.h
View File

@ -18,10 +18,10 @@ public:
virtual void removeAll(); virtual void removeAll();
virtual void update(float dt); virtual void update(float dt);
private: private:
float _fTotalTime; float _totalTime;
float _fTmpTime; float _tmpTime;
cocos2d::Scheduler *_pScheduler; cocos2d::Scheduler *_scheduler;
bool _bSuc; bool _suc;
}; };
@ -38,11 +38,11 @@ public:
virtual void removeAll(); virtual void removeAll();
void animationEvent(cocostudio::Armature *armature, cocostudio::MovementEventType movementType, const std::string& movementID); void animationEvent(cocostudio::Armature *armature, cocostudio::MovementEventType movementType, const std::string& movementID);
private: private:
int _nTag; int _tag;
std::string _comName; std::string _comName;
std::string _aniname; std::string _aniname;
int _nState; int _state;
bool _bSuc; bool _suc;
}; };
@ -58,7 +58,7 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
cocos2d::Point _origin; cocos2d::Point _origin;
cocos2d::Size _size; cocos2d::Size _size;
}; };
@ -75,8 +75,8 @@ public:
virtual void serialize(const rapidjson::Value &val); virtual void serialize(const rapidjson::Value &val);
virtual void removeAll(); virtual void removeAll();
private: private:
int _nTag; int _tag;
bool _bVisible; bool _visible;
}; };