C++ Shot类代码示例

void GameWorld::checkCollisionVsEnemyShots(GameObject* go)
{
	Shot* shot;
	Rect goRect = go->getRectangle();

	for (int i = 0; i < m_gameObjectManager->getEnemyShotsInUse(); i++)
	{
		shot = m_gameObjectManager->getEnemyShot(i);

		// Check that the shot is on screen. If not, remove.
		shot->setActive(shot->collide(m_physicsComponent, m_cameraView));
		if (!shot->getActive())
		{
			m_gameObjectManager->removeEnemyShot(i);
			i--;
			continue;
		}

		if ( shot->collide(m_physicsComponent, goRect) )
		{
			go->Health -= shot->Damage;
			m_gameObjectManager->removeEnemyShot(i);
			i--;
			continue;
		}
	}
}

Shot*
Weapon::NetFireSecondary(SimObject* tgt, System* sub, DWORD objid)
{
    Shot* shot = 0;

    if (IsPrimary() || Game::Paused())
    return shot;

    if (active_barrel < 0 || active_barrel >= nbarrels)
    active_barrel = 0;

    target    = tgt;
    subtarget = sub;
    aim_time  = 0;

    shot = FireBarrel(active_barrel++);

    if (active_barrel >= nbarrels) {
        active_barrel = 0;
        refire += design->salvo_delay;
    }

    if (shot)
    shot->SetObjID(objid);

    if (target)
    Observe(target);

    return shot;
}

void GameWorld::checkCollisionVsPlayersShots(GameObject* go)
{
	Shot* shot;
	for (int j = 0; j < m_gameObjectManager->getPlayerShotsInUse(); j ++)
	{
		shot = m_gameObjectManager->getPlayerShot(j);

		// Check that the shot is on screen. If not, remove.
		shot->setActive(shot->collide(m_physicsComponent, m_cameraView));
		if (!shot->getActive())
		{
			m_gameObjectManager->removePlayerShot(j);
			j--;
			continue;
		}

		// check if shot hits enemy.
		if ( shot->collide(m_physicsComponent, go->getRectangle()))
		{
			go->Health -= shot->Damage;
			m_gameObjectManager->removePlayerShot(j);
			j--;
			continue;
		}
	}
}

bool simulateShot(fastfiz_msgs::SimulateShotRequest& req, fastfiz_msgs::SimulateShotResponse& res)
{
  TableState ts = msgToFiz(req.state);
  ShotParams shot = msgToFiz(req.shot);
  Shot* s = ts.executeShot(shot, false, false);

  typedef std::vector<Event*> V_Event;
  const V_Event& events = s->getEventList();
  V_Event::const_iterator it = events.begin();
  V_Event::const_iterator end = events.end();
  for (; it != end; ++it)
  {
    Event* e = *it;
    fastfiz_msgs::Event event;
    event.type = e->getType();
    event.ball1 = fizToMsg(e->getBall1());
    event.ball2 = fizToMsg(e->getBall2());
    event.string_rep = e->toString();

    res.events.push_back(event);
  }

  delete s;

  res.state = fizToMsg(ts);

  return true;
}

void GamePage::MoveShots(list<Shot> &shotsList)
{
	list<Shot>::iterator it = shotsList.begin();

	while (it != shotsList.end())
	{
		if (it->IsPossibleToMove())
		{
			it->Move(this->m_counter);
			it++;
		}
		else
		{
			if (g_pScreen->GetObjectAt(it->GetNextX(), it->GetNextY()) == OBJECT_TYPE_SHOT)
			{
				Shot *s = this->GetShotAt(it->GetNextX(), it->GetNextY());
				
				if (s->GetLastMove() == this->m_counter)
				{
					it++;
					continue;
				}
			}

			this->RemoveObject(it->GetNextX(), it->GetNextY());

			list<Shot>::iterator temp = it;
			it++;

			temp->Clear();
			shotsList.erase(temp);
		}
	}
}

