C++ Opt::GetX方法代码示例

void BounceCollisionSubSystem::Collide( Actor& actor, Actor& other )
{
    Opt<BounceCollisionComponent> bounceCC = actor.Get<BounceCollisionComponent>();
    if (mShotCollisionSubSystem.IsValid() && bounceCC->IsUseShotCollision())
    {
        mShotCollisionSubSystem->Collide(actor, other);
    }
    //TODO: for now its wallcc should be a bouncableComponent or this should be a collision class
    Opt<WallCollisionComponent> wallCC = other.Get<WallCollisionComponent>();
    if( !wallCC.IsValid() )
    {
        return;
    }
    Opt<IPositionComponent> positionC = actor.Get<IPositionComponent>();
    Opt<IMoveComponent> moveC = actor.Get<IMoveComponent>();

    Opt<IPositionComponent> otherPositionC = other.Get<IPositionComponent>();
    Opt<ICollisionComponent> otherCC = other.Get<ICollisionComponent>();
    if ( !otherPositionC.IsValid() || !otherCC.IsValid() || !positionC.IsValid() )
    {
        return;
    }
    double const dx = otherPositionC->GetX() - positionC->GetX();
    double const dy = otherPositionC->GetY() - positionC->GetY();

    const double h = moveC->GetHeading();
    double c = cos( h );
    double s = sin( h );
    double at = atan2( s, c );
    double at2 = atan2( c, s );
    if( std::abs( dx ) > std::abs( dy ) )
    {
        c *= -1;
    }
    else if( std::abs( dx ) < std::abs( dy ) )
    {
        s *= -1;
    }
    moveC->SetHeading( atan2( s, c ) );
    moveC->GetSpeed().mBase.Set( moveC->GetSpeed().mBase.Get() * ( 1.0 - bounceCC->GetSpeedLossPercent() ) );
    if (bounceCC->GetHitCountToKill() > 0)
    {
        bounceCC->SetHitCountToKill(bounceCC->GetHitCountToKill() - 1);
    }
    if (bounceCC->IsResetActorsCollidedOnBounce())
    {
        bounceCC->ResetDamagedActorIds();
    }
}

glm::vec4 Grid::Box( Actor const& Obj, double Dt )const
{
    Opt<IMoveComponent> moveC = Obj.Get<IMoveComponent>();
    float const MvX = moveC.IsValid() ? Dt * moveC->GetSpeedX() : 0.0f;
    float const MvY = moveC.IsValid() ? Dt * moveC->GetSpeedY() : 0.0f;

    double const Radius = Obj.Get<ICollisionComponent>()->GetRadius();
    Opt<IPositionComponent> const objPositionC = Obj.Get<IPositionComponent>();
    double const Ox = objPositionC->GetX() - mMin.x;
    double const Oy = objPositionC->GetY() - mMin.y;
    glm::vec4 Ret( Ox - Radius,
                   Oy - Radius,
                   Ox + Radius,
                   Oy + Radius );
    if( MvX < 0.0 )
    {
        Ret.x += MvX;
    }
    else
    {
        Ret.z += MvX;
    }
    if( MvY < 0.0 )
    {
        Ret.y += MvY;
    }
    else
    {
        Ret.w += MvY;
    }
    return Ret;
}

