SpaceShooter::SpaceShooter()
{
Renderer::Get().Initialize();
// Create the player's view.
Quaternion viewRotation( Vector3::Right, Pi / 2.f );
mCamera = ViewPtr( new View( Vector3( 0.f, 60.f, 0.f ), viewRotation, 1.04719755f, 1920.0f / 1080.0f, 0.1f, 100.f, false ) );
Renderer::Get().SetCamera( mCamera );
// Create the background.
MaterialPtr backgroundMaterial = MaterialPtr( new Material( L"Resources\\Shaders\\tangent.hlsl", L"Resources\\Textures\\starfield.dds" ) );
RawMeshPtr backgroundMesh = RawMeshPtr( new RawMesh() );
GenerateQuadVerticies( *backgroundMesh.get(), 90.f, 45.f );
MeshPrimitivePtr background = MeshPrimitivePtr( new MeshPrimitive( backgroundMesh, backgroundMaterial, GetTangentSpaceVertexSource() ) );
mBackground = GameObjectPtr( new GameObject( background ) );
Matrix4 backgroundOffset;
backgroundOffset.CreateFromQuaternion( Quaternion( Vector3::Right, Pi / 2.f ) );
mBackground->SetOffset( backgroundOffset );
mBackground->SetTranslation( Vector3( 0.f, -10.f, 0.f ) );
mBackground->Attach();
// Load the player's ship.
MaterialPtr playerShipMaterial = MaterialPtr( new Material( L"Resources\\Shaders\\tangent.hlsl", L"Resources\\Textures\\frigate.dds" ) );
RawMeshPtr shipMesh = RawMeshPtr( new RawMesh() );
LoadMeshFromObjFile( "Resources\\Meshes\\frigate_normal.obj", *shipMesh.get() );
CalculateTangents( *shipMesh.get() );
MeshPrimitivePtr player = MeshPrimitivePtr( new MeshPrimitive( shipMesh, playerShipMaterial, GetTangentSpaceVertexSource() ) );
mPlayerObject = PlayerShipPtr( new PlayerShip( player ) );
mPlayerObject->SetScale( 0.3f );
mPlayerObject->SetBounds( 6.5f );
Matrix4 playerOffset;
playerOffset.CreateFromQuaternion( Quaternion( Vector3::Up, Pi / 2.f ) );
mPlayerObject->SetOffset( playerOffset );
mPlayerObject->SetFrictionFactor( 0.5f );
mPlayerObject->Attach();
// Load asteroids
MaterialPtr asteroidMaterial = MaterialPtr( new Material( L"Resources\\Shaders\\tangent.hlsl", L"Resources\\Textures\\asteroid.dds" ) );
RawMeshPtr asteroidMesh = RawMeshPtr( new RawMesh() );
LoadMeshFromObjFile( "Resources\\Meshes\\asteroid1.obj", *asteroidMesh.get() );
CalculateTangents( *asteroidMesh.get() );
for ( int i = 0; i < 5; i++ )
{
MeshPrimitivePtr asteroid = MeshPrimitivePtr( new MeshPrimitive( asteroidMesh, asteroidMaterial, GetTangentSpaceVertexSource() ) );
GameObjectPtr newAsteroid = GameObjectPtr( new Asteroid( asteroid ) );
newAsteroid->SetScale( 1.f );
newAsteroid->SetBounds( 4.f );
newAsteroid->SetTranslation( Vector3( RandomFloat( -40.f, 40.f ), 0.f, RandomFloat( -40.f, 40.f ) ) );
mAsteroids.push_back( newAsteroid );
newAsteroid->Attach();
}
// Load the player's jet particles.
playerJetParticles = ParticleSystemPtr( new ParticleSystem() );
ParticleSystemLoader loader;
loader.LoadFromFile( "Resources\\ParticleSystems\\jet_fuel.part", playerJetParticles );
playerJetParticles->SetEmitterState( false ); // turn the particles off to start with
Renderer::Get().AddTranslucentPrimitive( playerJetParticles );
}
GameObjectPtr GameObjectPtr::fromUserString(const QString &string) {
if (string == "0") {
return GameObjectPtr();
}
QStringList components = string.split(':');
if (components.length() != 2) {
throw GameException(GameException::InvalidGameObjectPointer);
}
return GameObjectPtr(Realm::instance(), GameObjectType::fromString(components[0]),
components[1].toInt());
}
GameObject::~GameObject() {
DEBUG_M("Entering deconstructor...");
if(area_) {
area_->removeObject(GameObjectPtr(this));
}
DEBUG_M("Exiting deconstructor...");
}
GameObject *Scene::CreateGameObject(std::string name) {
GameObject *object = new GameObject(name);
object->RenderPipeline(_renderPipeline.get());
object->ObjectSearch(this);
object->GlobalDispatcher(&_globalDispatcher);
_objectsToAdd.push_back(std::move(GameObjectPtr(object)));
return object;
}
GameObjectPtr NetworkManager::GetGameObject( uint32_t inNetworkId ) const
{
auto gameObjectIt = mNetworkIdToGameObjectMap.find( inNetworkId );
if ( gameObjectIt != mNetworkIdToGameObjectMap.end() )
{
return gameObjectIt->second;
}
else
{
return GameObjectPtr();
}
}
GameObjectPtr CLevel::GetObjByName( CIwStringS name ) const
{
GameObjectsContainer::const_iterator it = mObjs.begin(), ite = mObjs.end();
for(; it != ite; it++ )
{
if ( (*it)->GetName() == name )
{
return *it;
}
}
return GameObjectPtr();
}
GameObjectPtr CLevel::HitTest( int32 x, int32 y, bool isIgnoreInactive )
{
GameObjectsContainer::const_reverse_iterator it = mObjs.rbegin(), ite = mObjs.rend();
for (; it != ite; it++ )
{
if ( ((*it)->IsActive() || !isIgnoreInactive) && (*it)->IsHitTest(x, y) )
{
return *it;
}
}
return GameObjectPtr();
}
GameObjectPtr Tpl_SkyLight::CreateGameObject()
{
GameObjectPtr pObj = m_pManager->CreateGameObject("Sky Light");
GameObjectComponentPtr pLight = m_pManager->CreateComponent("SkyLight");
if(false == pObj->AddComponent(pLight))
{
pObj->Clear();
pObj.reset();
return GameObjectPtr();
}
return pObj;
}
void GOCPlayerInput::SetActive(bool active)
{
if (active)
{
QuitAllNewsgroups();
JoinNewsgroup(GlobalMessageIDs::KEY_DOWN);
//JoinNewsgroup(GlobalMessageIDs::KEY_UP);
JoinNewsgroup(GlobalMessageIDs::MOUSE_MOVE);
JoinNewsgroup(GlobalMessageIDs::UPDATE_PER_FRAME);
}
mActive = active;
GameObjectPtr owner = mOwnerGO.lock();
if (mActive && owner.get())
SceneManager::Instance().RegisterPlayer(owner);
else SceneManager::Instance().RegisterPlayer(GameObjectPtr());
}
virtual void Execute(const DataObject &object)
{
wxASSERT(1 <= object.numItems());
wxInt32 player = current();
if(2 <= object.numItems())
{
player = object.read<wxInt32>(1);
}
//first, determine the tile and corner being built on
wxInt32 tile, corner;
boost::tie(tile, corner) = Utility::decodeSel(object.read<wxInt32>());
PlayerGame &playergame(playerGame(player));
ColorType color = playergame.color();
wxInt32 turn = gameData<wxInt32>(shTurn);
//now create the settlement object for this player and add it to their
//list
CornerObjectPtr settlement(CornerObjectPtr(new SettlementObject(
player, turn, color, GetGame(), tile, corner)));
playergame.addCornerObject(shSettlements, settlement);
//subtract one from the player's stock settlements
playerGameData<wxInt32>(shStockSettlements, player) -= 1;
//send it to the view
AggregatorObjectPtr aggregate(new AggregatorObject);
aggregate->add(settlement);
Controller::get().Transmit(shEventGameObjects, aggregate);
// Run an animation if needed.
RULE.Execute(shRuleAnimatePlacement, DataObject(playergame.player(),
GameObjectPtr(settlement), color));
// Adjust stats.
RULE.Execute(shRulePurchaseItem, DataObject(current(), shSettlement));
// Add one point to the player's score.
RULE.Execute(shRuleAdjustPoints, DataObject(player, 1));
}
GameObjectPtr SceneManager::GetObjectByInternID(int id)
{
auto i = mGameObjects.find(id);
if (i != mGameObjects.end()) return i->second;
return GameObjectPtr();
}
void PlatformGenerator::addObjectsToPlatform(Platform& p, const Engine& e)
{
// Some constants
const int MaxYounglingClusters = 4;
const int MinYounglingClusters = 2;
const int MaxYounglingsInCluster = 3;
const int MinYounglingsInCluster = 3;
if(p.x() > m_minBlockLength * 16) // don't add objects to the very first platform
{
// Add younglings.
// Younglings come in groups of 1, 2 or 3.
// There can be up to 4 groups of younglings on one platform
// There's at least two groups on each platform.
// They are positioned randomly.
int clusters = MinYounglingClusters + rand() % (MaxYounglingClusters - MinYounglingClusters + 1);
GameObjectPtr next_youngling(new Youngling(e, 0, 0));
int max_cluster_width = next_youngling -> width() * MaxYounglingsInCluster;
int yng_x = rand() % (p.width() - max_cluster_width); // X coordinate offset from the start of the platform
int yng_y = p.y() - next_youngling -> height(); // Y coordinate
// Place groups one after another, leaving some space between them.
// If we exceed the length of the platform, wrap around.
for(int c = 0; c < clusters; ++c) // Generate younglings for each group
{
int yng_count = MinYounglingsInCluster + rand() % (MaxYounglingsInCluster - MinYounglingsInCluster + 1);
yng_x = (yng_x + max_cluster_width) % (p.width() - max_cluster_width);
// Place each youngling in the group
for(int c = 0; c < yng_count; ++c)
{
next_youngling.reset(new Youngling(e, p.x() + yng_x, yng_y));
p.addObject(GameObjectPtr(next_youngling));
yng_x += next_youngling -> width();
}
}
// Add meanies.
// Meanies come in the following combinations:
// a single Walker
// a single Jumper
// Jumper - Walker
// Jumper - Flyer
// Walker - Flyer
int r = rand() % 5;
switch(r)
{
case 0:
p.addObject(GameObjectPtr(new MeanWalker(e, p.x() + 16, p.y() - 9, p.x(), p.x() + p.width())));
break;
case 1:
p.addObject(GameObjectPtr(new MeanJumper(e, p.x() + p.width()/2, p.y() - 10, p.x(), p.x() + p.width())));
break;
case 2:
p.addObject(GameObjectPtr(new MeanWalker(e, p.x() + 16, p.y() - 9, p.x(), p.x() + p.width())));
p.addObject(GameObjectPtr(new MeanJumper(e, p.x() + p.width()/2, p.y() - 10, p.x(), p.x() + p.width())));
break;
case 3:
p.addObject(GameObjectPtr(new MeanFlyer(e, p.x() + p.width()/4, p.y() - 32, p.x(), p.x() + p.width())));
p.addObject(GameObjectPtr(new MeanWalker(e, p.x() + 16, p.y() - 9, p.x(), p.x() + p.width())));
break;
case 4:
p.addObject(GameObjectPtr(new MeanFlyer(e, p.x() + p.width()/4, p.y() - 32, p.x(), p.x() + p.width())));
p.addObject(GameObjectPtr(new MeanJumper(e, p.x() + p.width()/2, p.y() - 10, p.x(), p.x() + p.width())));
break;
}
// Add a heart with 1/3 probability
if(rand() % 3 == 0)
{
p.addObject(GameObjectPtr(new Heart(e, p.x() + rand() % p.width(), p.y() - (16 + rand() % 5))));
}
}
}
GameObjectPtr GameObjectManager::find_object(std::string const& name) const {
ObjectNameMap::const_iterator entry_itr = _objects_by_name.find(name);
return (entry_itr != _objects_by_name.end()) ? entry_itr->second : GameObjectPtr(0);
}
inline void GameObject::remove_dependency(GameObjectPtr const& dependency) {
_manager->remove_object_dependency(GameObjectPtr(this), dependency);
}
inline void GameObject::add_dependency(GameObjectPtr const& dependency) {
_manager->add_object_dependency(GameObjectPtr(this), dependency);
}
GameObjectPtr GameEngine::CreateGameObject() {
GameObjectPtr tmp = GameObjectPtr(new GameObject());
_objects[tmp->GetGuid()] = tmp;
return tmp;
}