void Game::sonicDeflectorEffect() {
  for ( unsigned int i = 0; i < racers->getNrRacers(); i++) {
    if ( racers->getRacer(i)->getShipType() == LIGHT_FIGHTER ) {
      Shot* nearestRocket = shots->getNearestRocket( racers->getRacer(i)->getPos() );
      // a rocket exists and it is in range of the sonic
      if ( nearestRocket != NULL &&
        (nearestRocket->getPos() - racers->getRacer(i)->getPos()).getLength() < 
        RACER_SONIC_ACTIVATION_DIST ) {
        // activate the correct sonic
        if (i == 0) {
          sonic1->setPos( racers->getRacer(i)->getPos(), nearestRocket->getPos() );
          nearestRocket->deflectedBySonicFromPlayer1 = true;
        } else {
          sonic2->setPos( racers->getRacer(i)->getPos(), nearestRocket->getPos() );
          nearestRocket->deflectedBySonicFromPlayer2 = true;
        }
      // no rocket is in sonic-range
      } else {
        // deactivate the sonic
        if (i == 0) {
          sonic1->setActive( false );
        } else {
          sonic2->setActive( false );
        }
      }
    }
  }
}

void
Dissolve::postComplete(Shot& initialShot, Shot& finalShot)
{
  initialShot.getCamera()._alpha = UNITY;
  finalShot.getCamera()._alpha = UNITY;
  _timeElapsed = ZERO;
  _timeStarted = ZERO;
}

void Troop::AllAct() {
  Shot *tmpsh;
  tmpsh->AllAct();
  int ctr=0;
  for(ctr=0; ctr<maxtr; ++ctr) if (trp[ctr] != NULL) {
    trp[ctr]->Act();
    }
  }

void Troop::DeleteAll() {
  Shot *tmpsh;
  tmpsh->DeleteAll();
  int ctr=0;
  for(ctr=0; ctr<maxtr; ++ctr) if (trp[ctr] != NULL) {
    delete trp[ctr];
    }
  }

void
NetGameClient::DoWepRelease(NetMsg* msg)
{
	if (!msg) return;

	NetWepRelease release;
	release.Unpack(msg->Data());

	NetPlayer* player = FindPlayerByObjID(release.GetObjID());
	if (player) {
		player->DoWepRelease(&release);
	}

	else {
		Ship* shooter = FindShipByObjID(release.GetObjID());
		if (shooter) {
			int   index = release.GetIndex();
			DWORD tgtid = release.GetTgtID();
			DWORD wepid = release.GetWepID();
			int   subid = release.GetSubtarget();
			bool  decoy = release.GetDecoy();
			bool  probe = release.GetProbe();

			Weapon* w = 0;

			if (decoy)        w = shooter->GetDecoy();
			else if (probe)   w = shooter->GetProbeLauncher();
			else              w = shooter->GetWeaponByIndex(index);

			if (w && !w->IsPrimary()) {
				SimObject*  target = FindShipByObjID(tgtid);
				System*     subtgt = 0;

				if (target) {
					if (subid >= 0) {
						Ship* tgt_ship = (Ship*) target;
						subtgt = tgt_ship->Systems().at(subid);
					}
				}
				else {
					target = FindShotByObjID(tgtid);
				}

				Shot* shot = w->NetFireSecondary(target, subtgt, wepid);

				if (shot && shot->IsDrone()) {
					if (probe)
					shooter->SetProbe((Drone*) shot);

					else if (decoy)
					shooter->AddActiveDecoy((Drone*) shot);
				}
			}
		}
	}
}

	void ManagerModel::AddShot(Vec2 startPosition) {
		Shot *shot = DBG_NEW Shot();
		shot->startPosition = startPosition;
		shot->OnInit(this);
		mEntities.push_back(shot);

		for (auto *view : mViews) {
			view->OnShotSpawned((Shot*)shot);
			view->PlayShotSoundEffect((Shot*)shot);
		}
	}