void MouseAdapterSystem::Update( double DeltaTime )
{
    Opt<Actor> actor( mScene.GetActor( mProgramState.mControlledActorGUID ) );
    if ( !actor.IsValid() )
    {
        return;
    }
    int32_t playerId = 1;
    static input::PlayerControlDevice& pcd( input::PlayerControlDevice::Get() );
    if( pcd.GetControlDevice( playerId ) != input::PlayerControlDevice::KeyboardAndMouse )
    {
        return;
    }
    InputState inputState = mInputSystem->GetInputState( playerId );

    Opt<IPositionComponent> actorPositionC = actor->Get<IPositionComponent>();
    inputState.mOrientation = atan2( mY - actorPositionC->GetY(), mX - actorPositionC->GetX() );

    inputState.mCursorX = mX;
    inputState.mCursorY = mY;

    if ( mMouse->IsButtonPressed( MouseSystem::Button_Left ) )
    {
        inputState.mShoot = true;
    }
    else if ( mMouse->IsButtonPressed( MouseSystem::Button_Right ) )
    {
        inputState.mShootAlt = true;
    }
    mInputSystem->SetInputState( playerId, inputState );
}

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 WeaponItemSubSystem::SetProjectilePosition(Actor& projectile, Actor& actor)
{
    Opt<IPositionComponent> projPositionC = projectile.Get<IPositionComponent>();
    Opt<IPositionComponent> actorPositionC = actor.Get<IPositionComponent>();
    glm::vec2 rvec(0.0, 0.0);
    Opt<IInventoryComponent> inventoryC = actor.Get<IInventoryComponent>();
    if (inventoryC.IsValid())
    {
        Opt<Weapon> weapon = inventoryC->GetSelectedWeapon();
        if (weapon.IsValid())
        {
            rvec.x += weapon->GetPositionX();
            rvec.y -= weapon->GetPositionY();
        }
    }
    rvec=glm::rotate(rvec, float(actorPositionC->GetOrientation()));
    projPositionC->SetX( projPositionC->GetX() + actorPositionC->GetX() + rvec.x );
    projPositionC->SetY( projPositionC->GetY() + actorPositionC->GetY() + rvec.y );
}

std::auto_ptr<PositionMessage> PositionMessageSenderSystem::GeneratePositionMessage( Actor const& actor )
{
    Opt<IPositionComponent> positionC = actor.Get<IPositionComponent>();
    if ( !positionC.IsValid() )
    {
        return std::auto_ptr<PositionMessage>();
    }
    std::auto_ptr<PositionMessage> positionMsg( new PositionMessage );
    positionMsg->mX = std::floor( positionC->GetX() * PRECISION );
    positionMsg->mY = std::floor( positionC->GetY() * PRECISION );
    //positionMsg->mOrientation=positionC->GetOrientation();
    positionMsg->mActorGUID = actor.GetGUID();
    return positionMsg;
}

int32_t GuardControllerSubSystem::GetDistanceSqr( Opt<IPositionComponent> positionC, Opt<IPositionComponent> otherPositionC )
{
    glm::vec2 const distV( (positionC->GetX() - otherPositionC->GetX()), (positionC->GetY() - otherPositionC->GetY()) );
    return glm::dot( distV, distV );
}

