C++ ccpAdd函数代码示例

void HelloWorld::tick(float dt) {


    //=================================
    CCPoint backgroundScrollVert = ccp(-2000, 0);
    pBackgroundNode->setPosition(ccpAdd(pBackgroundNode->getPosition(), ccpMult(backgroundScrollVert, dt)));

    CCArray *BackGrounds = CCArray::createWithCapacity(2);
    BackGrounds->addObject(pSprite);
    BackGrounds->addObject(pNextSprite);
    for ( int ii = 0; ii < BackGrounds->count(); ii++ ) {
        CCSprite * BackGround = (CCSprite *)(BackGrounds->objectAtIndex(ii));
        float xPosition = pBackgroundNode->convertToWorldSpace(BackGround->getPosition()).x;
        float size = BackGround->getContentSize().width;
        if ( xPosition < -size/2 ) {
            pBackgroundNode->incrementOffset(ccp(BackGround->getContentSize().width*2,0),BackGround);
        }
    }


    //===================================

    pworld->Step(dt, 10, 10);
    for(b2Body *b = pworld->GetBodyList(); b; b=b->GetNext()) {
        if (b->GetUserData() != NULL) {

            if(b->GetType() == b2_dynamicBody)
            {
                CCSprite *ballData = (CCSprite *)b->GetUserData();
                ballData->setPosition(ccp(b->GetPosition().x * PTM_RATIO,
                                          b->GetPosition().y * PTM_RATIO));
                ballData->setRotation (-1 * CC_RADIANS_TO_DEGREES(b->GetAngle()));
            }

            /*else if(b->GetType() == b2_staticBody)
            {
            	CCSprite *ballData = (CCSprite *)b->GetUserData();
            	ballData->setPosition(ccp(b->GetPosition().x * PTM_RATIO,
            		b->GetPosition().y * PTM_RATIO));
            	ballData->setRotation (-1 * CC_RADIANS_TO_DEGREES(b->GetAngle()));
            }*/
        }
    }

}

void SGShowJingZhouRankCell::setData(SGShowJingZhouRankPlayerLayer *player)
{
    CCString *string = CCString::createWithFormat("countryIcon_%d.png", player->getHeadId());
    spriteIcon->setDisplayFrame(CCSprite::createWithSpriteFrameName(string->getCString())->displayFrame());
    spriteIcon->cocos2d::CCNode::setScale(0.9, 0.95);
    spriteIcon->setPosition(ccpAdd(spriteIconBg->getPosition(), ccp(spriteIcon->getContentSize().width*0.00, spriteIcon->getContentSize().height*0.05)) );
    //////////
    string = CCString::createWithFormat("country_%d.png", player->getHeadId());
    spriteIconBg->setDisplayFrame(CCSprite::createWithSpriteFrameName(string->getCString())->displayFrame());
    
    ////////////////////

     CCString *name= CCString::createWithFormat("%s", player->getName()->getCString());
     labelNickName->setString(name->getCString());
    
     CCString* paiming = CCString::createWithFormat(str_BMatchEndBox_str14, player->getRank());
     labelRank->setString(paiming->getCString());
    
     CCString* boshu = CCString::createWithFormat(str_ShowJingZhouRankCell_str2, player->getWave());
     labelboshu->setString(boshu->getCString());
    
     CCString* shanghai = CCString::createWithFormat(str_ShowJingZhouRankCell_str3, player->getDamage());
     labelshanghai->setString(shanghai->getCString());
	
	
	//更元宝显示, 是否能得到元宝
	//if (player->getGoldNum())
	{
		//可获得的奖励数量小于可获取奖励的人数时才显示
		goldCount->setString(CCString::createWithFormat("X %d", player->getGoldNum())->getCString());
	}
/*	else//没有元宝就什么都不显示
	{
		goldCount->setVisible(false);
		goldSpr->setVisible(false);
		goldBorderSpr->setVisible(false);
		goldBg->setVisible(false);
	}
	
	*/
	
	
	
 
}