void Shooter::update() {
    //rand()
    if(mFrame %(mSpeed) == 0) {
        Shot* ms = new Shot();
        ms->setShotType(Shot::ShotType_Fireball);
        ms->setInitialVelocity(float2(0.f,mInitialVelocity[Shot::ShotType_Fireball].y));
        ms->setPosition(getPosition());
        mRoom->addEntity(ms);
    }

    mFrame++;
}

bool
NetPlayer::DoWepRelease(NetWepRelease* release)
{
	if (ship && release) {
		int   index = release->GetIndex();
		DWORD tgtid = release->GetTgtID();
		DWORD wepid = release->GetWepID();
		int   subid = release->GetSubtarget();
		bool  decoy = release->GetDecoy();
		bool  probe = release->GetProbe();

		Weapon* w = 0;

		if (decoy)        w = ship->GetDecoy();
		else if (probe)   w = ship->GetProbeLauncher();
		else              w = ship->GetWeaponByIndex(index);

		if (w && !w->IsPrimary()) {
			SimObject*  target = 0;
			System*     subtgt = 0;

			NetGame* net_game = NetGame::GetInstance();
			if (net_game) {
				target = net_game->FindShipByObjID(tgtid);

				if (target) {
					if (subid >= 0) {
						Ship* tgt_ship = (Ship*) target;
						subtgt = tgt_ship->Systems().at(subid);
					}
				}
				else {
					target = net_game->FindShotByObjID(tgtid);
				}
			}

			Shot* shot = w->NetFireSecondary(target, subtgt, wepid);

			if (shot && shot->IsDrone()) {
				if (probe)
				ship->SetProbe((Drone*) shot);

				else if (decoy)
				ship->AddActiveDecoy((Drone*) shot);
			}

			return true;
		}
	}

	return false;
}

void
NetGameClient::DoObjDamage(NetMsg* msg)
{
	if (!msg) return;

	NetObjDamage obj_damage;
	obj_damage.Unpack(msg->Data());

	Ship* ship = FindShipByObjID(obj_damage.GetObjID());
	if (ship) {
		Sim*        sim         = Sim::GetSim();
		Shot*       shot        = FindShotByObjID(obj_damage.GetShotID());
		const Ship* owner       = 0;
		const char* owner_name  = "[NET]";

		ship->InflictNetDamage(obj_damage.GetDamage(), shot);

		if (shot && sim) {
			if (shot->Owner()) {
				owner       = shot->Owner();
				owner_name  = owner->Name();
			}

			if (shot->IsMissile()) {
				SimRegion*  region = ship->GetRegion();
				float       scale  = ship->Design()->explosion_scale;

				if (scale <= 0)
				scale = ship->Design()->scale;

				if (owner) {
					const ShipDesign* owner_design = owner->Design();
					if (owner_design && owner_design->scale < scale)
					scale = (float) owner_design->scale;
				}

				sim->CreateExplosion(shot->Location(), Point(), Explosion::SHOT_BLAST, 20.0f * scale, scale, region);
			}

			if (!shot->IsBeam()) {
				if (owner) {
					ShipStats* stats = ShipStats::Find(owner_name);

					if (stats) {
						if (shot->IsPrimary())
						stats->AddGunHit();
						else if (shot->Damage() > 0)
						stats->AddMissileHit();
					}
				}

				shot->Destroy();
			}
		}
	}
}

void
NetGameClient::DoWepDestroy(NetMsg* msg)
{
	if (!msg) return;

	NetWepDestroy destroy;
	destroy.Unpack(msg->Data());

	Shot* shot = FindShotByObjID(destroy.GetObjID());
	if (shot) {
		if (shot->IsBeam())
		::Print("NetGameClient::DoWepDestroy shot '%s'\n", shot->Name());

		shot->Destroy();
	}
}