C++ Explosion类代码示例

HitResponse
Brick::collision(GameObject& other, const CollisionHit& hit_){

  Player* player = dynamic_cast<Player*> (&other);
  if (player) {
    if (player->does_buttjump) try_break(player);
  }

  BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
  if(badguy) {
    // hit contains no information for collisions with blocks.
    // Badguy's bottom has to be below the top of the brick
    // SHIFT_DELTA is required to slide over one tile gaps.
    if( badguy->can_break() && ( badguy->get_bbox().get_bottom() > get_bbox().get_top() + SHIFT_DELTA ) ){
      try_break(player);
    }
  }
  Portable* portable = dynamic_cast<Portable*> (&other);
  if(portable) {
    MovingObject* moving = dynamic_cast<MovingObject*> (&other);
    if(moving->get_bbox().get_top() > get_bbox().get_bottom() - SHIFT_DELTA) {
      try_break(player);
    }
  }
  Explosion* explosion = dynamic_cast<Explosion*> (&other);
  if(explosion && explosion->hurts()) {
    try_break(player);
  }
  return Block::collision(other, hit_);
}

llvm::Constant *IRGenModule::getOrCreateOutlinedDestroyFunction(
                              SILType T, const TypeInfo &ti,
                              const OutliningMetadataCollector &collector) {
  IRGenMangler mangler;
  auto manglingBits = getTypeAndGenericSignatureForManglingOutlineFunction(T);
  auto funcName = mangler.mangleOutlinedDestroyFunction(manglingBits.first,
                                                        manglingBits.second);

  auto ptrTy = ti.getStorageType()->getPointerTo();
  llvm::SmallVector<llvm::Type *, 4> paramTys;
  paramTys.push_back(ptrTy);
  collector.addMetadataParameterTypes(paramTys);

  return getOrCreateHelperFunction(funcName, ptrTy, paramTys,
      [&](IRGenFunction &IGF) {
        Explosion params = IGF.collectParameters();
        Address addr = ti.getAddressForPointer(params.claimNext());
        collector.bindMetadataParameters(IGF, params);

        ti.destroy(IGF, addr, T, true);
        
        IGF.Builder.CreateRet(addr.getAddress());
      },
      true /*setIsNoInline*/);
}

void
Game::SpawnExplosion(int x, int y)
{
	Explosion* explosion = new Explosion();
	explosion->SetPositionX(x - 10);
	explosion->SetPositionY(y - 10);



	AnimatedSprite* exploding = m_pBackBuffer->CreateAnimatedSprite("assets\\explosion.png");
	exploding->SetLooping(false);
	exploding->SetFrameWidth(64);
	exploding->SetFrameSpeed(0.05);
	exploding->AddFrame(0);
	exploding->AddFrame(64);
	exploding->AddFrame(128);
	exploding->AddFrame(192);
	exploding->AddFrame(256);




	explosion->Initialise(exploding);

	Explosions.push_back(explosion);
}

		static void ExplosionActivate(unsigned int aId)
		{
			const ExplosionTemplate &explosiontemplate = Database::explosiontemplate.Get(aId);
			Explosion *explosion = new Explosion(explosiontemplate, aId);
			Database::explosion.Put(aId, explosion);
			explosion->Activate();
		}

Explosion* Level::createExplosion( Vec2f const& pos , float raidus )
{
	Explosion* e = new Explosion( pos , raidus );
	e->init();
	addObjectInternal( e );
	return e;
}

Object					*Explosion::clone(SerializedObject *serializedObject)
{
	Explosion			*newObject = new Explosion(this->explosionType, this->geometry->getPosition());

	newObject->setValues(serializedObject);
	return (newObject);
}

Explosion* Explosion::create()
{
	Explosion* boom = new Explosion();
	boom->init();
	
	return boom;
}

void CDestructibleModel::RegisterDestroyedStimulus()
{
	// Register audio and visual stimulus if specified.

	if( (m_nDestroyAlarmLevel > 0) && (m_fStimRadius > 0.f) )
	{
		LTVector vPos;
		g_pLTServer->GetObjectPos(m_hObject, &vPos);

		// Extract who caused an explosion.

		HOBJECT hDamager = m_hLastDamager;
		if( IsExplosion( hDamager ) )
		{
			Explosion* pExplosion = (Explosion*)g_pLTServer->HandleToObject(m_hLastDamager);
			hDamager = pExplosion->GetFiredFrom();
		}

		// If damager is still not a character (possibly because an explosion was triggered), assume player.
		// Better solution - set the alignment of the damager on the explosion?

		if( !IsCharacter( hDamager ) )
		{
			CPlayerObj *pPlayer = g_pCharacterMgr->FindPlayer();
			if ( pPlayer )
			{
				hDamager = pPlayer->m_hObject;
			}
		}

		g_pAIStimulusMgr->RegisterStimulus( kStim_EnemyDisturbanceSound, m_nDestroyAlarmLevel, hDamager, m_hObject, vPos, m_fStimRadius );
		m_eStimID = g_pAIStimulusMgr->RegisterStimulus( kStim_EnemyDisturbanceVisible, m_nDestroyAlarmLevel + 1, hDamager, m_hObject, vPos, m_fStimRadius );
	}
}

static void emitTypeTraitBuiltin(IRGenFunction &IGF,
                                 Explosion &out,
                                 Explosion &args,
                                 SubstitutionList substitutions,
                                 TypeTraitResult (TypeBase::*trait)()) {
  assert(substitutions.size() == 1
         && "type trait should have gotten single type parameter");
  args.claimNext();
  
  // Lower away the trait to a tristate 0 = no, 1 = yes, 2 = maybe.
  unsigned result;
  switch ((substitutions[0].getReplacement().getPointer()->*trait)()) {
  case TypeTraitResult::IsNot:
    result = 0;
    break;
  case TypeTraitResult::Is:
    result = 1;
    break;
  case TypeTraitResult::CanBe:
    result = 2;
    break;
  }

  out.add(llvm::ConstantInt::get(IGF.IGM.Int8Ty, result));
}