void CAScrollView::ccTouchEnded(CATouch *pTouch, CAEvent *pEvent)
{
    if (m_pTouches->containsObject(pTouch))
    {
        if (m_pTouches->count() == 1)
        {
            CCPoint p = CCPointZero;
            
            if (m_tPointOffset.size() > 0)
            {
                for (unsigned int i=0; i<m_tPointOffset.size(); i++)
                {
                    p = ccpAdd(p, m_tPointOffset.at(i));
                }
                p = p/m_tPointOffset.size();
            }
            m_tInertia = p * 1.5f;
			m_tPointOffset.clear();

            if (!m_tInertia.equals(CCPointZero))
            {
                m_bDecelerating = true;
                if (m_pScrollViewDelegate)
                {
                    m_pScrollViewDelegate->scrollViewDidScroll(this);
                }
            }

            this->startDeaccelerateScroll();
            
            if (m_pScrollViewDelegate)
            {
                m_pScrollViewDelegate->scrollViewDidEndDragging(this);
            }
            m_bTracking = false;
            
            this->detectionFromPullToRefreshView();
        }
        else if (m_pTouches->count() == 2)
        {
            m_bZooming = false;
        }
        m_pTouches->removeObject(pTouch);
    }
}

bool RoleJoyPad::init()
{

    if ( !CCLayer::init() )
    {
        return false;
    }
    CCPoint pos = this->getPosition();
    
    //ccp(winSize.width/2-32, winSize.height/2-164-115)
    CCSprite* mask =CCSprite::create("UI_Make_rock.png");
    mask->setPosition(ccpAdd(pos, ccp(288, 290)));

    this->initData(mask);
    this->initAction();
    
    return true;
}

void SGSkillItem::showPlayerStar()
{
    for(int i=0;i<arrayStar->count();i++)
    {
        CCSprite *sprite = (CCSprite*)arrayStar->objectAtIndex(i);
        sprite->removeFromParentAndCleanup(true);
    }
    
    int starCount = _card->getCurrStar();
    for(int i=0; i < starCount;i++)
    {
        CCSprite *sprite = CCSprite::createWithSpriteFrameName("xx.png");
        sprite->setAnchorPoint(ccp(0.5, 1));
        sprite->setPosition(ccpAdd(spritePlayerHead->getPosition(), ccp(spritePlayerHead->getContentSize().width+sprite->getContentSize().width*i - 17,4)));
        arrayStar->addObject(sprite);
        this->addChild(sprite);
    }
}

void CCBezierBy::update(ccTime time)
{
	if (m_pTarget)
	{
		float xa = 0;
		float xb = m_sConfig.controlPoint_1.x;
		float xc = m_sConfig.controlPoint_2.x;
		float xd = m_sConfig.endPosition.x;

		float ya = 0;
		float yb = m_sConfig.controlPoint_1.y;
		float yc = m_sConfig.controlPoint_2.y;
		float yd = m_sConfig.endPosition.y;

		float x = bezierat(xa, xb, xc, xd, time);
		float y = bezierat(ya, yb, yc, yd, time);
		m_pTarget->setPosition(ccpAdd(m_startPosition, ccp(x, y)));
	}
}

//-------------------------------------------------------------------------
//
//
void CTaskEventSubGui::ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent)
{
	if( m_vTaskEvent.size() <= 4 )
	{
		m_pUpScorl->setIsVisible( false );
		m_pDownScorl->setIsVisible( false );
		return;
	}

	CCSize s = CCDirector::sharedDirector()->getWinSize();

    CCSetIterator it = pTouches->begin();
	CCTouch* touch = (CCTouch*)(*it);

	CCPoint touchLocation = touch->locationInView( touch->view() );	
	CCPoint prevLocation = touch->previousLocationInView( touch->view() );	
	
	touchLocation = CCDirector::sharedDirector()->convertToGL( touchLocation );
	prevLocation = CCDirector::sharedDirector()->convertToGL( prevLocation );
	
	CCPoint diff = ccpSub(touchLocation, prevLocation);
	CCPoint currentPos = m_pGroupNode->getPosition();
	m_pGroupNode->setPosition( ccp( currentPos.x, ccpAdd(currentPos, diff).y ) );


	m_pUpScorl->setIsVisible( true );
	m_pDownScorl->setIsVisible( true );
	if( m_pGroupNode->getPosition().y <= 0 )
	{
		m_pGroupNode->setPosition( ccp( m_pGroupNode->getPosition().x, 0 ) );
		m_pUpScorl->setIsVisible( false );

	}

	if( m_pGroupNode->getPosition().y >= m_iEachSizeDis * ( m_vTaskEvent.size() - 4) )
	{
		m_pGroupNode->setPosition( ccp( m_pGroupNode->getPosition().x, m_iEachSizeDis * ( m_vTaskEvent.size() - 4) ) );
		m_pDownScorl->setIsVisible( false );

	}


}