void WeaponItemSubSystem::Update( Actor& actor, double DeltaTime )
{
    Opt<IInventoryComponent> inventoryC = actor.Get<IInventoryComponent>();
    Opt<Weapon> weapon = inventoryC->GetSelectedWeapon();
    if ( !weapon.IsValid() )
    {
        return;
    }
    double cd = weapon->GetCooldown();
    cd -= DeltaTime;
    if( cd < 0 )
    {
        cd = 0;
    }
    weapon->SetCooldown( cd );
    //scatter updated on client
    Opt<IAccuracyComponent> accuracyC = actor.Get<IAccuracyComponent>();
    weapon->GetScatter().Update( DeltaTime, accuracyC.IsValid() ? accuracyC->GetAccuracy().Get() : 0 );

    if ( weapon->CanReload()
         //Not enough bullet for current shot  Need to see if the player wants to shoot alt:
         && ( weapon->GetShoot() && weapon->GetBullets() < weapon->GetShotCost()
              && weapon->GetCooldown() <= 0
              //Not enough bullet for current alt shot. Need to see if the player wants to shoot normal:
              || weapon->GetShootAlt() && weapon->GetBullets() < weapon->GetShotCostAlt()
              && weapon->GetCooldown() <= 0
              //Not enough bullet at all. This time the reload is a sure thing:
              || weapon->GetBullets() < weapon->GetShotCost()
              && weapon->GetBullets() < weapon->GetShotCostAlt() ) )
    {
        weapon->SetBullets( 0.0 );
        weapon->SetReloadTime( weapon->GetReloadTimeMax() );
        EventServer<ItemPropertiesChangedEvent>::Get().SendEvent( ItemPropertiesChangedEvent( *weapon ) );
    }

    weapon->SetReloadTime( weapon->GetReloadTime() - DeltaTime );

    if ( weapon->GetBullets() <= 0.0 )
    {
        if ( weapon->GetReloadTime() <= 0 && weapon->GetStaticReload() == 0.0 )
        {
            //todo: need to sync reloading with the server (-1 could occur, if a shot comes too fast, then it is reset by the end of the reload missing one bullet)
            weapon->SetBullets( weapon->GetBullets() + weapon->GetBulletsMax() );
            weapon->SetReloadTime( 0.0 );
        }
    }

    if ( weapon->GetReloadTime() <= 0 && weapon->GetStaticReload() > 0.0 )
    {
        weapon->SetBullets( std::min(
                                ( weapon->GetBullets() + weapon->GetStaticReload()/**DeltaTime*/ )
                                , weapon->GetBulletsMax() ) );
        weapon->SetReloadTime( weapon->GetReloadTimeMax() );
    }
    BindIds_t::iterator itemssIt = mSubSystems.get<SubSystemHolder::AllByBindId>().find( weapon->GetId() );
    if ( itemssIt != mSubSystems.get<SubSystemHolder::AllByBindId>().end() )
    {
        itemssIt->mSystem->Update( actor, DeltaTime );
    }

    if (mProgramState.mMode != core::ProgramState::Client)
    {
        if (weapon->GetCooldown() <= 0.0) //not synced to client
        {
            Opt<IPositionComponent> actorPositionC = actor.Get<IPositionComponent>();
            if (actorPositionC.IsValid())
            {
                if (weapon->IsShooting() && weapon->GetBullets() >= weapon->GetShotCost())
                {
                    if (weapon->GetMuzzleId() != -1)
                    {
                        std::auto_ptr<Actor> muzzle(mActorFactory(weapon->GetMuzzleId()));
                        SetProjectilePosition(*muzzle, actor);
                        BOOST_ASSERT(muzzle->Get<IPositionComponent>().IsValid());
                        muzzle->Get<IPositionComponent>()->SetOrientation(actorPositionC->GetOrientation());
                        mScene.AddActor(muzzle.release());
                    }
                    EventServer<core::ShotEvent>::Get().SendEvent(core::ShotEvent(actor.GetGUID(), glm::vec2(actorPositionC->GetX(), actorPositionC->GetY()), false));
                }
                else if (weapon->IsShootingAlt() && weapon->GetBullets() >= weapon->GetShotCostAlt())
                {
                    if (weapon->GetMuzzleAltId() != -1)
                    {
                        std::auto_ptr<Actor> muzzle(mActorFactory(weapon->GetMuzzleAltId()));
                        SetProjectilePosition(*muzzle, actor);
                        BOOST_ASSERT(muzzle->Get<IPositionComponent>().IsValid());
                        muzzle->Get<IPositionComponent>()->SetOrientation(actorPositionC->GetOrientation());
                        mScene.AddActor(muzzle.release());
                    }
                    EventServer<core::ShotEvent>::Get().SendEvent(core::ShotEvent(actor.GetGUID(), glm::vec2(actorPositionC->GetX(), actorPositionC->GetY()), true));
                }
            }
        }
    }
}

