void BatchNode::addChild(Node *child, int zOrder, int tag)
{
Node::addChild(child, zOrder, tag);
Armature *armature = dynamic_cast<Armature *>(child);
if (armature != nullptr)
{
armature->setBatchNode(this);
const Dictionary *dict = armature->getBoneDic();
DictElement *element = nullptr;
CCDICT_FOREACH(dict, element)
{
Bone *bone = static_cast<Bone*>(element->getObject());
Array *displayList = bone->getDisplayManager()->getDecorativeDisplayList();
for(auto object : *displayList)
{
DecorativeDisplay *display = static_cast<DecorativeDisplay*>(object);
if (Skin *skin = dynamic_cast<Skin*>(display->getDisplay()))
{
skin->setTextureAtlas(getTexureAtlasWithTexture(skin->getTexture()));
}
}
}
void SIOClientImpl::handshakeResponse(HttpClient *sender, HttpResponse *response)
{
log("SIOClientImpl::handshakeResponse() called");
if (0 != strlen(response->getHttpRequest()->getTag()))
{
log("%s completed", response->getHttpRequest()->getTag());
}
int statusCode = response->getResponseCode();
char statusString[64] = {};
sprintf(statusString, "HTTP Status Code: %d, tag = %s", statusCode, response->getHttpRequest()->getTag());
log("response code: %d", statusCode);
if (!response->isSucceed())
{
log("SIOClientImpl::handshake() failed");
log("error buffer: %s", response->getErrorBuffer());
DictElement* el = NULL;
CCDICT_FOREACH(_clients, el) {
SIOClient* c = static_cast<SIOClient*>(el->getObject());
c->getDelegate()->onError(c, response->getErrorBuffer());
}
void PrettyPrinter::visit(const __Dictionary *p)
{
_result += "\n";
_result += _indentStr;
_result += "<dict>\n";
setIndentLevel(_indentLevel+1);
DictElement* element;
bool bFirstElement = true;
char buf[1000] = {0};
CCDICT_FOREACH(p, element)
{
if (!bFirstElement) {
_result += "\n";
}
sprintf(buf, "%s%s: ", _indentStr.c_str(),element->getStrKey());
_result += buf;
PrettyPrinter v(_indentLevel);
//FIXME:james element->getObject()->acceptVisitor(v);
_result += v.getResult();
bFirstElement = false;
}
setIndentLevel(_indentLevel-1);
_result += "\n";
_result += _indentStr;
_result += "</dict>";
}
Dictionary* TextureCache::snapshotTextures()
{
Dictionary* pRet = new Dictionary();
DictElement* pElement = NULL;
CCDICT_FOREACH(_textures, pElement)
{
pRet->setObject(pElement->getObject(), pElement->getStrKey());
}
void CCJSONConverter::convertDictionaryToJson(__Dictionary *Dictionary, cJSON *json)
{
#if COCOS2D_VERSION >= 0x00030000
DictElement * pElement = NULL;
#else
CCDictElement * pElement = NULL;
#endif
CCDICT_FOREACH(Dictionary, pElement){
Ref * obj = pElement->getObject();
cJSON * jsonItem = getObjJson(obj);
cJSON_AddItemToObject(json, pElement->getStrKey(), jsonItem);
}
void AnimationCache::parseVersion1(Dictionary* animations)
{
SpriteFrameCache *frameCache = SpriteFrameCache::sharedSpriteFrameCache();
DictElement* pElement = NULL;
CCDICT_FOREACH(animations, pElement)
{
Dictionary* animationDict = (Dictionary*)pElement->getObject();
Array* frameNames = (Array*)animationDict->objectForKey("frames");
float delay = animationDict->valueForKey("delay")->floatValue();
Animation* animation = NULL;
if ( frameNames == NULL )
{
CCLOG("cocos2d: AnimationCache: Animation '%s' found in dictionary without any frames - cannot add to animation cache.", pElement->getStrKey());
continue;
}
Array* frames = Array::createWithCapacity(frameNames->count());
frames->retain();
Object* pObj = NULL;
CCARRAY_FOREACH(frameNames, pObj)
{
const char* frameName = ((String*)pObj)->getCString();
SpriteFrame* spriteFrame = frameCache->spriteFrameByName(frameName);
if ( ! spriteFrame ) {
CCLOG("cocos2d: AnimationCache: Animation '%s' refers to frame '%s' which is not currently in the SpriteFrameCache. This frame will not be added to the animation.", pElement->getStrKey(), frameName);
continue;
}
AnimationFrame* animFrame = new AnimationFrame();
animFrame->initWithSpriteFrame(spriteFrame, 1, NULL);
frames->addObject(animFrame);
animFrame->release();
}
if ( frames->count() == 0 ) {
CCLOG("cocos2d: AnimationCache: None of the frames for animation '%s' were found in the SpriteFrameCache. Animation is not being added to the Animation Cache.", pElement->getStrKey());
continue;
} else if ( frames->count() != frameNames->count() ) {
CCLOG("cocos2d: AnimationCache: An animation in your dictionary refers to a frame which is not in the SpriteFrameCache. Some or all of the frames for the animation '%s' may be missing.", pElement->getStrKey());
}
animation = Animation::create(frames, delay, 1);
AnimationCache::sharedAnimationCache()->addAnimation(animation, pElement->getStrKey());
frames->release();
}
//
// load file
//
void Configuration::loadConfigFile(const char *filename)
{
Dictionary *dict = Dictionary::createWithContentsOfFile(filename);
CCASSERT(dict, "cannot create dictionary");
// search for metadata
bool validMetadata = false;
Object *metadata = dict->objectForKey("metadata");
if (metadata && dynamic_cast<Dictionary*>(metadata))
{
Object *format_o = static_cast<Dictionary*>(metadata)->objectForKey("format");
// XXX: cocos2d-x returns Strings when importing from .plist. This bug will be addressed in cocos2d-x v3.x
if (format_o && dynamic_cast<String*>(format_o))
{
int format = static_cast<String*>(format_o)->intValue();
// Support format: 1
if (format == 1)
{
validMetadata = true;
}
}
}
if (! validMetadata)
{
CCLOG("Invalid config format for file: %s", filename);
return;
}
Object *data = dict->objectForKey("data");
if (!data || !dynamic_cast<Dictionary*>(data))
{
CCLOG("Expected 'data' dict, but not found. Config file: %s", filename);
return;
}
// Add all keys in the existing dictionary
Dictionary *data_dict = static_cast<Dictionary*>(data);
DictElement* element;
CCDICT_FOREACH(data_dict, element)
{
if(! _valueDict->objectForKey( element->getStrKey() ))
_valueDict->setObject(element->getObject(), element->getStrKey());
else
CCLOG("Key already present. Ignoring '%s'", element->getStrKey());
}
}
void ControlButton::setPreferredSize(Size size)
{
if(size.width == 0 && size.height == 0)
{
_doesAdjustBackgroundImage = true;
}
else
{
_doesAdjustBackgroundImage = false;
DictElement * item = NULL;
CCDICT_FOREACH(_backgroundSpriteDispatchTable, item)
{
Scale9Sprite* sprite = static_cast<Scale9Sprite*>(item->getObject());
sprite->setPreferredSize(size);
}
}
void OneSidedPlatform::PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
{
Test::PreSolve(contact, oldManifold);
b2Fixture* fixtureA = contact->GetFixtureA();
b2Fixture* fixtureB = contact->GetFixtureB();
DictElement * ele;
__Dictionary * itemList = BattleController::shared()->getItemList();
CCDICT_FOREACH(itemList, ele){
Item * item = dynamic_cast<Item*>(ele->getObject());
b2Fixture * itemBox2d = item->getB2fixture();
if (fixtureA == itemBox2d || fixtureB == itemBox2d) {
contact->SetEnabled(false);
break;
}
}
//遍历
void CommonDictionary::foreach()
{
DictElement * pElement;
CCDICT_FOREACH(pDict, pElement)
{
const char * key = pElement->getStrKey();
const char* value = (const char*)pDict->objectForKey(key);
printf("CommonDictionary ---> key = %s, value = %s\n", key, value);
//CCLog(key);
//CCLog(value);
//myStrcat(Str, value);
//CCLog(Str);
}
}
Node* CCBReader::readNodeGraphFromData(Data *pData, Object *pOwner, const Size &parentSize)
{
mData = pData;
CC_SAFE_RETAIN(mData);
mBytes = mData->getBytes();
mCurrentByte = 0;
mCurrentBit = 0;
mOwner = pOwner;
CC_SAFE_RETAIN(mOwner);
mActionManager->setRootContainerSize(parentSize);
mActionManager->mOwner = mOwner;
mOwnerOutletNodes = new Array();
mOwnerCallbackNodes = new Array();
Dictionary* animationManagers = Dictionary::create();
Node *pNodeGraph = readFileWithCleanUp(true, animationManagers);
if (pNodeGraph && mActionManager->getAutoPlaySequenceId() != -1 && !jsControlled)
{
// Auto play animations
mActionManager->runAnimationsForSequenceIdTweenDuration(mActionManager->getAutoPlaySequenceId(), 0);
}
// Assign actionManagers to userObject
if(jsControlled) {
mNodesWithAnimationManagers = new Array();
mAnimationManagersForNodes = new Array();
}
DictElement* pElement = NULL;
CCDICT_FOREACH(animationManagers, pElement)
{
Node* pNode = (Node*)pElement->getIntKey();
CCBAnimationManager* manager = static_cast<CCBAnimationManager*>(animationManagers->objectForKey((intptr_t)pNode));
pNode->setUserObject(manager);
if (jsControlled)
{
mNodesWithAnimationManagers->addObject(pNode);
mAnimationManagersForNodes->addObject(manager);
}
}
void ArmatureAnimation::setAnimationScale(float animationScale )
{
if(animationScale == _animationScale)
{
return;
}
_animationScale = animationScale;
DictElement *element = NULL;
Dictionary *dict = _armature->getBoneDic();
CCDICT_FOREACH(dict, element)
{
Bone *bone = (Bone *)element->getObject();
bone->getTween()->setAnimationScale(_animationScale);
if (bone->getChildArmature())
{
bone->getChildArmature()->getAnimation()->setAnimationScale(_animationScale);
}
}
static void dictionaryToMap(__Dictionary* dict, map<string,string>& ret)
{
if (dict == nullptr)
return;
DictElement* el = nullptr;
CCDICT_FOREACH(dict, el)
{
auto str = dynamic_cast<__String*>(el->getObject());
auto boolean = dynamic_cast<__Bool*>(el->getObject());
auto number = dynamic_cast<__Double*>(el->getObject());
stringstream ss;
if (str)
ss << str->getCString();
else if (boolean)
ss << (int)boolean->getValue();
else if (number)
ss << number->getValue();
ret[el->getStrKey()] = ss.str();
}
void ArmatureAnimation::setSpeedScale(float speedScale)
{
if(speedScale == _speedScale)
{
return;
}
_speedScale = speedScale;
_processScale = !_movementData ? _speedScale : _speedScale * _movementData->scale;
DictElement *element = NULL;
Dictionary *dict = _armature->getBoneDic();
CCDICT_FOREACH(dict, element)
{
Bone *bone = static_cast<Bone*>(element->getObject());
bone->getTween()->setProcessScale(_processScale);
if (bone->getChildArmature())
{
bone->getChildArmature()->getAnimation()->setProcessScale(_processScale);
}
}
mrb_value dictionary_to_rubyval(mrb_state* mrb, __Dictionary* dict)
{
mrb_value rhash = mrb_hash_new(mrb);
DictElement* element = nullptr;
std::string className = "";
__String* strVal = nullptr;
__Dictionary* dictVal = nullptr;
__Array* arrVal = nullptr;
__Double* doubleVal = nullptr;
__Bool* boolVal = nullptr;
__Float* floatVal = nullptr;
__Integer* intVal = nullptr;
CCDICT_FOREACH(dict, element) {
if (nullptr == element)
continue;
mrb_value rkey = mrb_str_new_cstr(mrb, element->getStrKey());
mrb_value rval;
std::string typeName = typeid(element->getObject()).name();
auto iter = g_rubyType.find(typeName);
if (g_rubyType.end() != iter) {
className = iter->second;
if (nullptr != dynamic_cast<Ref*>(element->getObject())) {
rval = to_mrb_value(mrb, element->getObject());
}
} else if((strVal = dynamic_cast<__String *>(element->getObject()))) {
rval = mrb_str_new_cstr(mrb, strVal->getCString());
} else if ((dictVal = dynamic_cast<__Dictionary*>(element->getObject()))) {
rval = dictionary_to_rubyval(mrb, dictVal);
} else if ((arrVal = dynamic_cast<__Array*>(element->getObject()))) {
rval = array_to_rubyval(mrb, arrVal);
} else if ((doubleVal = dynamic_cast<__Double*>(element->getObject()))) {
rval = mrb_float_value(mrb, (mrb_float)doubleVal->getValue());
} else if ((floatVal = dynamic_cast<__Float*>(element->getObject()))) {
rval = mrb_float_value(mrb, (mrb_float)floatVal->getValue());
} else if ((intVal = dynamic_cast<__Integer*>(element->getObject()))) {
rval = mrb_fixnum_value((mrb_int)intVal->getValue());
} else if ((boolVal = dynamic_cast<__Bool*>(element->getObject()))) {
rval = mrb_bool_value((mrb_bool)boolVal->getValue());
} else {
CCASSERT(false, "the type isn't suppored.");
}
mrb_hash_set(mrb, rhash, rkey, rval);
}
return rhash;
}
// equip
void CocosGUIExamplesEquipScene::EquipInit()
{
m_eEquipType = EQUIP_TYPE_CLOTHES;
m_dicBeUsedSlot = __Dictionary::create();
CC_SAFE_RETAIN(m_dicBeUsedSlot);
m_dicClothesSlot = __Dictionary::create();
CC_SAFE_RETAIN(m_dicClothesSlot);
m_dicWeaponsSlot = __Dictionary::create();
CC_SAFE_RETAIN(m_dicWeaponsSlot);
m_dicPetsSlot = __Dictionary::create();
CC_SAFE_RETAIN(m_dicPetsSlot);
m_dicClothes = __Dictionary::create();
CC_SAFE_RETAIN(m_dicClothes);
m_dicWeapons = __Dictionary::create();
CC_SAFE_RETAIN(m_dicWeapons);
m_dicPets = __Dictionary::create();
CC_SAFE_RETAIN(m_dicPets);
container_1_Zorder = 0;
container_2_Zorder = 0;
container_3_Zorder = 0;
container_1_Position = Point::ZERO;
container_2_Position = Point::ZERO;
container_3_Position = Point::ZERO;
movePoint = Point::ZERO;
lastPoint = Point::ZERO;
widgetLastWorldSpace = Point::ZERO;
widgetLastNodeSpace = Point::ZERO;
lastWidgetParent = NULL;
//
// equip root from json
Layout* equipe_root = dynamic_cast<Layout*>(cocostudio::GUIReader::getInstance()->widgetFromJsonFile("cocosgui/gui_examples/equip_1/equip_1.json"));
equipe_root->setTag(EQUIP_LAYOUT_TAG_ROOT);
m_pUILayer->addChild(equipe_root);
// title layout
Layout* title_layout = dynamic_cast<Layout*>(equipe_root->getChildByName("title_panel"));
// close button
Button* close_btn = dynamic_cast<Button*>(title_layout->getChildByName("close_button"));
close_btn->setVisible(false);
// close_btn->addReleaseEvent(this, coco_releaseselector(CocosGUIExamplesEquipScene::close));
// up layout
Layout* up_layout = dynamic_cast<Layout*>(equipe_root->getChildByName("up_panel"));
up_layout->setTag(EQUIP_LAYOUT_TAG_UP);
// switch button
// close button
Button* clothes_btn = dynamic_cast<Button*>(up_layout->getChildByName("clothes_button"));
clothes_btn->addTouchEventListener(this, toucheventselector(CocosGUIExamplesEquipScene::switchBtnCallBack));
clothes_btn->setTag(EQUIP_SWITCH_LAYOUT_BUTTON_TAG_CLOTHES);
clothes_btn->setBright(false);
// weapons button
Button* weapons_btn = dynamic_cast<Button*>(up_layout->getChildByName("weapons_button"));
weapons_btn->addTouchEventListener(this, toucheventselector(CocosGUIExamplesEquipScene::switchBtnCallBack));
weapons_btn->setTag(EQUIP_SWITCH_LAYOUT_BUTTON_TAG_WEAPONS);
// pets button
Button* pets_btn = dynamic_cast<Button*>(up_layout->getChildByName("pets_button"));
pets_btn->addTouchEventListener(this, toucheventselector(CocosGUIExamplesEquipScene::switchBtnCallBack));
pets_btn->setTag(EQUIP_SWITCH_LAYOUT_BUTTON_TAG_PETS);
// repertories
// clothes layout
Layout* clothes_layout = dynamic_cast<Layout*>(equipe_root->getChildByName("clothes_panel"));
clothes_layout->setTag(EQUIP_LAYOUT_TAG_CLOTHES);
// weapons layout
Layout* weapons_layout = dynamic_cast<Layout*>(equipe_root->getChildByName("weapons_panel"));
weapons_layout->setTag(EQUIP_LAYOUT_TAG_WEAPONS);
// pets layout
Layout* pets_layout = dynamic_cast<Layout*>(equipe_root->getChildByName("pets_panel"));
pets_layout->setTag(EQUIP_LAYOUT_TAG_PETS);
container_1_Zorder = clothes_layout->getZOrder();
container_2_Zorder = weapons_layout->getZOrder();
container_3_Zorder = pets_layout->getZOrder();
container_1_Position = clothes_layout->getPosition();
container_2_Position = weapons_layout->getPosition();
container_3_Position = pets_layout->getPosition();
// clothes repertory slot
for (auto& obj : clothes_layout->getChildren())
{
Widget* child = dynamic_cast<Widget*>(obj);
m_dicClothesSlot->setObject(child, child->getName());
}
// weapons repertory slot
for (auto& obj : weapons_layout->getChildren())
{
Widget* child = dynamic_cast<Widget*>(obj);
m_dicWeaponsSlot->setObject(child, child->getName());
}
// pets repertory slot
for (auto& obj : pets_layout->getChildren())
{
Widget* child = dynamic_cast<Widget*>(obj);
m_dicPetsSlot->setObject(child, child->getName());
}
// actor
ImageView* wallBG_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("wall"));
ImageView* wal_iv = ImageView::create();
wal_iv->loadTexture("cocosgui/gui_examples/equip_1/equip/eg/1.png");
wal_iv->setAnchorPoint(Point(0.5, 0.5));
float wal_x = wallBG_iv->getSize().width / 2.04;
float wal_y = wallBG_iv->getSize().height / 2.4;
wal_iv->setPosition(Point((-wallBG_iv->getSize().width / 2) + wal_x,
(-wallBG_iv->getSize().height / 2) + wal_y));
wallBG_iv->addChild(wal_iv);
// original clothes be used slot
ImageView* originalClothesSlot_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("1"));
ImageView* originalClothes_iv = ImageView::create();
originalClothes_iv->loadTexture("cocosgui/gui_examples/equip_1/equip/eg/6.png");
originalClothesSlot_iv->addChild(originalClothes_iv);
m_dicBeUsedSlot->setObject(originalClothesSlot_iv, originalClothesSlot_iv->getName());
// other be used slot
ImageView* slot_2_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("2"));
m_dicBeUsedSlot->setObject(slot_2_iv, slot_2_iv->getName());
ImageView* slot_3_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("3"));
m_dicBeUsedSlot->setObject(slot_3_iv, slot_3_iv->getName());
ImageView* slot_4_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("4"));
m_dicBeUsedSlot->setObject(slot_4_iv, slot_4_iv->getName());
ImageView* slot_5_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("5"));
m_dicBeUsedSlot->setObject(slot_5_iv, slot_5_iv->getName());
ImageView* slot_6_iv = dynamic_cast<ImageView*>(up_layout->getChildByName("6"));
m_dicBeUsedSlot->setObject(slot_6_iv, slot_6_iv->getName());
// equip create
create();
// initialize touch able and influence children
DictElement* element = NULL;
clothes_layout->setTouchEnabled(true);
CCDICT_FOREACH(m_dicClothesSlot, element)
{
Widget* child = dynamic_cast<Widget*>(element->getObject());
child->setTouchEnabled(true);
}
void GB2ShapeCache::addShapesWithFile(const std::string &plist) {
std::string fullName = FileUtils::getInstance()->fullPathForFilename(plist);
__Dictionary* dict = __Dictionary::createWithContentsOfFile(fullName.c_str());
CCAssert(dict != NULL, "Shape-file not found"); // not triggered - cocos2dx delivers empty dict if non was found
CCAssert(dict->count() != 0, "plist file empty or not existing");
__Dictionary *metadataDict = (__Dictionary *)dict->objectForKey("metadata");
int format = static_cast<__String *>(metadataDict->objectForKey("format"))->intValue();
ptmRatio = static_cast<__String *>(metadataDict->objectForKey("ptm_ratio"))->floatValue();
CCAssert(format == 1, "Format not supported");
__Dictionary *bodyDict = (__Dictionary *)dict->objectForKey("bodies");
b2Vec2 vertices[b2_maxPolygonVertices];
DictElement* pElement;
std::string bodyName;
__Dictionary *bodyData;
CCDICT_FOREACH(bodyDict,pElement){
bodyName = pElement->getStrKey();
bodyData =(__Dictionary*)pElement->getObject();
BodyDef *bodyDef = new BodyDef();
bodyDef->anchorPoint = PointFromString(static_cast<__String *>(bodyData->objectForKey("anchorpoint"))->getCString());
__Array *fixtureList = (__Array *)(bodyData->objectForKey("fixtures"));
FixtureDef **nextFixtureDef = &(bodyDef->fixtures);
Ref* object;
CCARRAY_FOREACH(fixtureList, object){
b2FixtureDef basicData;
__Dictionary *fixtureData = (__Dictionary*)object;
basicData.filter.categoryBits = static_cast< __String*>(fixtureData->objectForKey("filter_categoryBits"))->intValue();
basicData.filter.maskBits = static_cast<__String*>(fixtureData->objectForKey("filter_maskBits"))->intValue();
basicData.filter.groupIndex = static_cast<__String *>(fixtureData->objectForKey("filter_groupIndex"))->intValue();
basicData.friction = static_cast<__String *>(fixtureData->objectForKey("friction"))->floatValue();
basicData.density = static_cast<__String *>(fixtureData->objectForKey("density"))->floatValue();
basicData.restitution = static_cast<__String *>(fixtureData->objectForKey("restitution"))->floatValue();
basicData.isSensor = (bool)static_cast<__String *>(fixtureData->objectForKey("isSensor"))->boolValue();
__String *cb = static_cast<__String *>(fixtureData->objectForKey("userdataCbValue"));
int callbackData = 0;
if (cb)
callbackData = cb->intValue();
std::string fixtureType = static_cast<__String *>(fixtureData->objectForKey("fixture_type"))->getCString();
if (fixtureType == "POLYGON") {
__Array *polygonsArray = (__Array *)(fixtureData->objectForKey("polygons"));
Ref* singlePolygon;
CCARRAY_FOREACH(polygonsArray, singlePolygon){
FixtureDef *fix = new FixtureDef();
fix->fixture = basicData; // copy basic data
fix->callbackData = callbackData;
b2PolygonShape *polyshape = new b2PolygonShape();
int vindex = 0;
__Array *verticeArray = (__Array *)singlePolygon;
assert(verticeArray->count() <= b2_maxPolygonVertices);
Ref* singlePoint;
CCARRAY_FOREACH(verticeArray, singlePoint){
__String* vert = (__String*)singlePoint;
cocos2d::Point offset = PointFromString(vert->getCString());
vertices[vindex].x = (offset.x / ptmRatio) ;
vertices[vindex].y = (offset.y / ptmRatio) ;
vindex++;
}