void CCSimpleRookieGuide::pointToRegionCenter(int regionIndex, float distance, float degree, float arrowPresetRotation) {
    // basic check
    if(regionIndex < 0 || regionIndex >= m_regions.size() || !m_arrow)
        return;

    // get region
    Region& reg = m_regions.at(regionIndex);
    CCRect& r = reg.r;
    CCPoint center = ccpAdd(r.origin, ccp(r.size.width / 2, r.size.height / 2));

    // get center of arrow sprite
    float radian = CC_DEGREES_TO_RADIANS(degree);
    center.x += distance * cosf(radian);
    center.y += distance * sinf(radian);

    // set arrow
    m_arrow->setPosition(center);
    m_arrow->setRotation(-(degree - 180 - arrowPresetRotation));
}

//
// Logics - BEGIN
//
void MovingComponent::update(float dt) {
    CCPoint agentPos = m_pAgent->getPosition();
    
    if (fabsf(agentPos.x - m_uTargetPosition.x) < 2 && fabsf(agentPos.y - m_uTargetPosition.y) < 2) {
        MessageDispatcher::instance()->dispatchMessage(0, m_pAgent->getID(), m_pAgent->getID(), kMessageReachPosition, (void *)&m_uTargetPosition);
        return ;
    }
    
    CCPoint direction = ccpSub(m_uTargetPosition, agentPos);
    CCPoint n = ccpNormalize(direction);
    
    double kSpeedTweaker = 0.2;
    double k = m_eSpeedLevel * kSpeedTweaker;
    n.x *= k;
    n.y *= k;
    
    CCPoint goTo = ccpAdd(m_pAgent->getPosition(), n);
    m_pAgent->setPosition(goTo);
}

void Hero::move(HeroDirection direction) 
{
	if (isHeroMoving)
		return;

	//移动的距离
	Point moveByPosition;
	//根据方向计算移动的距离
	switch (direction)
	{
	case kDown:
		moveByPosition = Vec2(0, -32);
		break;
	case kLeft:
		moveByPosition = Vec2(-32, 0);
		break;
	case kRight:
		moveByPosition = Vec2(32, 0);
		break;
	case kUp:
		moveByPosition = Vec2(0, 32);
		break;
	}
	//计算目标坐标，用当前勇士坐标加上移动距离
	targetPosition = ccpAdd(this->getPosition(), moveByPosition);
	//调用checkCollision检测碰撞类型，如果是墙壁、怪物、门，则只需要设置勇士的朝向
	CollisionType collisionType = checkCollision(targetPosition);
	if (collisionType == kWall || collisionType == kEnemy || collisionType == kDoor || collisionType == kNPC)
	{
		setFaceDirection((HeroDirection)direction);
		return;
	}
	//heroSprite仅播放行走动画
	heroSprite->runAction(sAnimationMgr->createAnimate(direction));
	//主体进行位移，结束时调用onMoveDone方法
	Action *action = Sequence::create(
		MoveBy::create(0.20f, moveByPosition),
		//把方向信息传递给onMoveDone方法
		CCCallFuncND::create(this, callfuncND_selector(Hero::onMoveDone), (void*)direction),
		NULL);
	this->runAction(action);
	isHeroMoving = true;
}

