自学教程：C++ CheckCollision函数代码示例

iMovingObject* csBlobManager::CheckCollision (iMovingObject* b){  int layer = b->GetLayer ();  iBlobViewPort* vp = b->GetViewPort ();  if (vp)  {    csBlobViewPort* viewport = static_cast<csBlobViewPort*> (vp);    for (size_t i = 0 ; i < viewport->objects.GetSize () ; i++)    {      iMovingObject* o = viewport->objects.Get (i);      if (o != b && o->GetLayer () == layer && CheckCollision (b, o))        return o;    }  }  else  {    for (size_t i = 0 ; i < movingobjects[layer].GetSize () ; i++)    {      iMovingObject* o = movingobjects[layer].Get (i);      if (o != b && o->GetViewPort () == 0 && CheckCollision (b, o))        return o;    }  }  return 0;}

/* Checks if the ball hit a wall or a goal post.  * In case it did the ball will bounce off.  * The parameter is the future positions of the * center of the ball. It's used to check the collision * with the goal posts. */void Game::WallHitCheck(){	Point2d ball_pos = ball->GetObject()->axiscenter;	// Collision with the ball	if (ball_pos.x - BALL_CIRCLE_RAY <= Field::LEFTUCORNER.x + Field::LINE_WIDTH ||		ball_pos.x + BALL_CIRCLE_RAY >= Field::RIGHTUCORNER.x){			deltax *= -1;			m_team_last = -1;			m_player_last = -1;	}	else if (ball_pos.y + BALL_CIRCLE_RAY >= Field::RIGHTUCORNER.y ||		ball_pos.y - BALL_CIRCLE_RAY <= Field::RIGHTLCORNER.y + Field::LINE_WIDTH){			deltay *= -1;			m_team_last = -1;			m_player_last = -1;	}	Point2d ball_center(ball_pos.x + SPEED * deltax * m_dt, 						ball_pos.y + SPEED * deltay * m_dt);	// Collision with one of the goal posts	if (CheckCollision(ball_center, Field::UP_MIDDLE_LEFT) > 0 || 		CheckCollision(ball_center, Field::UP_MIDDLE_RIGHT) > 0 ||		CheckCollision(ball_center, Field::BOTTOM_MIDDLE_LEFT) > 0 ||		CheckCollision(ball_center, Field::BOTTOM_MIDDLE_RIGHT) > 0) {			deltay *= -1;			m_team_last = -1;			m_player_last = -1;	}}

void AMobileEnemy::Tick(float DeltaSeconds) {  DeltaSeconds = TimeManager::Instance()->GetDeltaTime(DeltaSeconds);  m_lastPosition = GetActorLocation();  m_nextPosition = m_lastPosition;  EnemyAnimationMesh->bPauseAnims = TimeManager::Instance()->IsPaused();  if (!m_player) {    for (TActorIterator< APawn > ActorItr(GetWorld()); ActorItr; ++ActorItr) {      if (ActorItr->ActorHasTag("Player")) {        m_player = (APlayerOvi*)*ActorItr;        m_jumpSpeed = m_player->JumpSpeed;        m_accelerationJump = m_player->AccelerationJump;        break;      }    }  }  m_tickCounter++;  if (!HasTrigger || (HasTrigger && m_initMovement)) {    CheckCollision();    doMovement(DeltaSeconds);    CalculateGravity(DeltaSeconds);    CheckCollision();    SetActorLocation(m_nextPosition);  }}

int CollisionResult(){    // collision with bad shroom    if ( CheckCollision(&g_hippy, &g_shroom) || CheckCollision(&g_hippy, &g_fireBall) )    {        g_lives--;        if (g_lives < 0)        {            //ham_DeleteObj(g_hippy.sprite);            //ham_DeleteObj(g_shroom.sprite);            return 1;        }        else        {            // set life counter frame            ham_UpdateObjGfx(g_lifeCount.sprite, (void *)&lives_bitmap[g_lifeCount.w * g_lifeCount.h * g_lives]);            return -1;        }    }        // collision with key shroom    if ( CheckCollision(&g_hippy, &g_key) )    {        ham_DeleteObj(g_hippy.sprite);        ham_DeleteObj(g_shroom.sprite);        ham_DeleteObj(g_key.sprite);        ham_DeleteObj(g_fireBall.sprite);        return 3;    }    return 0;}

void Animal::Move(World &world){	if (m_isAlive)	{		m_vitesse.x = 0.05;		m_vitesse.z = 0.05;		if (m_ClockTarget.getElapsedTime().asSeconds() < m_timeNextTarget)		{			Vector3<float> deplacementVector = Vector3<float>(sin(m_HorizontalRot / 180 * PI), 0.f, cos(m_HorizontalRot / 180 * PI));			deplacementVector.Normalize();			//Avance en x			m_pos.x += deplacementVector.x * m_vitesse.x;			if (CheckCollision(world))			{				m_pos.x -= deplacementVector.x * m_vitesse.x;				Jump();			}			//En z			m_pos.z += deplacementVector.z * m_vitesse.z;			if (CheckCollision(world))			{				m_pos.z -= deplacementVector.z * m_vitesse.z;				Jump();			}		}		else		{			m_HorizontalRot += rand() % 200 - 100;			m_timeNextTarget = rand() % 10;			m_ClockTarget.restart();		}		//Chute		m_pos.y -= m_vitesse.y;		//Si collision		if (CheckCollision(world))		{			//Si on a touche le sol 			if (m_vitesse.y > 0)				m_isInAir = false;			//annule			m_pos.y += m_vitesse.y;			m_vitesse.y = 0;		}		else			m_isInAir = true;		//Acceleration		m_vitesse.y += 0.013f;	}}

void	CCollision::SpellCollision(CMap *MapPointer,CEntityManager *EntityPointer,CSpell *SpellPointer){	if (MapPointer->m_spell.empty())		return;	for (int i = MapPointer->m_spell.size()-1; i >= 0; i--)	{		// check if player was hit by a spell		if (CheckCollision((int)MapPointer->m_playerX,(int)MapPointer->m_playerY,(int)MapPointer->m_spell[i].x,(int)MapPointer->m_spell[i].y,TILE_SIZE))		{			// check to see if the spell was not created by player			if (MapPointer->m_spell[i].parent != -1)			{				// spell casted by enemy				int hp = EntityPointer->m_pPlayer->GetHP();				int mp = EntityPointer->m_pPlayer->GetMP();				SpellPointer->SpellHit(MapPointer->m_spell[i].imgID,MapPointer->m_spell[i].lvl,hp,mp);								EntityPointer->m_pPlayer->SetHP(hp);				EntityPointer->m_pPlayer->SetMP(mp);								MapPointer->m_spell.erase(MapPointer->m_spell.begin()+i);				continue;			}		}		//checking if an enemy has been hit by a spell		for (size_t j = 0; j < MapPointer->m_closeEnemyXY.size(); j++)		{			if (CheckCollision((int)MapPointer->m_closeEnemyXY[j].x,(int)MapPointer->m_closeEnemyXY[j].y,(int)MapPointer->m_spell[i].x,(int)MapPointer->m_spell[i].y,TILE_SIZE))			{				int hp = EntityPointer->m_VCloseEnemy[j].GetHP();				int mp = EntityPointer->m_VCloseEnemy[j].GetMP();				if (MapPointer->m_spell[i].parent == -1)				{   // spell casted by player					SpellPointer->SpellHit(MapPointer->m_spell[i].imgID,MapPointer->m_spell[i].lvl,hp,mp);				}				EntityPointer->m_VCloseEnemy[j].SetHP(hp);				EntityPointer->m_VCloseEnemy[j].SetMP(mp);								// enemies created on map must be created in the same order in EntityManager so that the same index can be used to access both				MapPointer->m_spell.erase(MapPointer->m_spell.begin()+i);								break;			}		}	}}

//handles collision for missiles and playerbool CollisionManager::PlayerMissileCollision(Player& player, EnemyMissile& missile, Explosions& explosion){	for (unsigned int i = 0; i < missile.missiles.size(); i++)	{		if (CheckCollision(player.box_1, missile.missiles[i]->box) || CheckCollision(player.box_2, missile.missiles[i]->box))		{			explosion.ExplosionHandler(player.box.x, player.box.y - 20, 2);			missile.missiles[i]->isAlive = false;			return true;		}	}	return false;}

bool CollisionManager::EnemyBulletCollisions(Enemy1Bullet& bullet, Player& player, Explosions& explosion){	//loop through the enemy bullet vector to check if any hit the player	//if the player is hit destroy the bullet and decrease player health by 1	for (unsigned int i = 0; i < bullet.enemyBullets.size(); i++)	{		if (CheckCollision(bullet.enemyBullets[i]->box, player.box_1) || CheckCollision(bullet.enemyBullets[i]->box, player.box_2))		{			explosion.ExplosionHandler(player.box.x, player.box.y - 20, 2); //this will play an explosion on the player when it gets hit			bullet.enemyBullets[i]->isAlive = false;			return true;		}	}	return false;}

void CBaseGolem::Update(float fDT){	CBaseEntity::Update(fDT);	/*if( GetFlag_prev_MovementState() == FLAG_MOVESTATE_MOVING)	{				if(this->GetFlag_MovementState() == FLAG_MOVESTATE_ATDESTINATION)		{		int objectID = MObjectManager::GetInstance()->FindLayer( this->m_nIdentificationNumber ).GetFlake( OBJECT_OBJECT ).GetInfoAtIndex( GetIndexPosX() , GetIndexPosY() ) ;		IUnitInterface* object = (MObjectManager::GetInstance()->GetUnit(objectID)) ;				CheckCollision( object , true );		}	}*/	if(( GetDistanceLeft() <= 32 && GetDistanceLeft() >= 30 ) || (GetDistanceLeft() <= 16 && GetDistanceLeft() >= 14 ) )		CSGD_FModManager::GetInstance()->PlaySound2D( m_nStepSoundID, CGamePlayState::GetInstance()->testVaribale, this->m_nIdentificationNumber) ;	//UpdateAI();	if( LastDistance > 0.0f && GetDistanceLeft() < 0.1f )	{		CheckCollision( 			MObjectManager::GetInstance()->GetUnit( 			MObjectManager::GetInstance()->FindLayer( m_nIdentificationNumber ).GetFlake( OBJECT_OBJECT ).GetInfoAtIndex( GetIndexPosX(), GetIndexPosY() ) ), true );	}	LastDistance = GetDistanceLeft();}

void GuiItem::Update(GuiElement* hover, GuiElement* focus){	//If there's no dragged_item, when clicking over the item, it's freed from the inventory	if (!(App->gui->dragged_item))	{		if (CheckCollision(App->input->GetMousePosition()))		{			//Feedback :D			inventory->SetSlotsState(this, GREEN);			mousehover = true;			if (App->input->GetMouseButtonDown(SDL_BUTTON_LEFT) == KEY_DOWN)			{				inventory->FreeItem(this);			}		}		else			mousehover = false;						}		if (App->gui->dragged_item == this)	{		mousehover = false;	}}

void UNIT::Update(float deltaTime){	//update unit animation time	m_time += deltaTime * 0.8f * m_speed;	//if the unit is moving...	if(m_moving)	{		if(m_movePrc < 1.0f)m_movePrc += deltaTime * m_speed;		if(m_movePrc > 1.0f)m_movePrc = 1.0f;				//waypoint reached		if(m_movePrc == 1.0f)		{			if(m_activeWP + 1 >= (int)m_path.size())		//goal reached			{				m_moving = false;				SetAnimation("Still");			}			else if(!CheckCollision(m_path[m_activeWP + 1])) //Next Waypoint			{							m_activeWP++;				SetAnimation("Run");				MoveUnit(m_path[m_activeWP]);			}		}		//Interpolate position between m_lastWP and m_nextWP		m_position = m_lastWP * (1.0f - m_movePrc) + m_nextWP * m_movePrc;	}}

bool CollisionManager::PlayerEnemyCollisions(EnemyShip1& enemy, Player& player, Explosions& explosion){	//check if the enemy and player collide	//if they do, destroy the enemy and decrease player health	for (unsigned int i = 0; i < enemy.enemies.size(); i++)	{		if (CheckCollision(player.box_1, enemy.enemies[i]->box_1) || CheckCollision(player.box_1, enemy.enemies[i]->box_2) || CheckCollision(player.box_2, enemy.enemies[i]->box_1) || CheckCollision(player.box_2, enemy.enemies[i]->box_2))		{			explosion.ExplosionHandler(enemy.enemies[i]->box.x, enemy.enemies[i]->box.y, 1);//add an explosion when an enemy dies			explosion.ExplosionHandler(player.box.x, player.box.y - 20, 2);			enemy.enemies[i]->isAlive = false;			return true;		}	}	return false;}

int CMonsterClubB1::DoAction(/*CScreen* scr, */IObjectManager* objMan){	mYMove= (CGTimer::Time()-oldmove)*mSpeed;	oldmove=CGTimer::Time();	int i = CheckCollision(objMan);	if(mJumpDirect==1)	{	if (GetBit(i,2)==1)	{		mJumpDirect=0;	}	else		mYPos=mYPos-mYMove;	}	if(mJumpDirect==0)	{	if (GetBit(i,3)==1)	{		return -1;	}	else		mYPos=mYPos+mYMove;	}	NextFrame();	return 1;}

// Update the skeleton transforms based on the dragger.void IvObjectDragger::UpdateSkeleton(){    ItemPtr selectedItem = GetSelectedItem();    if( !selectedItem ) {        return;    }    RaveTransform<float> tbox;    const float* q = _transformBox->rotation.getValue().getValue();    tbox.rot = Vector(q[3], q[0], q[1], q[2]);    SbVec3f v = _transformBox->translation.getValue();    tbox.trans = Vector(v[0], v[1], v[2]);    Transform told; told.trans = -_ab.pos;    RaveTransform<float> tnew = tbox*told*_toffset;    SetSoTransform(selectedItem->GetIvTransform(), tnew);    KinBodyItemPtr pbody = boost::dynamic_pointer_cast<KinBodyItem>(selectedItem);    if( !!pbody ) {        pbody->UpdateFromIv();        CheckCollision(_checkCollision);    }    // other motion handler calls    _viewer.lock()->_UpdateCameraTransform(0);}

void CPartSnowFlake::Think( float flTime ){	if( m_flBrightness < 130.0 && !m_bTouched )		m_flBrightness += 4.5;	Fade( flTime );	Spin( flTime );	if( m_flSpiralTime <= gEngfuncs.GetClientTime() )	{		m_bSpiral = !m_bSpiral;		m_flSpiralTime = gEngfuncs.GetClientTime() + UTIL_RandomLong( 2, 4 );	}	else	{	}	if( m_bSpiral && !m_bTouched )	{		const float flDelta = flTime - g_Environment.GetOldTime();		const float flSpin = sin( flTime * 5.0 + reinterpret_cast<int>( this ) );			m_vOrigin = m_vOrigin + m_vVelocity * flDelta;		m_vOrigin.x += ( flSpin * flSpin ) * 0.3;	}	else	{		CalculateVelocity( flTime );	}	CheckCollision( flTime );}

int RTPSources::GetRTCPSourceData(uint32_t ssrc, const RTPAddress *senderaddress, RTPInternalSourceData **srcdat2, bool *newsource){    int status;    bool created;    RTPInternalSourceData *srcdat;    *srcdat2 = 0;    if ((status = ObtainSourceDataInstance(ssrc, &srcdat, &created)) < 0)        return status;    if (created)    {        if ((status = srcdat->SetRTCPDataAddress(senderaddress)) < 0)            return status;    }    else // got a previously existing source    {        if (CheckCollision(srcdat, senderaddress, false))            return 0; // ignore packet on collision    }    *srcdat2 = srcdat;    *newsource = created;    return 0;}

void UpdateContent(LevelContent* m_content,SDL_Rect camera){	for (unsigned int i = 0; i < m_content->ennemies.size(); ++i)	{		m_content->ennemies.at(i).Update(m_content->tileMap);		for (unsigned int j = 0; j < m_content->bullets.size(); ++j)		{			if (CheckCollision(m_content->ennemies.at(i).GetRect(),				m_content->bullets.at(j).GetRect()))			{				m_content->bullets.erase(m_content->bullets.begin() + j);				m_content->ennemies.erase(m_content->ennemies.begin() + i);				break;			}		}	}	for (unsigned int i = 0; i < m_content->items.size(); ++i)	{		if (isOutScreen(camera, m_content->items.at(i).GetRect()))			m_content->items.erase(m_content->items.begin() + i);		else			m_content->items.at(i).Update(m_content->tileMap);		}		for (unsigned int j = 0; j < m_content->bullets.size(); ++j)	{		m_content->bullets.at(j).Update(m_content->tileMap);		if (m_content->bullets.at(j).isEnd() || isOutScreen(camera, m_content->bullets.at(j).GetRect()))			m_content->bullets.erase(m_content->bullets.begin() + j);	}	}

/** /param fDeltaTime: time since last Update */void Player::Update(shoot::f32 fDeltaTime){	super::Update(fDeltaTime);	bool bRightPressed = shoot::InputManager::Instance()->IsKeyPressed(shoot::InputManager::KT_Right);	bool bLeftPressed = shoot::InputManager::Instance()->IsKeyPressed(shoot::InputManager::KT_Left);		if(bRightPressed)	{		m_vVelocity = m_vSlidingDirection*m_fAcceleration;			}	else if(bLeftPressed)	{		m_vVelocity = m_vSlidingDirection*-m_fAcceleration;	}			bool bWasInTheAir = IsInTheAir();	if(bWasInTheAir)	{		m_vVelocity.Y += m_fGravity;	}		if(IsInTheAir() || (bRightPressed || bLeftPressed))	{		CheckCollision(m_vPosition, m_vVelocity, m_vPosition, m_vVelocity);		if(bWasInTheAir && !IsInTheAir())		{			shoot::Print("*** bWasInTheAir && !IsInTheAir()/n");		}		m_vPosition += m_vVelocity;	}	}

void UNIT::Goto(INTPOINT mp){	if(m_pTerrain == NULL)return;	//Clear old path	m_path.clear();	m_activeWP = 0;	if(m_moving)		//If unit is currently moving	{		//Finish the active waypoint 		m_path.push_back(m_mappos);		std::vector<INTPOINT> tmpPath = m_pTerrain->GetPath(m_mappos, mp);		//add new path		for(int i=0;i<(int)tmpPath.size();i++)			m_path.push_back(tmpPath[i]);	}	else		//Create new path from scratch...	{		m_path = m_pTerrain->GetPath(m_mappos, mp);				if(m_path.size() > 0)		//if a path was found		{			m_moving = true;			//Check that the next tile is free			if(!CheckCollision(m_path[m_activeWP]))			{				MoveUnit(m_path[m_activeWP]);				SetAnimation("Run");							}		}	}}

void BlockControl::HandleDown(const Uint8 *state, float frame_time, std::vector<Square> board_squares){		if (!CheckCollision(current_block.block_squares, Block::DOWN, board_squares))	{		if (state[SDL_SCANCODE_DOWN])		{						velocity = 120;		}		if (!state[SDL_SCANCODE_DOWN])		{			if (velocity == 120)			{				velocity = 60;			}		}	}}

/** * Moves the current piece to the left. */void TetraminoesManager::InnerData::MoveLeft() {    int aux = pieceX;    pieceX--;    if(CheckCollision()) {        pieceX = aux;    }}

void EnemyBase::Update(){    if(isAlive)    {        Move();        CheckCollision();    }}

// 
C++ CheckCondition函数代码示例
C++ CheckClosed函数代码示例