void
Game::SpawnExplosion(int x, int y)
{
	Sprite* aS = m_pBackBuffer->CreateSprite("assets\\explosion.png");
	// create an explosion object
	Explosion* explosion = new Explosion();

	// initialize the texture
	if (!explosion->Initialise(*aS->GetTexture())) {
		LogManager::GetInstance().Log("Explosion Init Fail!");
		return;
	}

	
	// set the width and speed of the animation
	int fw = aS->GetWidth() / 5;
	explosion->SetFrameWidth(fw);	// 5 frames in the animation
	explosion->SetFrameSpeed(0.1f);
	for (int i = 0; i < 5; i++) {
		explosion->AddFrame(i * fw);
	}

	// set the center points for visual alignment
	explosion->SetCenter(fw / 2, aS->GetHeight() / 2);

	// set the x and y
	explosion->SetX(x - explosion->GetCenterX() / 2);
	explosion->SetY(y - explosion->GetCenterY() / 2);
	
	// add to the explosion container
	m_explosion.push_back(explosion);

}

void Player::PlayerHitByBall(Game_Scene* game, Ball* ball)
{
	if (!_invincible)
	{
		//get hit
		_timeSinceHit = 0.0f;
		//daze only if not dazed too recently
		if (_stunLockTimer >= Settings::playerDazeInvincibilityTime)
		{
			_stunLockTimer = 0;
			if (ball->getType() == OilBall::type)
			{
				_sprite->setColor(_oilColour);
				Daze(true);
			}
			else if (ball->getType() == BombBall::type || ball->getType() == BombOther::type)
			{
				Daze(true);
			}
			else if (game->GetBallHitter(ball)->HasDoubleAttack())
			{
				Daze(true);
			}
			else
			{
				Daze(false);
			}
		}
		if (ball->getType() == BombOther::type)
		{
			((Game_Scene*)(this->getParent()->getParent()))->SeeSaw(this, -4);

			Explosion* boomImage;
			boomImage = Explosion::create();
			ball->getParent()->addChild(boomImage);

			boomImage->setPosition(ball->getParent()->convertToWorldSpace(ball->getPosition()));
			((Game_Scene*)(ball->getParent()->getParent()))->DestroyAndDropBall(ball);

			AudioHelper::Play("bombball");
		}
		else if (ball->getType() == BombBall::type)
		{

			AudioHelper::Play("selfexplode");
		}
		else if (ball->getType() == OilBall::type)
		{
			AudioHelper::PlayRandom("Oilball", 3);
		}
		else if (ball->getType() == RocketBall::type)
		{
			AudioHelper::Play("missilehit");
		}
		AudioHelper::PlayRandom("Au", 4, (0.5 + rand_0_1() * 1.5));
	}
}

void MultiPartEntity::Part::onDestroy()
{
    m_parent->onPartDestroyed(*this);

    Explosion* explosion = new Explosion;
    sf::Vector2f pos = m_parent->getPosition() + getCenter();
    explosion->setPosition(pos);
    EntityManager::getInstance().addEntity(explosion);
}

void ExplosionPool::explode(const Point3d& pos, const Point3d& vel){
	if(freeList.empty()){
		explosionList.push_back(new Explosion("explostion", pos, vel));
	}else
	{
		Explosion* e = freeList.front();
		freeList.pop_front();
		e->set(pos, vel, 7000);
		explosionList.push_back(e);
	}
}

static void emitCastBuiltin(IRGenFunction &IGF, SILType destType,
                            Explosion &result,
                            Explosion &args,
                            llvm::Instruction::CastOps opcode) {
  llvm::Value *input = args.claimNext();
  assert(args.empty() && "wrong operands to cast operation");

  llvm::Type *destTy = IGF.IGM.getStorageType(destType);
  llvm::Value *output = IGF.Builder.CreateCast(opcode, input, destTy);
  result.add(output);
}

void GameManager::CheckCollide(Collider* collider, Vector<Target*>& targets)
{
	bool isCollisionChecked = false; //현재 충돌중인 타겟이 있는지 체크 -> lastTarget을 유지할 필요가 있는지 체크

	for (Target* target : targets)
	{
		if (collider->IsBullet())
		{
			Bullet* bullet = static_cast<Bullet*>(collider);
			
			if (IsCollision(target, bullet))
			{
				isCollisionChecked = true;

				if (bullet->m_currentCollidingTarget == target)
				{
					continue;
				}

				target->ApplyCollisionEffect(collider);
				bullet->m_currentCollidingTarget = target;

				if (target->IsMirror())
				{
					break;
				}
			}
		}
		else
		{
			Explosion* explosion = static_cast<Explosion*>(collider);
			const float explosionRadius = explosion->GetBoundingRadius();
			const Vec2 explosionPosition = explosion->getPosition();
			const Rect targetBoundingBox = target->GetBoundingArea();

			if ( targetBoundingBox.intersectsCircle( explosionPosition, explosionRadius) )
			{
				target->ApplyCollisionEffect(explosion);
			}
		}
	} //for문 끝

	if (!isCollisionChecked)
	{
		if (collider->IsBullet())
		{
			Bullet* bullet = static_cast<Bullet*>(collider);
			if (bullet != nullptr)
			{
				bullet->m_currentCollidingTarget = nullptr;
			}
		}
	}
}