bool GameMainLayer::init()
{
    if (!CCLayer::init())
        return false;
    
    CCSize size = CCDirector::sharedDirector()->getVisibleSize();
    CCPoint originPoint = CCDirector::sharedDirector()->getVisibleOrigin();
    
    map = new GameObjMap();
    map->setAnchorPoint(ccp(0, 1));
    map->setPosition(ccpSub(ccp(0, size.height), originPoint));
    this->addChild(map, 0);
    
    hero = new GameObjHero();
    hero->setScale(0.5f);
    hero->setPosition(ccpAdd(ccp(100, 160), originPoint));
    this->addChild(hero, 1);
    
    gameMark = new GameMark();
    this->addChild(gameMark, 4);
    
    //游戏结束
    gameOver = CCSprite::create("gameover.png");
    gameOver->setScale(0.5f);
    gameOver->setPosition(ccp(size.width/2, size.height/2 + 70));
    gameOver->setVisible(false);
    this->addChild(gameOver, 5);
    
    //菜单项
    CCMenuItemImage *pCloseItem = CCMenuItemImage::create("back.png", "back.png", this, menu_selector(GameMainLayer::menuBackCallback));
    pCloseItem->setPosition(ccp(size.width/2, size.height/2 - 50));
    pCloseItem->setScale(0.5f);
    
    CCMenu *pMenu = CCMenu::create(pCloseItem, NULL);
    pMenu->setPosition(CCPointZero);
    this->addChild(pMenu, 5, 25);
    pMenu->setVisible(false);
    pMenu->setEnabled(false);
    
    this->isOver = false;
    this->scheduleUpdate();
    return true;
}

//初始化界面
void SGFriend::initView()
{
    CCPoint bottomCenter = SGLayout::getPoint(kBottomCenter);
    CCPoint upCenter = SGLayout::getPoint(kUpCenter);
    float h = SGMainManager::shareMain()->getTotleHdHgt();
    float b = SGMainManager::shareMain()->getBottomHeight();
	 

    
    //我的好友
//    CCSprite *spriteTitle = CCSprite::createWithSpriteFrameName("friend_myFriend.png");
    SGCCLabelTTF *spriteTitle = SGCCLabelTTF::create(str_FriendCountFull_str11, FONT_XINGKAI, 36 , COLOR_UNKNOW_TAN);
    //modify by:zyc. merge into create.
	//spriteTitle->setColor(ccc3(0xff, 0x95, 0x0c));
    spriteTitle->setPosition(ccpAdd(upCenter, ccp(0, -h+65/2)));
    this->addChild(spriteTitle);
    
    CCSprite *title_bg = CCSprite::createWithSpriteFrameName("title_bg.png");
    title_bg->setAnchorPoint(ccp(0.5, 1));
    title_bg->setPosition(ccpAdd(SGLayout::getPoint(kUpCenter), ccp(0, -h + title_bg->getContentSize().height-2)));
    this->addChild(title_bg,-1);
    
    
    float headhgt = SGMainManager::shareMain()->getTotleHdHgt();
    CCSize s = CCDirector::sharedDirector()->getWinSize();
    CCSprite *titlecenter = CCSprite::createWithSpriteFrameName("title_bg_2.png");
    titlecenter->setAnchorPoint(ccp(0.5, 0));
    titlecenter->setPosition(ccpAdd(SGLayout::getPoint(kUpCenter), ccp(0,  -headhgt- 10)));
    this->addChild(titlecenter,10);
    titlecenter->setScaleX(4);
    
    CCSprite *title_bg_l = CCSprite::createWithSpriteFrameName("title_bg_LR.png");
    title_bg_l->setAnchorPoint(ccp(0, 0));
    title_bg_l->setPosition(ccpAdd(SGLayout::getPoint(kUpCenter), ccp(-s.width/2,  -headhgt- 10)));
    this->addChild(title_bg_l,10);
    
    CCSprite *title_bg_r = CCSprite::createWithSpriteFrameName("title_bg_LR.png");
    title_bg_r->setFlipX(true);
    title_bg_r->setAnchorPoint(ccp(1, 0));
    title_bg_r->setPosition(ccpAdd(SGLayout::getPoint(kUpCenter), ccp(s.width/2,  -headhgt- 10)));
    this->addChild(title_bg_r,10);
   
    //tableview
    tableView->setFrame(CCRectMake(0, 56+101, SGLayout::getSkewing(320) , SGLayout::getSkewingY(480)-b-h));
    tableView->setZOrder(0);
    tableView->setPosition(ccpAdd(bottomCenter, ccp(-skewing(160), b)));
    this->tableViewHeight = 110;
    tableView->setDown(-18);
    //tableView -> setPageNEnable(true);
}

