void ExplodeOnHitSystem::Init()
{
SystemSuppressor::Get().Add( SystemSuppressor::SceneLoad, GetType_static() );
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<IExplodeOnHitComponent>().IsValid(); } );
}
void AttractableSystem::Update(double DeltaTime)
{
for (auto actor : mScene.GetActorsFromMap( GetType_static() ))
{
auto attractableC( actor->Get<IAttractableComponent>() );
auto accelerationC( actor->Get<IAccelerationComponent>() );
auto targetHolderC( actor->Get<ITargetHolderComponent>() );
auto moveC( actor->Get<IMoveComponent>() );
if (!attractableC.IsValid() || !accelerationC.IsValid() || !targetHolderC.IsValid() || !moveC.IsValid())
{
continue;
}
auto const accel = accelerationC->GetAcceleration();
auto currentTarget( mScene.GetActor( targetHolderC->GetTargetGUID() ) );
targetHolderC->SetTargetGUID( -1 );
accelerationC->SetAcceleration( -1 * attractableC->GetDeceleration() );
if (currentTarget.IsValid())
{
auto healthC( currentTarget->Get<IHealthComponent>() );
if (healthC.IsValid() && healthC->IsAlive())
{
accelerationC->SetAcceleration( accel );
targetHolderC->SetTargetGUID( currentTarget->GetGUID() );
moveC->SetMoving( true );
attractableC->GetTurnToTargetAct().Update( *actor, DeltaTime );
}
}
}
}
NotifyParentOnDeathSystem::NotifyParentOnDeathSystem()
: mScene( Scene::Get() )
{
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<INotifyParentOnDeathComponent>().IsValid()
&& actor.Get<IHealthComponent>().IsValid(); } );
}
void ParticleSystem::Update( double DeltaTime )
{
for( auto actor: mScene.GetActorsFromMap( GetType_static() ) )
{
Opt<IEmitterComponent> emitterC = actor->Get<IEmitterComponent>();
if (!emitterC.IsValid())
{
continue;
}
Opt<IPositionComponent> positionC = actor->Get<IPositionComponent>();
if( !positionC.IsValid() )
{
continue;
}
Opt<IMoveComponent> moveC = actor->Get<IMoveComponent>();
glm::vec2 distance(0);
if ( moveC.IsValid() && moveC->IsMoving() && !moveC->IsRooted() )
{
distance = glm::vec2(moveC->GetSpeedX()*DeltaTime, moveC->GetSpeedY()*DeltaTime);
}
emitterC->Update( DeltaTime );
std::vector<int32_t> const& emitted = emitterC->GetEmitTypes();
for( std::vector<int32_t>::const_iterator ie = emitted.begin(), ee = emitted.end(); ie != ee; ++ie )
{
static ParticleEngine& pe( ParticleEngine::Get() );
pe.AddParticle( *ie, glm::vec2( positionC->GetX(), positionC->GetY() ), distance, positionC->GetOrientation() );
}
emitterC->Emitted( emitted );
}
}
void NotifyParentOnDeathSystem::Update( double DeltaTime )
{
for ( auto actor : mScene.GetActorsFromMap( GetType_static() ) )
{
Opt<INotifyParentOnDeathComponent> notifyParentOnDeathC = actor->Get<INotifyParentOnDeathComponent>();
if ( !notifyParentOnDeathC.IsValid() )
{
continue;
}
Opt<Actor> parent( mScene.GetActor( notifyParentOnDeathC->GetParentGUID() ) );
Opt<Actor> killer( mScene.GetActor( notifyParentOnDeathC->GetKillerGUID() ) );
if( !parent.IsValid() )
{
continue;
}
Opt<IHealthComponent> healthC = actor->Get<IHealthComponent>();
if( !healthC.IsValid() || healthC->IsAlive() )
{
continue;
}
if( !killer.IsValid() )
{
continue;
}
Opt<IListenChildDeathComponent> listenChildDeathC = parent->Get<IListenChildDeathComponent>();
if ( !listenChildDeathC.IsValid() )
{
continue;
}
listenChildDeathC->SetKillerOfChildGUID( killer->GetGUID() );
}
}
void CollisionSystem::Update( double DeltaTime )
{
static const auto enableCollision = Settings::Get().GetInt( "collisions.enable", 1 ) != 0;
if( !enableCollision )
{
return;
}
mUpdateTimer.Log( "start collision" );
mPerfTimer.Log( "pre build grid" );
std::vector<std::pair<Opt<CollisionSubSystem>, Actor*>> collisionAndActors;
for (auto actor : mScene.GetActorsFromMap( GetType_static() ))
{
Opt<ICollisionComponent> collisionC = actor->Get<ICollisionComponent>();
if ( collisionC.IsValid() )
{
Opt<CollisionSubSystem> collisionSS = GetCollisionSubSystem( collisionC->GetId() );
if ( collisionSS.IsValid() )
{
collisionAndActors.push_back( std::make_pair( collisionSS, actor ) );
collisionSS->ClipScene( *actor );
}
mCollisionGrid.AddActor( actor, DeltaTime, collisionC );
}
}
mPerfTimer.Log( "post build grid" );
PossibleCollisions_t const& PossibleCollisions = mCollisionGrid.GetPossibleCollisions();
for( PossibleCollisions_t::const_iterator i = PossibleCollisions.begin(), e = PossibleCollisions.end(); i != e; ++i )
{
Actor& A = *( i->A1 );
Actor& B = *( i->A2 );
Opt<ICollisionComponent> ACollisionC = A.Get<ICollisionComponent>();
Opt<ICollisionComponent> BCollisionC = B.Get<ICollisionComponent>();
BOOST_ASSERT( ACollisionC.IsValid() && BCollisionC.IsValid() ); //TODO: here this one should be true
CollisionModel const& CollModel = mCollisionStore.GetCollisionModel( ACollisionC->GetCollisionClass(), BCollisionC->GetCollisionClass() );
if( !CollModel.AreActorsColliding( A, B, DeltaTime ) )
{
continue;
}
//TODO: needs optimization, maybe a template parameter for SubSystemHolder to subsystem would do
Opt<CollisionSubSystem> ACollisionSS = GetCollisionSubSystem( ACollisionC->GetId() );
if ( ACollisionSS.IsValid() )
{
ACollisionSS->Collide( A, B );
}
Opt<CollisionSubSystem> BCollisionSS = GetCollisionSubSystem( BCollisionC->GetId() );
if ( BCollisionSS.IsValid() )
{
BCollisionSS->Collide( B, A );
}
}
mPerfTimer.Log( "post collide" );
for (auto& collAndActor : collisionAndActors)
{
collAndActor.first->Update( *collAndActor.second, DeltaTime );
}
mPerfTimer.Log( "post collSS" );
mUpdateTimer.Log( "end collision" );
}
void AttractableSystem::Init()
{
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<IAttractableComponent>().IsValid()
&& actor.Get<ITargetHolderComponent>().IsValid()
&& actor.Get<IAccelerationComponent>().IsValid()
&& actor.Get<IMoveComponent>().IsValid(); } );
}
void CollisionSystem::Init()
{
SubSystemHolder::Init();
mCollisionGrid.Build( mScene.GetDimensions(), 400.0f );
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<ICollisionComponent>().IsValid()
&& actor.Get<IPositionComponent>().IsValid()
&& actor.Get<IMoveComponent>().IsValid(); } );
mOnActorEvent = EventServer<ActorEvent>::Get().Subscribe( boost::bind( &CollisionSystem::OnActorEvent, this, _1 ) );
}
void ExplodeOnHitSystem::Update( double DeltaTime )
{
for( auto actor : mScene.GetActorsFromMap( GetType_static() ) )
{
Opt<IExplodeOnHitComponent> explodeOnHitC = actor->Get<IExplodeOnHitComponent>();
if ( !explodeOnHitC.IsValid() || !explodeOnHitC->IsExploded() )
{
continue;
}
WeaponItemSubSystem::Projectiles_t projectiles;
ExplodeOnDeathSystem::FillExplosionProjectiles( *explodeOnHitC.Get(), *actor, projectiles );
Scatter scatter;
WeaponItemSubSystem::Get()->AddProjectiles( *actor, projectiles, scatter );
Opt<IHealthComponent> healthC = actor->Get<IHealthComponent>();
if( healthC.IsValid() )
{
healthC->SetHP( 0 );
}
}
}
void PulseSystem::Update(double DeltaTime)
{
for (auto actor : mScene.GetActorsFromMap( GetType_static() ))
{
Opt<IPulseComponent> pulseC(actor->Get<IPulseComponent>());
for (auto& pulse : pulseC->GetPulses())
{
pulse.mDurationCurrent += (pulse.mDirection?1:-1)*DeltaTime;
if (pulse.mDurationCurrent > pulse.mDuration)
{
pulse.mDurationCurrent = pulse.mDuration;
pulse.mDirection = !pulse.mDirection;
}
else if (pulse.mDurationCurrent < 0.0)
{
pulse.mDurationCurrent = 0.0;
pulse.mDirection = !pulse.mDirection;
}
}
}
}
void RemoveComponentsOnDeathSystem::Update( double DeltaTime )
{
for (auto actor : mScene.GetActorsFromMap( GetType_static() ))
{
Opt<IRemoveComponentsOnDeathComponent> removeComponentsOnDeathC = actor->Get<IRemoveComponentsOnDeathComponent>();
if ( !removeComponentsOnDeathC.IsValid() )
{
continue;
}
Opt<IHealthComponent> healthC = actor->Get<IHealthComponent>();
if( !healthC.IsValid() )
{
continue;
}
if( healthC->IsAlive() )
{
continue;
}
// create copy, component might drop itself
std::vector<int32_t> const comps = removeComponentsOnDeathC->GetComponents();
std::for_each( std::begin( comps ), std::end( comps ),
[&]( int32_t id ) { actor->DropComponent( id ); } );
}
}
void ParticleSystem::Init()
{
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<IEmitterComponent>().IsValid()
&& actor.Get<IPositionComponent>().IsValid(); } );
}
void PulseSystem::Init()
{
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<IPulseComponent>().IsValid(); } );
}
void RemoveComponentsOnDeathSystem::Init()
{
mScene.AddValidator( GetType_static(), []( Actor const& actor )->bool {
return actor.Get<IRemoveComponentsOnDeathComponent>().IsValid()
&& actor.Get<IHealthComponent>().IsValid(); } );
}