void HealthBarRenderer::Draw()
{
    SceneVertices_t Vertices;
    Vertices.reserve( mPrevVertices.size() );
    typedef std::vector<glm::vec2> Positions_t;
    Positions_t Positions;
    Positions_t TexCoords;
    Positions.reserve( mPrevVertices.size() );
    Positions_t TextPosition;
    TextPosition.reserve( mPrevVertices.size() );
    Positions_t Dimensions;
    Dimensions.reserve( mPrevVertices.size() );

    typedef std::vector<glm::vec4> Colors_t;
    Colors_t Colors;
    Colors.reserve( mPrevVertices.size() );
    SceneVertexInserter_t Inserter( Vertices );
    struct ChangedAt
    {
        size_t Start;
        size_t Count;
    };
    int32_t lastVertexIndex = 0;

    for ( core::ProgramState::ClientDatas_t::iterator i = mProgramState.mClientDatas.begin(), e = mProgramState.mClientDatas.end(); i != e; ++i )
    {
        Opt<Actor> player( Scene::Get().GetActor( ( *i ).mClientActorGUID ) );
        if ( !player.IsValid() )
        {
            continue;
        }
        engine::CloakSystem::CloakState cloakState = engine::CloakSystem::GetCloakState( *player.Get() );
        if ( cloakState == engine::CloakSystem::Invisible )
        {
            continue;
        }
        Opt<IPositionComponent> positionC = player->Get<IPositionComponent>();

        Opt<IHealthComponent> healthC( player->Get<IHealthComponent>() );
        Opt<ITeamComponent> teamC( player->Get<ITeamComponent>() );

        Opt<IArmorComponent> armorC = player->Get<IArmorComponent>();
        int32_t armor = 0;
        if ( armorC.IsValid() )
        {
            armor = armorC->GetCurrentArmor();
        }

        double currPercent = healthC->GetHP() / double( healthC->GetMaxHP().Get() );
        double currArmorPercent = armor / double( healthC->GetMaxHP().Get() + armor );

        bool isself = i->mClientActorGUID == mProgramState.mControlledActorGUID;
        {
            glm::vec4 dim( int32_t( positionC->GetX() ) + mBorderPosition.x, int32_t( positionC->GetY() ) + mBorderPosition.y, mBorderSize.x, mBorderSize.y );
            glm::vec4 col = isself ? glm::vec4( 0.0, 0.0, 0.0, 0.7 ) : glm::vec4( 0.0, 0.0, 0.0, 0.7 );
            ColoredBox( dim, col, Inserter );
        }
        {
            glm::vec4 dim( int32_t( positionC->GetX() ) + mPosition.x, int32_t( positionC->GetY() ) + mPosition.y, currPercent * mSize.x, mSize.y );
            glm::vec4 col = isself ? glm::vec4( 0.59, 0.15, 0.7, 1.0 ) : glm::vec4( 0.0, 0.8, 0.0, 0.7 );
            if ( teamC.IsValid() )
            {
                col = mColorRepo( teamC->GetTeam() );
            }
            ColoredBox( dim, col, Inserter );
        }
        {
            double currCombinedPercent = currPercent + currArmorPercent > 1.0 ? 1 - currArmorPercent : currPercent;
            glm::vec4 dim( int32_t( positionC->GetX() ) + mPosition.x + currCombinedPercent * mSize.x
                           , int32_t( positionC->GetY() ) + mPosition.y
                           , currArmorPercent * mSize.x, mSize.y );
            glm::vec4 col = glm::vec4( 1.0, 1.0, 1.0, 0.7 );
            ColoredBox( dim, col, Inserter );
        }

    }
    size_t const CurSize = Vertices.size();
    if ( CurSize == 0 )
    {
        return;
    }
    SceneVertex vertex = Vertices.back();

    // todo: check and track changes
    for( SceneVertices_t::const_iterator i = Vertices.begin(), e = Vertices.end(); i != e; ++i )
    {
        SceneVertex const& Vert = *i;
        Positions.push_back( Vert.Pos );
        Colors.push_back( Vert.Color );
        TextPosition.push_back( Vert.RealPos );
        //Dimensions.push_back(Vert.Dimensions);
    }


    mVAO.Bind();
    if( CurSize != mPrevVertices.size() )
    {
        size_t TotalSize = CurSize * ( sizeof( glm::vec4 ) + 3 * sizeof( glm::vec2 ) );
        glBufferData( GL_ARRAY_BUFFER, TotalSize, NULL, GL_DYNAMIC_DRAW );
    }
//.........这里部分代码省略.........

void ControllerAdapterSystem::Update(double DeltaTime)
{
    Opt<InputSystem> inputsys = InputSystem::Get();
    if( !inputsys.IsValid() )
    {
        return;
    }

    // collect controlled players by controller id
    std::map<int32_t, Opt<Actor> > controlledPlayers;
    static core::ProgramState& ps =  core::ProgramState::Get();
    Opt<Actor> actor( mScene.GetActor( ps.mControlledActorGUID ) );
    Opt<core::ClientData> clientData( ps.FindClientDataByActorGUID( ps.mControlledActorGUID ) );
    if( clientData.IsValid() && actor.IsValid() )
    {
        controlledPlayers[ clientData->mControlledLocalPlayerId ] = actor;
    }

    for( auto joy : getJoysticks() )
    {
        // get keymapping for joy name @ joy pos ( if custom, support per-slot mapping )
        ControllerState cs( joy );
        if( !cs.isValid() )
        {
            continue;
        }

        if( mCalibrate )
        {
            std::cout << "Joy " << joy << "\n";
            std::cout << "\tname: '" << cs.name << "'\n";
            std::cout << "\taxes: \n";
            int cnt = 0;
            for( auto const& a : cs.axes )
            {
                std::cout << "\t\ta" << cnt++ << " " << a << "\n";
            }
            std::cout << "\tbuttons: \n";
            cnt = 0;
            for( auto const& b : cs.buttons )
            {
                std::cout << "\t\tb" << cnt++ << " " << b << "\n";
            }
        }

        // get controlled player for joy
        int32_t controlledLocalPlayerId = 1;
        static input::PlayerControlDevice& pcd( input::PlayerControlDevice::Get() );
        if( pcd.GetControlDevice( controlledLocalPlayerId ) != input::PlayerControlDevice::Controller ||
            pcd.GetControllerIndex( controlledLocalPlayerId ) != joy )
        {
            continue;
        }

        // get InputState for player
        InputState is = inputsys->GetInputState( controlledLocalPlayerId );

        // fill inputstate for player
        is.mShoot = cs.getBool( "shoot" );
        is.mShootAlt = cs.getBool( "shoot_alt" );
        is.mUseNormalItem = cs.getBool( "use_normal" );
        is.mReload = cs.getBool( "reload" );
        is.mShowLeaderboard = cs.getBool( "show_leaderboard" );
        is.mPause = cs.getBool( "pause" );
        double vh = cs.getDouble( "view_horizontal" ), vv = cs.getDouble( "view_vertical" );
        static Settings& settings( Settings::Get() );
        static double const viewNullZone = settings.GetDouble( "controllers.view_null_zone", 0.4 );
        if( std::abs( vv ) >= viewNullZone || std::abs( vh ) >= viewNullZone )
        {
            is.mOrientation = atan2( vv, vh );
        }
        Opt<Actor> actor = controlledPlayers[ controlledLocalPlayerId ];
        if( actor.IsValid() )
        {
            Opt<IPositionComponent> actorPositionC = actor->Get<IPositionComponent>();
            static double const radius = settings.GetDouble( "controllers.cursor_radius", 400 );
            is.mCursorX = actorPositionC->GetX() + radius * cos( is.mOrientation );
            is.mCursorY = actorPositionC->GetY() + radius * sin( is.mOrientation );
        }
        double mh = cs.getDouble( "move_horizontal" ), mv = cs.getDouble( "move_vertical" );
        is.mHeading = atan2( mv, mh );
        static double const moveNullZone = settings.GetDouble( "controllers.move_null_zone", 0.2 );
        is.mMoving = std::abs( mv ) >= moveNullZone || std::abs( mh ) >= moveNullZone;
        inputsys->SetInputState( controlledLocalPlayerId, is );
        // TODO fill generic input state ( ui )
    }
}