Point IRole::getNextPointByDir()
{
	Point dest;
	int dirValue = 212;
	int dValue = 176;
	switch (direction)
	{
		case GameDirs::BACK_DIR:
		{
			dest = ccp(0, dirValue);
		}break;
		case GameDirs::LEFT_DIR:
		{
			dest = ccp(-dirValue, 0);
		}break;
		case GameDirs::RIGHT_DIR:
		{
			dest = ccp(dirValue, 0);
		}break;
		case GameDirs::FRONT_DIR:
		{
			dest = ccp(0, -dirValue);
		}break;
		case GameDirs::BACK_LEFT_DIR:
		{
			dest = ccp(-dValue, dValue);
		}break;
		case GameDirs::FRONT_RIGHT_DIR:
		{
			dest = ccp(dValue, -dValue);
		}break;
		case GameDirs::FRONT_LEFT_DIR:
		{
			dest = ccp(-dValue, -dValue);
		}break;
		case GameDirs::BACK_RIGHT_DIR:
		{
			dest = ccp(dValue, dValue);
		}break;
	}
	return ccpAdd(dest,this->getPosition()); 
}

CCPoint EXZoomController::getHistoricSpeed() {
    CCPoint lastPt;
    CCPoint tPt = ccp(0,0);
    CCPoint speed = ccp(0,0);
    float   lastTime;
    int     count = 0;
    
    //Walk thru our history
    for (int i = 0; i < kEXZoomControllerHistoryCount && i < _timePointStampCounter; i++) {
        CCPanZoomTimePointStamp *record = &_history[(_timePointStampCounter-i-1) % kEXZoomControllerHistoryCount];
        
        CCPoint pt = record->pt;
        float time = record->time;
        
        //Only calculate after first
        if (i != 0) {
            //Sentinels: stop if we have large time chunks
            if ((lastTime-time) > .25)
                break;
            //or sporadic vectors past an amount of history
            if (i > 3 && vectorsDeviation(lastPt, pt) > .1)
                break;
            
            //Get a vector between two touches, but weight it with the time difference,
            //this will eliminate small quick movements and favor sweeping touches
            tPt = ccpAdd(tPt, ccpMult(ccpSub(lastPt, pt), (lastTime-time)));
            count++;
        }
        
        lastPt = pt;
        lastTime = time;
    }
    
    //Calculate speed
    if (count)
        speed = ccpMult(tPt, 1.0f/count);
    
    CCLog("tPt %f,%f",tPt.x, tPt.y);
    CCLog("count %d",count);
    CCLog("speed %f,%f",speed.x, speed.y);
    return speed;
}

void GameGlobals::GeneratePolygonFormation(EEnemyFormation type, vector<CCPoint> &vertices, int num_vertices, CCRect boundary, CCPoint anchor_point)
{
	int num_polygons = 1;
	float polygon_radius = SCREEN_SIZE.width/6;
	switch(type)
	{
	case E_FORMATION_POLYGON_EASY:
		num_polygons = 1;
		polygon_radius = SCREEN_SIZE.width/6;
		break;
	case E_FORMATION_POLYGON_MEDIUM:
		num_polygons = 2;
		polygon_radius = SCREEN_SIZE.width/7;
		break;
	case E_FORMATION_POLYGON_HARD:
		num_polygons = 3;
		polygon_radius = SCREEN_SIZE.width/8;
		break;
	}

	int num_vertices_per_polygon = (int)(num_vertices/num_polygons);
	vector<CCPoint> vertices_per_polygon;
	vertices_per_polygon.clear();

	for(int i = 0; i < num_polygons; ++i)
	{
		// get the vertices of a single polygon
		GetRegularPolygonVertices(vertices_per_polygon, num_vertices_per_polygon, (i * ENEMY_RADIUS * 2.5f + polygon_radius));

		// copy the vertices into the final array
		for(int j = 0; j < num_vertices_per_polygon; ++j)
		{
			CCPoint vertex = ccpAdd(vertices_per_polygon[j], anchor_point);
			if(RECT_CONTAINS_CIRCLE(boundary, vertex, ENEMY_RADIUS*2))
			{
				vertices.push_back(vertex);
			}
		}

		vertices_per_polygon.clear();
	}
}