source: code/branches/campaignHS15/src/orxonox/controllers/FlyingController.cc @ 10875

/*
 *   ORXONOX - the hottest 3D action shooter ever to exist
 *                    > www.orxonox.net <
 *
 *
 *   License notice:
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation; either version 2
 *   of the License, or ( at your option )any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *   Author:
 *      Fabian 'x3n' Landau
 *   Co-authors:
 *      Dominik Solenicki
 *
 */
#include "controllers/FlyingController.h"
#include "core/XMLPort.h"
#include "worldentities/pawns/SpaceShip.h"
#include "util/Math.h"

namespace orxonox
{    
    RegisterClass (FlyingController);
    
    FlyingController::FlyingController( Context* context ): CommonController( context )
    {
        this->spread_ = 200;
        this->tolerance_ = 80;
        RegisterObject( FlyingController );
    }
    FlyingController::~FlyingController() 
    {

    }
    void FlyingController::XMLPort( Element& xmlelement, XMLPort::Mode mode )
    {
        XMLPortParam( FlyingController, "spread", setSpread, getSpread,  xmlelement, mode );
        XMLPortParam( FlyingController, "formationMode", setFormationModeXML, getFormationModeXML,  xmlelement, mode );
        SUPER( FlyingController, XMLPort, xmlelement, mode );
    }
   
    void FlyingController::setFormationModeXML( std::string val )
    {
        const std::string valUpper = getUppercase( val );
        FormationMode::Value value;
        
        if ( valUpper == "WALL" )
            value = FormationMode::WALL;
        else if ( valUpper == "FINGER4" )
            value = FormationMode::FINGER4;
        else if ( valUpper == "DIAMOND" )
            value = FormationMode::DIAMOND;
        else
            ThrowException( ParseError, std::string( "Attempting to set an unknown FormationMode: '" )+ val + "'." );
        this->setFormationMode( value );
    }
    std::string FlyingController::getFormationModeXML() 
    {
        switch ( this->formationMode_ )
        {
            case FormationMode::WALL:
            { return "WALL"; break; }
            case FormationMode::FINGER4:
            { return "FINGER4"; break; }
            case FormationMode::DIAMOND:
            { return "DIAMOND"; break; }
            default:
                return "DIAMOND"; break;
        }
    }

    

    void FlyingController::stopMoving()
    {
        this->bHasTargetPosition_ = false;
    }

    void FlyingController::moveToPosition( const Vector3& target, float dt )
    {
        ControllableEntity* entity = this->getControllableEntity();
        Vector2 coord = get2DViewCoordinates
            ( entity->getPosition() , 
            entity->getOrientation()  * WorldEntity::FRONT, 
            entity->getOrientation()  * WorldEntity::UP, 
            target );

        float distance = ( target - this->getControllableEntity() ->getPosition() ).length();
        float rotateX = -clamp( coord.x * 10, -1.0f, 1.0f );
        float rotateY = clamp( coord.y * 10, -1.0f, 1.0f );

        if ( distance > this->tolerance_ )
        {
            this->getControllableEntity() ->rotateYaw( ROTATEFACTOR * rotateX * dt );
            this->getControllableEntity() ->rotatePitch( ROTATEFACTOR * rotateY * dt );

            if ( distance < 300 )
            {
                if ( bHasTargetOrientation_ )
                {
                    copyTargetOrientation( dt );
                }
            }
            if (distance > this->tolerance_*1.5f || (rotateX > -0.01 && rotateX < 0.01 && rotateY > -0.01 && rotateY < 0.01))
                this->getControllableEntity() ->moveFrontBack( SPEED * dt );
        }
        else
        {      
            bHasTargetPosition_ = false;
            bHasTargetOrientation_ = false;
        }
    }
    void FlyingController::moveToTargetPosition(float dt)
    {
        this->moveToPosition (this->targetPosition_, dt);
    }
    void FlyingController::copyOrientation( const Quaternion& orient, float dt )
    {

        double diff=orient.getRoll(false).valueRadians() -
                        ( this->getControllableEntity() ->getOrientation() .getRoll( false ).valueRadians() );
        while( diff>math::twoPi)diff-=math::twoPi;
        while( diff<-math::twoPi )diff+=math::twoPi;

        this->getControllableEntity() ->rotateRoll(diff * ROTATEFACTOR * dt);
    }
    //change log: increased precision, increased rotation speed
    void FlyingController::copyTargetOrientation( float dt )
    {
        if ( bHasTargetOrientation_ )
        {   
            copyOrientation( targetOrientation_, dt );
        }
    }
    
    void FlyingController::setTargetPosition( const Vector3& target )
    {
        this->targetPosition_ = target;
        this->bHasTargetPosition_ = true;
    }

    void FlyingController::setTargetOrientation( const Quaternion& orient )
    {
        this->targetOrientation_=orient;
        this->bHasTargetOrientation_=true;
    }

    void FlyingController::setTargetOrientation( ControllableEntity* target )
    {
        if ( target )
            setTargetOrientation( target->getOrientation() );
    }
    void FlyingController::boostControl()
    {
        SpaceShip* ship = orxonox_cast<SpaceShip*>(this->getControllableEntity());
        if(ship == NULL) return;
        if(ship->getBoostPower()*1.5f > ship->getInitialBoostPower() ) //upper limit ->boost
        {

            this->getControllableEntity()->boost(true);
        }
        else if(ship->getBoostPower()*4.0f < ship->getInitialBoostPower()) //lower limit ->do not boost
        {
           this->getControllableEntity()->boost(false);
        }
    }
    
}