bool Team::isCapturing(GameObjectWatchID targetWID, GameObjectWatchID exceptWID) { if(exceptWID) for(size_t i = 0; i < rosterSize; i++) { if(roster[i] == exceptWID) continue; MoverPtr mover = dynamic_cast<MoverPtr>(ObjectManager->getByWatchID(roster[i])); Assert(mover != nullptr, roster[i], " Team.isTargeting: nullptr mover "); MechWarriorPtr pilot = mover->getPilot(); if(pilot && (pilot->getCurTacOrder()->code == TACTICAL_ORDER_CAPTURE)) { GameObjectPtr target = pilot->getCurTacOrder()->getTarget(); if(target && (target->getWatchID() == targetWID)) return(true); } } else for(size_t i = 0; i < rosterSize; i++) { MoverPtr mover = dynamic_cast<MoverPtr>(ObjectManager->getByWatchID(roster[i])); Assert(mover != nullptr, roster[i], " Team.isTargeting: nullptr mover "); MechWarriorPtr pilot = mover->getPilot(); if(pilot && (pilot->getCurTacOrder()->code == TACTICAL_ORDER_CAPTURE)) { GameObjectPtr target = pilot->getCurTacOrder()->getTarget(); if(target && (target->getWatchID() == targetWID)) return(true); } } return(false); }
/// Perform a non-blocking attempt to sync with an asynchronous shader variant load request. /// /// @param[in] loadId Load request ID. /// @param[out] rspVariant Smart pointer set to the variant reference if loading has completed. /// /// @return True if loading has completed, false if not. Note that if this returns true, the load request ID will /// no longer be valid for its current load request and should not be reused. /// /// @see BeginLoadVariant() bool Shader::TryFinishLoadVariant( size_t loadId, ShaderVariantPtr& rspVariant ) { HELIUM_ASSERT( IsValid( loadId ) ); // Use the try-finish-load override if one is registered. if( sm_pTryFinishLoadVariantOverride ) { bool bFinished = sm_pTryFinishLoadVariantOverride( sm_pVariantLoadOverrideData, loadId, rspVariant ); return bFinished; } // Attempt to sync the object load request. GameObjectLoader* pObjectLoader = GameObjectLoader::GetStaticInstance(); HELIUM_ASSERT( pObjectLoader ); GameObjectPtr spObject; bool bFinished = pObjectLoader->TryFinishLoad( loadId, spObject ); if( bFinished ) { rspVariant = Reflect::AssertCast< ShaderVariant >( spObject.Get() ); } return bFinished; }
GameObjectPtr ObjectType::createInstance(void) { GameObjectPtr result = new GameObject; result->init(true, this); //result->setIdNumber(NextIdNumber++); return(result); }
GameObjectPtr SceneManager::CreateGameObject() { GameObjectPtr object = std::make_shared<GameObject>(); object->SetWeakThis(std::weak_ptr<GameObject>(object)); mGameObjects.insert(std::make_pair<int, GameObjectPtr>(object->GetID(), object)); return object; }
void GameObjectManager::remove_object(GameObjectPtr const& object) { assert((object != 0) && (object->get_manager() == this)); // make sure object is removed from reset list ObjectContainer::iterator reset_itr = std::remove(_objects_to_reset.begin(), _objects_to_reset.end(), object.p()); _objects_to_reset.erase(reset_itr, _objects_to_reset.end()); // remove the object from the dependency graph ObjectNodeMap::iterator node_entry_itr = _object_nodes.find(object.p()); // remove dependency edges from object's dependents ObjectContainer& dependents = node_entry_itr->second.dependents; for (ObjectContainer::iterator object_itr = dependents.begin(), object_end_itr = dependents.end(); object_itr != object_end_itr; ++object_itr) { ObjectNodeMap::iterator entry_itr = _object_nodes.find(*object_itr); ObjectContainer::iterator dependency_itr = std::remove(entry_itr->second.dependencies.begin(), entry_itr->second.dependencies.end(), object.p()); entry_itr->second.dependencies.erase(dependency_itr, entry_itr->second.dependencies.end()); } // remove dependent edges from object's dependencies ObjectContainer& dependencies = node_entry_itr->second.dependencies; for (ObjectContainer::iterator object_itr = dependencies.begin(), object_end_itr = dependencies.end(); object_itr != object_end_itr; ++object_itr) { ObjectNodeMap::iterator entry_itr = _object_nodes.find(*object_itr); ObjectContainer::iterator dependent_itr = std::remove(entry_itr->second.dependents.begin(), entry_itr->second.dependents.end(), object.p()); entry_itr->second.dependents.erase(dependent_itr, entry_itr->second.dependents.end()); } _object_nodes.erase(node_entry_itr); _objects_by_name.erase(object->get_name()); _objects_need_sorting = true; object->_manager = 0; }
/// Recursive function for resolving a package request. /// /// @param[out] rspPackage Resolved package. /// @param[in] packagePath Package object path. void CachePackageLoader::ResolvePackage( GameObjectPtr& rspPackage, GameObjectPath packagePath ) { HELIUM_ASSERT( !packagePath.IsEmpty() ); rspPackage = GameObject::FindObject( packagePath ); if( !rspPackage ) { GameObjectPtr spParent; GameObjectPath parentPath = packagePath.GetParent(); if( !parentPath.IsEmpty() ) { ResolvePackage( spParent, parentPath ); HELIUM_ASSERT( spParent ); } HELIUM_VERIFY( GameObject::CreateObject( rspPackage, Package::GetStaticType(), packagePath.GetName(), spParent ) ); HELIUM_ASSERT( rspPackage ); HELIUM_ASSERT( rspPackage->IsClass( Package::GetStaticType()->GetClass() ) ); } rspPackage->SetFlags( GameObject::FLAG_PRELOADED | GameObject::FLAG_LINKED | GameObject::FLAG_LOADED ); }
GameObjectPtr CLevel::CreateObject( const char * type, const char * templ ) { GameObjectPtr obj; if ( type != NULL && type[0] != 0 ) { if ( strcasecmp(type, "cgameobject") == 0 ) { obj = new CGameObject( this ); } else if ( strcasecmp(type, "cparticlesystem") == 0 ) { obj = new CParticleSystem( this ); } else { IwAssertMsg(GAME, false, ("Cant load unknown type '%s'", type)); } } else { IwAssertMsg(GAME, false, ("CLevel::CreateObject invalid type")); } if ( templ != NULL ) { TiXmlElement * elem_tmpl = GetTemplate( templ ); obj->Load( elem_tmpl ); } return obj; }
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 ); }
QString GameObjectPtr::toUserString(const GameObjectPtr &pointer) { if (pointer.isNull()) { return "(not set)"; } else { return pointer.toString() + " (" + pointer->name() + ")"; } }
Ogre::SceneNode* GOCOgreNodeUser::GetNode() { GameObjectPtr owner = mOwnerGO.lock(); IceAssert(owner.get()) GOCOgreNode *gocNode = owner->CreateOrRetrieveComponent<GOCOgreNode>(); return gocNode->GetNode(); }
bool CLevel::OrderZPred( const GameObjectPtr & obj1, const GameObjectPtr & obj2 ) { if ( obj1 != NULL && obj2 != NULL ) { return obj1->GetZ() < obj2->GetZ(); } return false; }
void GOComponent::NotifyOwnerGO() { GameObjectPtr ownerGO = mOwnerGO.lock(); if (!ownerGO.get()) return; UpdatePosition(ownerGO->GetGlobalPosition()); UpdateOrientation(ownerGO->GetGlobalOrientation()); UpdateScale(ownerGO->GetGlobalScale()); }
uint32_t ReplicationManagerServer::WriteCreateAction( OutputMemoryBitStream& inOutputStream, int inNetworkId, uint32_t inDirtyState ) { //need object GameObjectPtr gameObject = NetworkManagerServer::sInstance->GetGameObject( inNetworkId ); //need 4 cc inOutputStream.Write( gameObject->GetClassId() ); return gameObject->Write( inOutputStream, inDirtyState ); }
GameObjectPtr Level::CreateObject(std::string type, std::string name) { GameObjectPtr gameObj = GameClassRegistry::Get().Create(type); gameObj->SetLevel(this); if(name != "") gameObj->SetName(name); mGameObjects[gameObj->GetName()] = gameObj; return gameObj; }
GameObjectPtr DirLightTpl::CreateGameObject() { GameObjectPtr pObj = m_pManager->CreateGameObject(L"Directional Light"); GameObjectComponentPtr pLight = m_pManager->CreateComponent(L"DirectionalLight"); pObj->AddComponent(pLight); return pObj; }
void LogicComponentEnemy::processCollision(GameObjectPtr pGameObject, Ogre::Vector3 pNormal) { if(pGameObject->getType().compare(GAME_OBJECT_TYPE_FLASHLIGHT)==0) { GameObjectFlashLightPtr flashlight=BOOST_PTR_CAST(GameObjectFlashLight,pGameObject); int flashlightColour=flashlight->getColour(); if ( mHitRecoveryTime<0 && !mHasBeenHit && !mHasDied) { std::stringstream msg; if (getMaskValueFromColour(flashlightColour) & mColourSensitivityMask) { if(getParent()->getType().compare(GAME_OBJECT_TYPE_TRIPOLLO)==0) { decreaseHP(flashlight->getAttackDamage()); std::stringstream msg(""); msg<<getParentName()<<" remaining HP: "<<mHealthPoints; Logger::getInstance()->log(msg.str()); mHitRecoveryTime=1;//TODO: use animation instead of hit time //only hit if nightmares mHasBeenHit=getParent()->getWorld()==NIGHTMARES; } else if(getParent()->getType().compare(GAME_OBJECT_TYPE_BOSS)==0) { //only hit if nightmares mHasBeenHit=getParent()->getWorld()==NIGHTMARES; } } } } if(pGameObject->getType().compare(GAME_OBJECT_TYPE_PILLOW)==0 && !mHasBeenHit && !mHasDied) { GameObjectPillowPtr pillow=BOOST_PTR_CAST(GameObjectPillow, pGameObject); if (mHitRecoveryTime<0) { if(getParent()->getType().compare(GAME_OBJECT_TYPE_TRIPOLLO)==0) { decreaseHP(pillow->getAttackDamage()); std::stringstream msg(""); msg<<getParentName()<<" remaining HP: "<<mHealthPoints; Logger::getInstance()->log(msg.str()); mHitRecoveryTime=1; //only hit if dreams mHasBeenHit=getParent()->getWorld()==DREAMS; } else if(getParent()->getType().compare(GAME_OBJECT_TYPE_BOSS)==0) { //only hit if dreams mHasBeenHit=getParent()->getWorld()==DREAMS; } } } if(pGameObject->getType().compare(GAME_OBJECT_TYPE_ONY)==0) { mHasHitOny=true; } }
void ReplicationManagerClient::ReadAndDoUpdateAction( InputMemoryBitStream& inInputStream, int inNetworkId ) { GameObjectPtr gameObject = NetworkManagerClient::sInstance->GetGameObject( inNetworkId ); // Should be good gameObject->Read( inInputStream ); }
void GOComponent::SetOwnerTransform(const Ogre::Vector3 &position, const Ogre::Quaternion &orientation, bool updateReferences, bool updateChildren) { GameObjectPtr owner = mOwnerGO.lock(); if (!owner.get()) return; owner->SetGlobalPosition(position, false, updateReferences, updateChildren); owner->SetGlobalOrientation(orientation, false, updateReferences, updateChildren); Msg msg; msg.typeID = GameObject::MessageIDs::UPDATE_COMPONENT_TRANSFORM; owner->BroadcastObjectMessage(msg, this); }
void GOComponent::SetOwnerPosition(const Ogre::Vector3 &position, bool updateReferences, bool updateChildren) { GameObjectPtr owner = mOwnerGO.lock(); if (!owner.get()) return; owner->SetGlobalPosition(position, false, updateReferences, updateChildren); Msg msg; msg.typeID = GameObject::MessageIDs::UPDATE_COMPONENT_POSITION; msg.params.AddOgreVec3("Position", position); owner->BroadcastObjectMessage(msg, this); }
void GOComponent::SetOwnerOrientation(const Ogre::Quaternion &orientation, bool updateReferences, bool updateChildren) { GameObjectPtr owner = mOwnerGO.lock(); if (!owner.get()) return; owner->SetGlobalOrientation(orientation, false, updateReferences, updateChildren); Msg msg; msg.typeID = GameObject::MessageIDs::UPDATE_COMPONENT_ORIENTATION; msg.params.AddOgreQuat("Orientation", orientation); owner->BroadcastObjectMessage(msg, this); }
GameObjectPtr PointLightTpl::CreateGameObject() { GameObjectPtr pObj = m_pManager->CreateGameObject(L"Point Light"); GameObjectComponentPtr pLight = m_pManager->CreateComponent(L"PointLight"); pObj->AddComponent(pLight); return pObj; }
GOCOgreNodeUser::~GOCOgreNodeUser() { GameObjectPtr owner = mOwnerGO.lock(); if (owner.get()) { if (GetNode()->numAttachedObjects() == 0) owner->RemoveComponent("OgreNode"); } }
_BEGIN_NAMESPACE_ bool CLevel::IsObjDeadPred(const GameObjectPtr& obj) { if( obj->IsDead() ) { obj->Deinit(); } return obj->IsDead(); }
void GameScene::AddDefaultLight() { using namespace ld3d; using namespace ld3d; GameObjectPtr pObj = m_pEngine->CreateObjectFromTpl("Default Light", "SkyLight"); pObj->SetTranslation(1, 1, 1); pObj->LookAt(math::Vector3(0, 0, 0)); }
void GameScene::AddDefaultLight() { using namespace engine; using namespace engine; GameObjectPtr pObj = CreateObjectFromTpl(L"Default Light", L"SkyLight"); pObj->SetTranslation(1, 1, 1); pObj->LookAt(math::Vector3(0, 0, 0)); }
void GOCCharacterController::SetParameters(DataMap *parameters) { _clear(); mDimensions = parameters->GetValue("Dimensions", Ogre::Vector3(1,1,1)); mMovementSpeed = parameters->GetFloat("MaxSpeed"); mMaterialName = parameters->GetValue<Ogre::String>("MaterialName", "Wood"); mDensity = parameters->GetValue<float>("Density", 100); Create(mDimensions); GameObjectPtr owner = mOwnerGO.lock(); if (owner.get()) mActor.getPxActor()->userData = owner.get(); }
void GOCCharacterController::SetOwner(std::weak_ptr<GameObject> go) { mOwnerGO = go; GameObjectPtr owner = mOwnerGO.lock(); if (!owner.get()) return; if (mActor.getPxActor()) { mActor.getPxActor()->userData = owner.get(); UpdatePosition(owner->GetGlobalPosition()); } }
void Yarn::InitFromShooter( GameObjectPtr inShooter, GameObjectPtr inTarget ) { SetPlayerId( inShooter->GetPlayerId() ); Vector3 forward = inTarget->GetLocation() - inShooter->GetLocation(); SetVelocity( forward * kMuzzleSpeed ); SetLocation( inShooter->GetLocation() ); mShooterCat = inShooter; mTargetCat = inTarget; }
void GameObjectFlashLight::processCollision(GameObjectPtr pGameObject, Ogre::Vector3 pNormal) { if(pGameObject->getType().compare(GAME_OBJECT_TYPE_PORTAL)==0) { Logger::getInstance()->log("FLASHLIGHT COLLISION " + pGameObject->getName()); } if (mLogicComponent.get()) { mLogicComponent->processCollision(pGameObject, pNormal); } }
GameObjectPtr VoxelWorldTemplate::CreateGameObject() { GameObjectPtr pObj = m_pManager->CreateGameObject(L"VoxelWorld"); VoxelWorldPtr pWorld = m_pManager->GetAllocator()->AllocObject<VoxelWorld>(m_pManager); pObj->AddComponent(pWorld); VoxelWorldRendererPtr pRenderer = m_pManager->GetAllocator()->AllocObject<VoxelWorldRenderer>(m_pManager); pObj->AddComponent(pRenderer); return pObj; }