void CCTintBy::startWithTarget(CCNode *pTarget)
{
CCActionInterval::startWithTarget(pTarget);
CCRGBAProtocol *pRGBAProtocol = pTarget->convertToRGBAProtocol();
if (pRGBAProtocol)
{
ccColor3B color = pRGBAProtocol->getColor();
m_fromR = color.r;
m_fromG = color.g;
m_fromB = color.b;
}
}
void CCControlButton::setOpacity(GLubyte opacity)
{
m_cOpacity = opacity;
CCObject* child;
CCArray* children=getChildren();
CCARRAY_FOREACH(children, child)
{
CCRGBAProtocol* pNode = dynamic_cast<CCRGBAProtocol*>(child);
if (pNode)
{
pNode->setOpacity(opacity);
}
}
void CArmySprite::underAttack(int nHurt)
{
if (m_eCurState >= AS_EXPLODE)
{
return ;
}
m_sCurData.mHealthPoint -= nHurt;
if (m_bIsNormal)
{
m_bIsNormal = false;
CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTurretSprite);
color = pRGBAProtocol->getColor();
pRGBAProtocol->setColor(ccc3(255,0,0));
}
if (m_sCurData.mHealthPoint < 0)
{
m_sCurData.mHealthPoint = 0;
m_eCurState = AS_EXPLODE;
m_pTurretSprite->setVisible(false);
m_pBaseSprite->setVisible(false);
if (m_pCapSprite)
{
m_pCapSprite->setVisible(false);
}
m_pWreckSprite->setVisible(true);
CGlobalData::getSingleton()->addScore(m_sCurData.mScoreValue);
Music::playExplode2Effect();
CGlobalData::getSingleton()->addDesArmyScore(m_sCurLandData.mKind);
ASSESS_DATA mData;
if (CCRANDOM_0_1() > 0.5f)
{
mData.mKind = ASK_PERFECT;
}
else
{
mData.mKind = ASK_DEFAULT;
}
mData.mPos = getPosition();
CAssess *pAssess = CAssess::createAssess(mData);
getParent()->addChild(pAssess, ASSESS_ZORDER);
mData.mKind = ASK_ADD100;
mData.mPos = ccpAdd(mData.mPos, ccp(0, getContentSize().height * 0.5f));
pAssess = CAssess::createAssess(mData);
getParent()->addChild(pAssess, ASSESS_ZORDER);
runEffect();
}
}
void CCScale9Sprite::setColor(const ccColor3B& color)
{
_color = color;
CCObject* child;
CCArray* children = this->getSubviews();
CCARRAY_FOREACH(children, child)
{
CCRGBAProtocol* pNode = dynamic_cast<CCRGBAProtocol*>(child);
if (pNode)
{
pNode->setColor(color);
}
}
bool UIWidget::init()
{
m_children = CCArray::create();
m_children->retain();
initNodes();
m_pRender->retain();
m_pRender->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = DYNAMIC_CAST_CCRGBAPROTOCOL;
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(true);
renderRGBA->setCascadeOpacityEnabled(true);
}
return true;
}
void CCTreeFadeIn::fadeInRecursively(CCNode* n, float time) {
CCArray* children = n->getChildren();
int cc = n->getChildrenCount();
for(int i = 0; i < cc; i++) {
CCNode* child = (CCNode*)children->objectAtIndex(i);
if(!m_excludeList.containsObject(child)) {
CCRGBAProtocol* p = dynamic_cast<CCRGBAProtocol*>(child);
if(p) {
p->setOpacity((GLubyte)(255 * time));
}
}
fadeInRecursively(child, time);
}
}
void Crystal820Layer::updateColor(void)
{
CCLayerColor::updateColor();
if(m_pChildren && m_pChildren->count() > 0)
{
CCObject* child;
CCARRAY_FOREACH(m_pChildren, child)
{
CCNode* pNode = (CCNode*) child;
CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(pNode);
if (pRGBAProtocol)
{
pRGBAProtocol->setOpacity(m_cOpacity);
}
}
/** Override synthesized setOpacity to recurse items */
void CCLayerRGBA::setOpacity(GLubyte opacity)
{
_displayedOpacity = _realOpacity = opacity;
if( _cascadeOpacityEnabled )
{
GLubyte parentOpacity = 255;
CCRGBAProtocol *parent = dynamic_cast<CCRGBAProtocol*>(m_pParent);
if (parent && parent->isCascadeOpacityEnabled())
{
parentOpacity = parent->getDisplayedOpacity();
}
updateDisplayedOpacity(parentOpacity);
}
}
void CCLabelBMFont::setIsOpacityModifyRGB(bool var)
{
m_bIsOpacityModifyRGB = var;
if (m_pChildren && m_pChildren->count() != 0)
{
NSMutableArray<CCNode*>::NSMutableArrayIterator it;
for(it = m_pChildren->begin(); it != m_pChildren->end(); ++it)
{
CCRGBAProtocol *pRGBAProtocol = (*it)->convertToRGBAProtocol();
if (pRGBAProtocol)
{
pRGBAProtocol->setIsOpacityModifyRGB(m_bIsOpacityModifyRGB);
}
}
}
}
void CCLayerRGBA::setColor(const ccColor3B& color)
{
_displayedColor = _realColor = color;
if (_cascadeColorEnabled)
{
ccColor3B parentColor = ccWHITE;
CCRGBAProtocol* parent = dynamic_cast<CCRGBAProtocol*>(m_pParent);
if (parent && parent->isCascadeColorEnabled())
{
parentColor = parent->getDisplayedColor();
}
updateDisplayedColor(parentColor);
}
}
void CCLayerRGBA::updateDisplayedOpacity(GLubyte parentOpacity)
{
_displayedOpacity = _realOpacity * parentOpacity/255.0;
if (_cascadeOpacityEnabled)
{
CCObject *obj = NULL;
CCARRAY_FOREACH(m_pChildren, obj)
{
CCRGBAProtocol *item = dynamic_cast<CCRGBAProtocol*>(obj);
if (item)
{
item->updateDisplayedOpacity(_displayedOpacity);
}
}
}
static void setEnableRecursiveCascading(CCNode* node, bool enable)
{
CCRGBAProtocol* rgba = dynamic_cast<CCRGBAProtocol*>(node);
if (rgba)
{
rgba->setCascadeColorEnabled(enable);
rgba->setCascadeOpacityEnabled(enable);
}
CCObject* obj;
CCArray* children = node->getChildren();
CCARRAY_FOREACH(children, obj)
{
CCNode* child = (CCNode*)obj;
setEnableRecursiveCascading(child, enable);
}
void CCScale9Sprite::setOpacityModifyRGB(bool var)
{
if (!_scale9Image)
{
return;
}
_opacityModifyRGB = var;
CCObject* child;
CCArray* children = _scale9Image->getChildren();
CCARRAY_FOREACH(children, child)
{
CCRGBAProtocol* pNode = dynamic_cast<CCRGBAProtocol*>(child);
if (pNode)
{
pNode->setOpacityModifyRGB(_opacityModifyRGB);
}
}
void CCLabelBMFont::setOpacity(GLubyte var)
{
m_cOpacity = var;
if (m_pChildren && m_pChildren->count() != 0)
{
NSMutableArray<CCNode*>::NSMutableArrayIterator it;
for(it = m_pChildren->begin(); it != m_pChildren->end(); ++it)
{
CCRGBAProtocol *pRGBAProtocol = (*it)->convertToRGBAProtocol();
if (pRGBAProtocol)
{
pRGBAProtocol->setOpacity(m_cOpacity);
}
}
}
}
bool UIWidget::init()
{
m_children = CCArray::create();
m_children->retain();
initRenderer();
m_pRenderer->retain();
m_pRenderer->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = DYNAMIC_CAST_CCRGBAPROTOCOL;
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(true);
renderRGBA->setCascadeOpacityEnabled(true);
}
setBright(true);
ignoreContentAdaptWithSize(true);
return true;
}
//--------------------------------------------------------------------
// 递归渐隐
void FKCW_Action_TreeFadeOut::FadeOutRecursively( CCNode* p_pRoot, float p_fTime )
{
CCRGBAProtocol* p = dynamic_cast<CCRGBAProtocol*>(p_pRoot);
if(p)
{
p->setOpacity((GLubyte)(255 * (1 - p_fTime)));
}
CCArray* children = p_pRoot->getChildren();
int cc = p_pRoot->getChildrenCount();
for(int i = 0; i < cc; i++)
{
CCNode* child = (CCNode*)children->objectAtIndex(i);
if(!m_vecExcludeList.containsObject(child))
{
FadeOutRecursively(child, p_fTime);
}
else if(!m_bIsRecursivelyExclude)
{
FadeOutRecursively(child, p_fTime);
}
}
// 检查UI
Widget* w = dynamic_cast<Widget*>(p_pRoot);
if(w)
{
if(w->getVirtualRenderer())
{
CCRGBAProtocol* p = dynamic_cast<CCRGBAProtocol*>(w->getVirtualRenderer());
if(p)
{
p->setOpacity((GLubyte)(255 * (1 - p_fTime)));
}
}
CCArray* children = w->getNodes();
int cc = children->count();
for(int i = 0; i < cc; i++)
{
CCNode* child = (CCNode*)children->objectAtIndex(i);
FadeOutRecursively(child, p_fTime);
}
}
}
void CCScale9Sprite::setOpacityModifyRGB(bool var)
{
do
{
CC_BREAK_IF(m_pImage == NULL);
_opacityModifyRGB = var;
CCObject* child;
CCArray* children = this->getSubviews();
CCARRAY_FOREACH(children, child)
{
CCRGBAProtocol* pNode = dynamic_cast<CCRGBAProtocol*>(child);
if (pNode)
{
pNode->setOpacityModifyRGB(_opacityModifyRGB);
}
}
}
while (0);
}
bool Layout::init()
{
m_children = CCArray::create();
m_children->retain();
initRenderer();
m_pRenderer->retain();
m_pRenderer->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = dynamic_cast<CCRGBAProtocol*>(m_pRenderer);
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(false);
renderRGBA->setCascadeOpacityEnabled(false);
}
ignoreContentAdaptWithSize(false);
setSize(CCSizeZero);
setBright(true);
setAnchorPoint(ccp(0, 0));
m_pScheduler = CCDirector::sharedDirector()->getScheduler();
CC_SAFE_RETAIN(m_pScheduler);
return true;
}
bool UIWidget::init()
{
m_children = CCArray::create();
m_children->retain();
m_pLayoutParameterDictionary = CCDictionary::create();
CC_SAFE_RETAIN(m_pLayoutParameterDictionary);
initRenderer();
m_pRenderer->retain();
m_pRenderer->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = DYNAMIC_CAST_CCRGBAPROTOCOL;
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(true);
renderRGBA->setCascadeOpacityEnabled(true);
}
setBright(true);
ignoreContentAdaptWithSize(true);
m_pScheduler = CCDirector::sharedDirector()->getScheduler();
CC_SAFE_RETAIN(m_pScheduler);
return true;
}
void CCMenu::setColor(cocos2d::ccColor3B var)
{
m_tColor = var;
if (m_pChildren && m_pChildren->count() > 0)
{
NSMutableArray<CCNode*>::NSMutableArrayIterator it;
for (it = m_pChildren->begin(); it != m_pChildren->end(); ++it)
{
if (! *it)
{
break;
}
CCRGBAProtocol *pRGBAProtocol = (*it)->convertToRGBAProtocol();
if (pRGBAProtocol)
{
pRGBAProtocol->setColor(m_tColor);
}
}
}
}
void CArmySprite::enemyUpdate(float fEscapeTime)
{
switch(m_eCurState)
{
case AS_DEFAULT:
break;
case AS_MOVE:
//if (getPosition().y < -getContentSize().height || getPosition().y > mScreenSize.height - BANNER_HEIGHT + getContentSize().height)
//{
// m_eCurState = BS_HIDE;
//}
m_fFireCoolTime += fEscapeTime;
if (m_fFireCoolTime > 2.0f)
{
fireBullet(fEscapeTime);
}
break;
case AS_EXPLODE:
break;
case AS_HIDE:
if(getPosition().y < -getContentSize().height * 0.5f)
{
getParent()->removeChild(this, true);
}
break;
}
if (m_eCurState < AS_EXPLODE && m_sCurData.mKind < AK_BUNKER01)
{
CCNode *m_pTarget = (CCNode*)(getParent()->getChildByTag(PALYER_TYPE));
float o = m_pTarget->getPosition().x - getPosition().x;
float a = m_pTarget->getPosition().y - getPosition().y;
float at = (float) CC_RADIANS_TO_DEGREES( atanf( o/a) );
if( a < 0 )
{
if( o < 0 )
at = 180 + fabs(at);
else
at = 180 - fabs(at);
}
m_pTurretSprite->setRotation(180 + at);
}
if (getPosition().y > -getContentSize().height * 0.5f)
{
setPosition(ccpAdd(getPosition(),ccpMult(ccp(0.0f, -1.0f), m_sCurData.mMoveSpeed * fEscapeTime)));
}
else
{
m_eCurState = AS_HIDE;
}
if (!m_bIsNormal)
{
m_fFlashTime += fEscapeTime;
if (m_fFlashTime > 0.1f)
{
m_fFlashTime = 0.0f;
CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTurretSprite);
pRGBAProtocol->setColor(color);
m_bIsNormal = true;
}
}
}
void NodeReader::initNode(cocos2d::CCNode* node, const rapidjson::Value& json)
{
float x = DICTOOL->getFloatValue_json(json, X);
float y = DICTOOL->getFloatValue_json(json, Y);
float scalex = DICTOOL->getFloatValue_json(json, SCALE_X, 1);
float scaley = DICTOOL->getFloatValue_json(json, SCALE_Y, 1);
float rotation = DICTOOL->getFloatValue_json(json, ROTATION);
float rotationSkewX = DICTOOL->getFloatValue_json(json, ROTATION_SKEW_X);
float rotationSkewY = DICTOOL->getFloatValue_json(json, ROTATION_SKEW_X);
float skewx = DICTOOL->getFloatValue_json(json, SKEW_X);
float skewy = DICTOOL->getFloatValue_json(json, SKEW_Y);
float anchorx = DICTOOL->getFloatValue_json(json, ANCHOR_X, 0.5f);
float anchory = DICTOOL->getFloatValue_json(json, ANCHOR_Y, 0.5f);
GLubyte alpha = (GLubyte)DICTOOL->getIntValue_json(json, ALPHA, 255);
GLubyte red = (GLubyte)DICTOOL->getIntValue_json(json, RED, 255);
GLubyte green = (GLubyte)DICTOOL->getIntValue_json(json, GREEN, 255);
GLubyte blue = (GLubyte)DICTOOL->getIntValue_json(json, BLUE, 255);
int zorder = DICTOOL->getIntValue_json(json, ZORDER);
int tag = DICTOOL->getIntValue_json(json, TAG);
int actionTag = DICTOOL->getIntValue_json(json, ACTION_TAG);
bool visible = DICTOOL->getBooleanValue_json(json, VISIBLE);
if(x != 0 || y != 0)
node->setPosition(CCPoint(x, y));
if(scalex != 1)
node->setScaleX(scalex);
if(scaley != 1)
node->setScaleY(scaley);
if (rotation != 0)
node->setRotation(rotation);
if(rotationSkewX != 0)
node->setRotationX(rotationSkewX);
if(rotationSkewY != 0)
node->setRotationY(rotationSkewY);
if(skewx != 0)
node->setSkewX(skewx);
if(skewy != 0)
node->setSkewY(skewy);
if(anchorx != 0.5f || anchory != 0.5f)
node->setAnchorPoint(CCPoint(anchorx, anchory));
if(zorder != 0)
node->setZOrder(zorder);
if(visible != true)
node->setVisible(visible);
CCRGBAProtocol *rgbaProtocaol = dynamic_cast<CCRGBAProtocol *>(node);
if(rgbaProtocaol)
{
if(alpha != 255)
{
rgbaProtocaol->setOpacity(alpha);
}
if(red != 255 || green != 255 || blue != 255)
{
rgbaProtocaol->setColor(ccc3(red, green, blue));
}
}
node->setTag(tag);
node->setUserObject(TimelineActionData::create(actionTag));
}
bool CCControlButton::initWithLabelAndBackgroundSprite(CCNode* node, CCScale9Sprite* backgroundSprite)
{
if (CCControl::init())
{
CCAssert(node != NULL, "Label must not be nil.");
CCLabelProtocol* label = dynamic_cast<CCLabelProtocol*>(node);
CCRGBAProtocol* rgbaLabel = dynamic_cast<CCRGBAProtocol*>(node);
CCAssert(backgroundSprite != NULL, "Background sprite must not be nil.");
CCAssert(label != NULL || rgbaLabel!=NULL || backgroundSprite != NULL, "");
m_bParentInited = true;
// Initialize the button state tables
this->setTitleDispatchTable(CCDictionary::create());
this->setTitleColorDispatchTable(CCDictionary::create());
this->setTitleLabelDispatchTable(CCDictionary::create());
this->setBackgroundSpriteDispatchTable(CCDictionary::create());
setTouchEnabled(true);
m_isPushed = false;
m_zoomOnTouchDown = true;
m_currentTitle=NULL;
// Adjust the background image by default
setAdjustBackgroundImage(true);
setPreferredSize(CCSizeZero);
// Zooming button by default
m_zoomOnTouchDown = true;
// Set the default anchor point
ignoreAnchorPointForPosition(false);
setAnchorPoint(ccp(0.5f, 0.5f));
// Set the nodes
setTitleLabel(node);
setBackgroundSprite(backgroundSprite);
// Set the default color and opacity
setColor(ccc3(255.0f, 255.0f, 255.0f));
setOpacity(255.0f);
setOpacityModifyRGB(true);
// Initialize the dispatch table
CCString* tempString = CCString::create(label->getString());
//tempString->autorelease();
setTitleForState(tempString, CCControlStateNormal);
setTitleColorForState(rgbaLabel->getColor(), CCControlStateNormal);
setTitleLabelForState(node, CCControlStateNormal);
setBackgroundSpriteForState(backgroundSprite, CCControlStateNormal);
setLabelAnchorPoint(ccp(0.5f, 0.5f));
// Layout update
needsLayout();
return true;
}
//couldn't init the CCControl
else
{
return false;
}
}
void CCControlButton::needsLayout()
{
if (!m_bParentInited) {
return;
}
// Hide the background and the label
if (m_titleLabel != NULL) {
m_titleLabel->setIsVisible(false);
}
if (m_backgroundSprite) {
m_backgroundSprite->setIsVisible(false);
}
// Update anchor of all labels
this->setLabelAnchorPoint(this->m_labelAnchorPoint);
// Update the label to match with the current state
CC_SAFE_RELEASE(m_currentTitle);
m_currentTitle = getTitleForState(m_eState);
CC_SAFE_RETAIN(m_currentTitle);
m_currentTitleColor=getTitleColorForState(m_eState);
this->setTitleLabel(getTitleLabelForState(m_eState));
CCLabelProtocol* label = dynamic_cast<CCLabelProtocol*>(m_titleLabel);
if (label && m_currentTitle)
{
label->setString(m_currentTitle->toStdString().c_str());
}
CCRGBAProtocol* rgbaLabel = dynamic_cast<CCRGBAProtocol*>(m_titleLabel);
if (rgbaLabel)
{
rgbaLabel->setColor(m_currentTitleColor);
}
if (m_titleLabel != NULL)
{
m_titleLabel->setPosition(ccp (getContentSize().width / 2, getContentSize().height / 2));
}
// Update the background sprite
this->setBackgroundSprite(this->getBackgroundSpriteForState(m_eState));
if (m_backgroundSprite != NULL)
{
m_backgroundSprite->setPosition(ccp (getContentSize().width / 2, getContentSize().height / 2));
}
// Get the title label size
CCSize titleLabelSize;
if (m_titleLabel != NULL)
{
titleLabelSize = m_titleLabel->boundingBox().size;
}
// Adjust the background image if necessary
if (m_doesAdjustBackgroundImage)
{
// Add the margins
if (m_backgroundSprite != NULL)
{
m_backgroundSprite->setContentSize(CCSizeMake(titleLabelSize.width + m_marginH * 2, titleLabelSize.height + m_marginV * 2));
}
}
else
{
//TODO: should this also have margins if one of the preferred sizes is relaxed?
if (m_backgroundSprite != NULL)
{
CCSize preferredSize = m_backgroundSprite->getPreferredSize();
if (preferredSize.width <= 0)
{
preferredSize.width = titleLabelSize.width;
}
if (preferredSize.height <= 0)
{
preferredSize.height = titleLabelSize.height;
}
m_backgroundSprite->setContentSize(preferredSize);
}
}
// Set the content size
CCRect rectTitle;
if (m_titleLabel != NULL)
{
rectTitle = m_titleLabel->boundingBox();
}
CCRect rectBackground;
if (m_backgroundSprite != NULL)
{
rectBackground = m_backgroundSprite->boundingBox();
}
CCRect maxRect = CCControlUtils::CCRectUnion(rectTitle, rectBackground);
setContentSize(CCSizeMake(maxRect.size.width, maxRect.size.height));
if (m_titleLabel != NULL)
{
m_titleLabel->setPosition(ccp(getContentSize().width/2, getContentSize().height/2));
// Make visible the background and the label
m_titleLabel->setIsVisible(true);
}
if (m_backgroundSprite != NULL)
{
m_backgroundSprite->setPosition(ccp(getContentSize().width/2, getContentSize().height/2));
m_backgroundSprite->setIsVisible(true);
}
}
void RichText::formatText()
{
if (_formatTextDirty)
{
_elementRenderersContainer->removeAllChildren();
_elementRenders.clear();
if (_ignoreSize)
{
addNewLine();
for (unsigned int i=0; i<_richElements->count(); i++)
{
RichElement* element = static_cast<RichElement*>(_richElements->objectAtIndex(i));
CCNode* elementRenderer = NULL;
switch (element->_type)
{
case RICH_TEXT:
{
RichElementText* elmtText = static_cast<RichElementText*>(element);
elementRenderer = CCLabelTTF::create(elmtText->_text.c_str(), elmtText->_fontName.c_str(), elmtText->_fontSize);
break;
}
case RICH_IMAGE:
{
RichElementImage* elmtImage = static_cast<RichElementImage*>(element);
elementRenderer = CCSprite::create(elmtImage->_filePath.c_str());
break;
}
case RICH_CUSTOM:
{
RichElementCustomNode* elmtCustom = static_cast<RichElementCustomNode*>(element);
elementRenderer = elmtCustom->_customNode;
break;
}
default:
break;
}
CCRGBAProtocol* colorRenderer = dynamic_cast<CCRGBAProtocol*>(elementRenderer);
colorRenderer->setColor(element->_color);
colorRenderer->setOpacity(element->_opacity);
pushToContainer(elementRenderer);
}
}
else
{
addNewLine();
for (unsigned int i=0; i<_richElements->count(); i++)
{
RichElement* element = static_cast<RichElement*>(_richElements->objectAtIndex(i));
switch (element->_type)
{
case RICH_TEXT:
{
RichElementText* elmtText = static_cast<RichElementText*>(element);
handleTextRenderer(elmtText->_text.c_str(), elmtText->_fontName.c_str(), elmtText->_fontSize, elmtText->_color, elmtText->_opacity);
break;
}
case RICH_IMAGE:
{
RichElementImage* elmtImage = static_cast<RichElementImage*>(element);
handleImageRenderer(elmtImage->_filePath.c_str(), elmtImage->_color, elmtImage->_opacity);
break;
}
case RICH_CUSTOM:
{
RichElementCustomNode* elmtCustom = static_cast<RichElementCustomNode*>(element);
handleCustomRenderer(elmtCustom->_customNode);
break;
}
default:
break;
}
}
}
formarRenderers();
_formatTextDirty = false;
}
}
