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;
}
