示例#1
0
void Player::advance(int phase)
{
    if(!phase) return;

    qreal xa = 0, ya =0;

    if(pSpriteMove->getIsRunning()){
        setSpeedWalking(DEFAULT_SPEED_WALKING *3);
    }else{
        setSpeedWalking(DEFAULT_SPEED_WALKING);
    }

    setAnimDelta(getAnimDelta()+1);
    setAnimTime(getAnimTime()+ getSpeedWalking());
    /* On gère l'animation de déplacement */
    if(getAnimDelta() >= getAnimTime()){
        setAnimFrame(getAnimFrame()+1);
        setAnimDelta(0);

        if(getAnimFrame() > DEFAULT_ANIME_FRAME){
            setAnimFrame(0);
        }
    }

    /*On définie les coordonnées de déplacement
     *par rapport au sens où le player doit aller.*/
    if(pSpriteMove->getIsLookingUp()){
        ya -= getSpeedWalking();
    }else if(pSpriteMove->getIsLookingDown()){
        ya += getSpeedWalking();
    }else if(pSpriteMove->getIsLookingLeft()){
        xa -= getSpeedWalking();
    }else if(pSpriteMove->getIsLookingRight()){
        xa += getSpeedWalking();
    }

    /* On effectue le déplacement du player*/

    if(xa != 0 || ya != 0){
        pSpriteMove->setIsWalking(true);
        move(xa,ya);
    }else{
        pSpriteMove->setIsWalking(false);
    }


    setAnimTime(DEFAULT_ANIME_TIME);
}
示例#2
0
void DrawElement::setAnimStateTime(int stat, int tim)
{
    //setAnimStateTime(AnimStateTime(stat,tim));
    setAnimState(stat);
    setAnimTime(tim);
    qDebug() << "DrawElement::setAnimStateTime = " << tim;
}
示例#3
0
void NcpEnnemy::advance(int phase)
{
    if(!phase) return;

    if(!chasingMode){
        targetInAgressiveZone();
    }else{
        setAnimDelta(getAnimDelta()+1);
        setAnimTime(getAnimTime()+ getSpeedWalking());
        if(getAnimDelta() >= getAnimTime()){
            setAnimFrame(getAnimFrame()+1);
            setAnimDelta(0);

            if(getAnimFrame() > DEFAULT_ANIME_FRAME){
                setAnimFrame(0);
            }
            findPathToTarget();
        }
        setAnimTime(DEFAULT_ANIME_E_TIME);
    }

}
void AnimTimeSensor::frame(Time oTime, UInt32 uiFrame)
{
    Time startT = _sfStartTime  .getValue();
    Time stopT  = _sfStopTime   .getValue();
    Time currT  = _sfTime       .getValue();

    Time length = _sfCycleLength.getValue();
    Time deltaT = 0.0;

    setTime(oTime);

    if(getEnabled() == false)
    {
        if(getIsActive() == true)
        {
            setIsActive(false);
        }

        return;
    }

    if(startT < stopT)
    {
        if(oTime < startT)
        {
            if(getIsActive() == true)
            {
                SLOG << "ATS: start < stop, BEFORE startT, deactivating" << std::endl;

                setFraction(0.f  );
                setAnimTime(0.f  );
                setIsActive(false);
            }

            return;
        }
        else if(oTime > stopT)
        {
            if(getIsActive() == true)
            {
                SLOG << "ATS: start < stop, AFTER stopT";

                setFraction(1.f   );
                setAnimTime(length);

                // only deactivate the second time oTime > stopT
                // to propagate the final state
                if(currT > stopT)
                {
                    PLOG << ", deactivating";

                    setIsActive(false);
                }

                PLOG << std::endl;
            }

            return;
        }
        else
        {
            if(currT <= 0.0)
            {
                deltaT = oTime - startT;
            }
            else
            {
                deltaT = oTime - currT;
            }
        }
    }
    else
    {
        if(oTime < startT)
        {
            if(getIsActive() == true)
            {
                SLOG << "ATS: start >= stop, BEFORE startT, deactivating" << std::endl;

                setFraction(0.f  );
                setAnimTime(0.f  );
                setIsActive(false);
            }

            return;
        }
        else
        {
            if(currT <= 0.0)
            {
                deltaT = oTime - startT;
            }
            else
            {
                deltaT = oTime - currT;
            }
        }
    }

    // use deltaT to update

    Real32 oldAnimT = getAnimTime();
    Real32 newAnimT = getAnimTime();

    if(getForward() == true)
    {
        newAnimT += getTimeScale() * deltaT;
    }
    else
    {
        newAnimT -= getTimeScale() * deltaT;
    }

    if(getLoop() == true)
    {
        newAnimT = osgMod<Real64>(newAnimT, length);
        
        while(newAnimT < 0.f)
            newAnimT += length;

        setAnimTime(newAnimT         );
        setFraction(newAnimT / length);

        if(getIsActive() == false)
            setIsActive(true);
    }
    else
    {
        if(newAnimT < 0.f)
        {
            if(getIsActive() == true)
            {
                SLOG << "ATS: start >= stop, newAnimT < 0";

                setAnimTime(0.f);
                setFraction(0.f);

                // only deactivate the second time newAnimT < 0.f
                // to propagate the final state
                if(oldAnimT <= 0.f)
                {
                    PLOG << ", deactivating";

                    setIsActive(false);
                }

                PLOG << std::endl;
            }
        }
        else if(newAnimT > length)
        {
            if(getIsActive() == true)
            {
                SLOG << "ATS: start >= stop, newAnimT > length";

                setAnimTime(length);
                setFraction(1.f   );

                // only deactivate the second time newAnimT > length
                // to propagate the final state
                if(oldAnimT >= length)
                {
                    PLOG << ", deactivating";

                    setIsActive(false);
                }

                PLOG << std::endl;
            }
        }
        else
        {
            setAnimTime(newAnimT         );
            setFraction(newAnimT / length);

            if(getIsActive() == false)
                setIsActive(true);
        }
    }
}