src/tron/gCycleMovement.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2004  Armagetron Advanced Team (http://sourceforge.net/projects/armagetronad/)

**************************************************************************

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.

***************************************************************************

*/

#ifndef     ARMAGETRONAD_SRC_TRON_GCYCLEMOVEMENT_H_INCLUDED
#define     ARMAGETRONAD_SRC_TRON_GCYCLEMOVEMENT_H_INCLUDED

#include "eNetGameObject.h"
#include <deque>

class gCycle;
class gDestination;
class gPlayerWall;
class gCycleMovement;
class gSensor;
struct gMaxSpaceAheadHitInfo;

class gMaxSpaceAheadHitInfoClearer
{
public:
    gMaxSpaceAheadHitInfoClearer( gMaxSpaceAheadHitInfo * & info );
    ~gMaxSpaceAheadHitInfoClearer();
private:
    gMaxSpaceAheadHitInfo * & info_;
};

REAL GetTurnSpeedFactor(void);

class gEnemyInfluence{
private:
    nObserverPtr< ePlayerNetID >        lastEnemyInfluence;     // the last enemy wall we encountered
    REAL                                                        lastTime;                               // the time it was drawn at

public:
    gEnemyInfluence();

    ePlayerNetID const *            GetEnemy() const;       // the last enemy possibly responsible for our death
    REAL                            GetTime() const;        // the time of the influence
    void                                                        AddSensor( const gSensor& sensor, REAL timePenalty, gCycleMovement * thisCycle ); // add the result of the sensor scan to our data
    void                                                        AddWall( const eWall * wall, eCoord const & point, REAL timePenalty, gCycleMovement * thisCycle ); // add the interaction with a wall to our data
    void                                                        AddWall( const gPlayerWall * wall, REAL timeBuilt, gCycleMovement * thisCycle ); // add the interaction with a wall to our data
};

struct gRealColor {
    REAL r,g,b;

    gRealColor():r(1), g(1), b(1){}

};

class gCycleMovement : public eNetGameObject
{
public:
    // accessors
    static float            RubberSpeed             ()                                              ;   
    static float            SpeedMultiplier         ()                                              ;   
    static void             SetSpeedMultiplier      ( REAL                  mult        )           ;   
    static float            MaximalSpeed            ()                                              ;   

    // AI info
    int                         WindingNumber           ()                                    const     ;   
    void                        SetWindingNumberWrapped ( int newWindingNumberWrapped )                 ;   

    // information about physics state
    virtual eCoord          Direction               ()                                    const     ;   
    virtual eCoord          LastDirection           ()                                    const     ;   
    virtual REAL            Speed                   ()                                    const     ;   
    virtual bool            Alive                   ()                                    const     ;   
    virtual bool            Vulnerable              ()                                    const     ;   
    virtual eCoord          SpawnDirection         ()                                    const     ;   

    bool                    CanMakeTurn             (int direction                      ) const     ;   
    bool                    CanMakeTurn             ( REAL time, int direction          ) const     ;   
    inline  REAL            GetDistanceSinceLastTurn(                                   ) const     ;   
    REAL                    GetTurnDelay            (                                   ) const     ;   
    REAL                    GetTurnDelayDb          (                                   ) const     ;   
    REAL                    GetNextTurn             (int direction                                   ) const     ;   

    // destination handling
    void                    AddDestination          ()                                              ;   
    void                    AdvanceDestination      ()                                              ;   
    void                    AddDestination          ( gDestination *        dest        )           ;   
    gDestination*           GetCurrentDestination   ()                                    const     ;   
    void                    NotifyNewDestination    ( gDestination *        dest        )           ;   
    bool                    IsDestinationUsed       ( const gDestination *  dest        ) const     ;   

    inline void            DropTempWall             ( gPlayerWall *         wall
            ,                                         eCoord const &        pos
            ,                                         eCoord const &        dir         )           ;   
    // information query
    virtual bool            EdgeIsDangerous         ( const eWall *         wall
            ,                                         REAL                  time
            ,                                         REAL                  alpha       ) const     ;   

    // movement commands
    bool                    Turn                    ( REAL                  dir         )           ;   
    bool                    Turn                    ( int                   dir         )           ;   

    void                    MoveSafely              (const eCoord &         dest
            ,                                        REAL                   startTime
            ,                                        REAL                   endTime     )           ;   

    virtual bool            Timestep                ( REAL                  currentTime )           ;   

    virtual REAL            NextInterestingTime     () const                                        ;   

    // existence management
    virtual void            AddRef                  ()                                              ;   

    gCycleMovement                                  ( eGrid *               grid
            ,                                         const eCoord &        pos
            ,                                         const eCoord &        dir
            ,                                         ePlayerNetID *        p=NULL
                    ,                                 bool                  autodelete=1 )          ;   
    gCycleMovement                                  ( nMessage &            message      )          ;   
    virtual ~gCycleMovement                         ()                                              ;   
    virtual void OnRemoveFromGame(); // called when the cycle is physically removed from the game

    void RequestSync(bool ack=true);     
    void RequestSync(int user,bool ack); 
protected:
    struct SyncData
    {
        eCoord pos, dir, lastTurn;
        REAL distance, speed, time, rubber, rubberMalus, brakingReservoir;
        unsigned short turns,braking,messageID;

        SyncData()
                :distance(0), speed(0), time(-10000), rubber(0), rubberMalus(0), brakingReservoir(0)
                ,turns(0),braking(0),messageID(0)
        {}
    };

    void            CopyFrom                        ( const gCycleMovement & other      )           ;   

    void            CopyFrom                        ( const SyncData &       sync
            ,                                         const gCycleMovement & other      )           ;   

    virtual void            InitAfterCreation       ()                                              ;   

    // acceleration handling
    virtual void            AccelerationDiscontinuity ()                                            ;   
    virtual void            CalculateAcceleration   (                                   )           ;   
    virtual void            ApplyAcceleration       ( REAL                  dt          )           ;   

    // destination handling
    REAL                    DistanceToDestination   ( gDestination &        dest        ) const     ;   
    virtual void            OnNotifyNewDestination  ( gDestination *        dest        )           ;   
    virtual void            OnDropTempWall          ( gPlayerWall *         wall
            ,                                         eCoord const &        pos
            ,                                         eCoord const &        dir         )           ;   
    virtual bool            DoIsDestinationUsed     ( const gDestination *  dest        ) const     ;   
    static  gDestination*   GetDestinationBefore    ( const SyncData &      sync
            ,                                         gDestination*         first       )                   ;   

    virtual bool            DoTurn                  ( int                   dir         )           ;   
    virtual REAL            DoGetDistanceSinceLastTurn  (                               ) const     ;   

    virtual void            RightBeforeDeath        ( int                   numTries    )           ;   
    virtual void            Die                     ( REAL time                         )           ;  

    virtual bool            TimestepCore            ( REAL                  currentTime
            ,                                         bool                  calculateAcceleration = true )           ;   
private:
    void                    MyInitAfterCreation     ()                                              ;   

    //      void            Init_gCycleCore         ()                                              ;   //!< initialisation function
    //      void            Finit_gCycleCore        ()                                              ;   //!< finalisation function

    gCycleMovement                                  ()                                              ;   
    gCycleMovement                                  ( gCycleMovement const & other      )           ;   
    gCycleMovement& operator =                      ( gCycleMovement const & other      )           ;   

private:
    short           alive_;                     

protected:
    gEnemyInfluence                             enemyInfluence; 

    gDestination*   destinationList;            
    gDestination*   currentDestination;         
    gDestination*   lastDestination;            

    eCoord          dirDrive;                   
    eCoord          dirSpawn;                   
    eCoord          lastDirDrive;               
    REAL            acceleration;               
    REAL            totalZoneAcceleration;      

    REAL            lastTimestep_;              
    REAL            verletSpeed_;               

    REAL            distance;                   
    // REAL         wallContDistance;           //!< distance at which the walls will start to build up ( negative if the wall is already building )

    mutable bool    refreshSpaceAhead_;         
    REAL            maxSpaceMaxCast_;           
    mutable gMaxSpaceAheadHitInfo * maxSpaceHit_; 

    unsigned short  turns;                      
    unsigned short  braking;                    

    int             windingNumber_;             
    int             windingNumberWrapped_;      

    mutable REAL    gap_[2];                    
    mutable bool    keepLookingForGap_[2];      

    eCoord                      lastTurnPos_;               
    REAL            lastTurnTimeRight_;         
    REAL            lastTurnTimeLeft_;          
    REAL            lastTimeAlive_;             
    std::deque<int> pendingTurns;               

    REAL            brakingReservoir;           
    REAL            rubber;                     
    REAL            rubberMalus;                
    REAL            rubberSpeedFactor;          

    REAL            brakeUsage;                 
    REAL            rubberUsage;                

    // room for accessors
public:
    REAL GetMaxSpaceAhead( REAL maxReport ) const; //< Returns the current maximal space ahead

    inline REAL GetDistance( void ) const;  
    inline gCycleMovement const & GetDistance( REAL & distance ) const; 
    inline REAL GetRubber( void ) const;    
    inline gCycleMovement const & GetRubber( REAL & rubber ) const; 
    inline unsigned short GetTurns( void ) const;   
    inline gCycleMovement const & GetTurns( unsigned short & turns ) const; 
    inline unsigned short GetBraking( void ) const; 
    inline gCycleMovement const & GetBraking( unsigned short & braking ) const; 
    inline REAL GetBrakingReservoir( void ) const;      
    inline gCycleMovement const & GetBrakingReservoir( REAL & brakingReservoir ) const; 
    inline REAL GetRubberMalus( void ) const;   
    inline gCycleMovement const & GetRubberMalus( REAL & rubberMalus ) const;   
    static bool RubberMalusActive( void ) ; 
    inline eCoord const & GetLastTurnPos( void ) const; 
    inline gCycleMovement const & GetLastTurnPos( eCoord & lastTurnPos ) const; 
    inline REAL const & GetLastTurnTime( void ) const;  
    inline gCycleMovement const & GetLastTurnTime( REAL & lastTurnTime ) const; 
    REAL GetAcceleration(void) const  { return acceleration; };  
    virtual void            AddZoneAcceleration     ( REAL zoneAcceleration             )           ;

protected:
    inline gCycleMovement & SetLastTurnPos( eCoord const & lastTurnPos );       
    inline gCycleMovement & SetLastTurnTime( REAL const & lastTurnTime );       
private:
    inline gCycleMovement & SetDistance( REAL distance );   
public:  // HACK
    //To have the zone able to influence it
    inline gCycleMovement & SetRubber( REAL rubber );   
private: // END OF HACK
    inline gCycleMovement & SetTurns( unsigned short turns );   
    inline gCycleMovement & SetBraking( unsigned short braking );   
public:  // HACK
    //To have the zone able to influence it
    inline gCycleMovement & SetBrakingReservoir( REAL brakingReservoir );       
private: // END OF HACK
    inline gCycleMovement & SetRubberMalus( REAL rubberMalus ); 
};

// float MaxSpaceAhead( const gCycleMovement* cycle, float ts, float lookAhead, float maxReport );

class gCycleDeath: public eDeath
{
public:
    gCycleDeath( eCoord const & pos )
            : pos_(pos)
    {}

    eCoord pos_;
};

class gCycleStop: public eDeath
{
};

// this class describes a point on the map the cycle on another
// computer of the game IS at. The copies of the cycle on the
// other computers try to reach this position by making the right
// turns.
class gDestination{
    friend class gCycleMovement;
    friend class gCycle;                                // todo: remove me
    friend class gCycleExtrapolator;    // todo: remove me

    eCoord position;                    // position of turn/brake command
    eCoord direction;                   // driving direction after the command
    REAL  gameTime;                             // game time of the command
    REAL  distance;                             // distance travelled so far
    REAL  speed;                                // speed at the time of the command
    bool  braking;                              // flag telling whether the brake was active
    bool  chatting;                             // flag indicating chat status

    unsigned short turns;       // the number of turns taken by the cycle so far
    bool hasBeenUsed;                   // flag indicating whether the sync code has already used this command
    unsigned short messageID;   // ID of the message this command came from
    bool missable;              // flag indicating that this destination is not to be treated as the one after a missed destination

    gDestination *next; // so they can form a list
    gDestination **list; // the list we are in
public:
    // take pos,dir and time from a cycle
    explicit gDestination(const gCycleMovement &takeitfrom);
    explicit gDestination(const gCycle &takeitfrom);

    // or from a message
    explicit gDestination( nMessage &m, unsigned short & cycle_id );

    // take pos,dir and time from a cycle
    void CopyFrom(const gCycleMovement &other);
    void CopyFrom(const gCycle &other);

    int CompareWith( const gDestination& other ) const;

    // write all the data into a nMessage
    void WriteCreate( nMessage &m, unsigned short cycle_id );

    // insert yourself into a list ordered by distance
    void InsertIntoList(gDestination **list);

    // find the latest entry in a list before the given distance
    static gDestination *RightBefore(gDestination *list, REAL dist);

    // find the earliest entry in a list after the given distance
    static gDestination *RightAfter(gDestination *list, REAL dist);

    // remove yourself again
    void RemoveFromList();

    bool Chatting(){ return chatting; }

    ~gDestination(){RemoveFromList();}

    gDestination & SetGameTime( REAL gameTime );        
    REAL GetGameTime( void ) const;     
    gDestination const & GetGameTime( REAL & gameTime ) const;  
};

// *******************************************************************************************
// *
// *    IsDestinationUsed
// *
// *******************************************************************************************
// *******************************************************************************************

inline bool gCycleMovement::IsDestinationUsed( const gDestination * dest ) const
{
    // delegate to virtual function
    return DoIsDestinationUsed( dest );
}

// *******************************************************************************************
// *
// *    DropTempWall
// *
// *******************************************************************************************
// *******************************************************************************************

inline void gCycleMovement::DropTempWall( gPlayerWall * wall, eCoord const & pos, eCoord const & dir )
{
    this->OnDropTempWall( wall, pos, dir );
}

// *******************************************************************************************
// *
// *    GetDistance
// *
// *******************************************************************************************
// *******************************************************************************************

inline REAL gCycleMovement::GetDistance( void ) const
{
    return this->distance;
}

// *******************************************************************************************
// *
// *    GetDistance
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement const & gCycleMovement::GetDistance( REAL & distance ) const
{
    distance = this->distance;
    return *this;
}

// *******************************************************************************************
// *
// *    SetDistance
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement & gCycleMovement::SetDistance( REAL distance )
{
    this->distance = distance;
    return *this;
}

// *******************************************************************************************
// *
// *    GetRubber
// *
// *******************************************************************************************
// *******************************************************************************************

inline REAL gCycleMovement::GetRubber( void ) const
{
    return this->rubber;
}

// *******************************************************************************************
// *
// *    GetRubber
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement const & gCycleMovement::GetRubber( REAL & rubber ) const
{
    rubber = this->rubber;
    return *this;
}

// *******************************************************************************************
// *
// *    SetRubber
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement & gCycleMovement::SetRubber( REAL rubber )
{
    this->rubber = rubber;
    return *this;
}

// *******************************************************************************************
// *
// *    GetTurns
// *
// *******************************************************************************************
// *******************************************************************************************

inline unsigned short gCycleMovement::GetTurns( void ) const
{
    return this->turns;
}

// *******************************************************************************************
// *
// *    GetTurns
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement const & gCycleMovement::GetTurns( unsigned short & turns ) const
{
    turns = this->turns;
    return *this;
}

// *******************************************************************************************
// *
// *    SetTurns
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement & gCycleMovement::SetTurns( unsigned short turns )
{
    this->turns = turns;
    return *this;
}

// *******************************************************************************************
// *
// *    GetBraking
// *
// *******************************************************************************************
// *******************************************************************************************

inline unsigned short gCycleMovement::GetBraking( void ) const
{
    return this->braking;
}

// *******************************************************************************************
// *
// *    GetBraking
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement const & gCycleMovement::GetBraking( unsigned short & braking ) const
{
    braking = this->braking;
    return *this;
}

// *******************************************************************************************
// *
// *    SetBraking
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement & gCycleMovement::SetBraking( unsigned short braking )
{
    this->braking = braking;
    return *this;
}

// *******************************************************************************************
// *
// *    GetBrakingReservoir
// *
// *******************************************************************************************
// *******************************************************************************************

inline REAL gCycleMovement::GetBrakingReservoir( void ) const
{
    return this->brakingReservoir;
}

// *******************************************************************************************
// *
// *    GetBrakingReservoir
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement const & gCycleMovement::GetBrakingReservoir( REAL & brakingReservoir ) const
{
    brakingReservoir = this->brakingReservoir;
    return *this;
}

// *******************************************************************************************
// *
// *    SetBrakingReservoir
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement & gCycleMovement::SetBrakingReservoir( REAL brakingReservoir )
{
    this->brakingReservoir = brakingReservoir;
    return *this;
}

// *******************************************************************************************
// *
// *    GetDistanceSinceLastTurn
// *
// *******************************************************************************************
// *******************************************************************************************

inline REAL gCycleMovement::GetDistanceSinceLastTurn( void ) const
{
    return this->DoGetDistanceSinceLastTurn();
}

// *******************************************************************************************
// *
// *    getRubberMalus
// *
// *******************************************************************************************
// *******************************************************************************************

inline REAL gCycleMovement::GetRubberMalus( void ) const
{
    return this->rubberMalus;
}

// *******************************************************************************************
// *
// *    getRubberMalus
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement const & gCycleMovement::GetRubberMalus( REAL & rubberMalus ) const
{
    rubberMalus = this->rubberMalus;
    return *this;
}

// *******************************************************************************************
// *
// *    setRubberMalus
// *
// *******************************************************************************************
// *******************************************************************************************

inline gCycleMovement & gCycleMovement::SetRubberMalus( REAL rubberMalus )
{
    this->rubberMalus = rubberMalus;
    return *this;
}

// *******************************************************************************************
// *
// *    GetLastTurnPos
// *
// *******************************************************************************************
// *******************************************************************************************

eCoord const & gCycleMovement::GetLastTurnPos( void ) const
{
    return this->lastTurnPos_;
}

// *******************************************************************************************
// *
// *    GetLastTurnPos
// *
// *******************************************************************************************
// *******************************************************************************************

gCycleMovement const & gCycleMovement::GetLastTurnPos( eCoord & lastTurnPos ) const
{
    lastTurnPos = this->lastTurnPos_;
    return *this;
}

// *******************************************************************************************
// *
// *    SetLastTurnPos
// *
// *******************************************************************************************
// *******************************************************************************************

gCycleMovement & gCycleMovement::SetLastTurnPos( eCoord const & lastTurnPos )
{
    this->lastTurnPos_ = lastTurnPos;
    return *this;
}

// *******************************************************************************************
// *
// *    GetLastTurnTime
// *
// *******************************************************************************************
// *******************************************************************************************

REAL const & gCycleMovement::GetLastTurnTime( void ) const
{
    return lastTurnTimeRight_ > lastTurnTimeLeft_ ? lastTurnTimeRight_ : lastTurnTimeLeft_;
}

// *******************************************************************************************
// *
// *    GetLastTurnTime
// *
// *******************************************************************************************
// *******************************************************************************************

gCycleMovement const & gCycleMovement::GetLastTurnTime( REAL & lastTurnTime ) const
{
    lastTurnTime = GetLastTurnTime();
    return *this;
}

// *******************************************************************************************
// *
// *    SetLastTurnTime
// *
// *******************************************************************************************
// *******************************************************************************************

gCycleMovement & gCycleMovement::SetLastTurnTime( REAL const & lastTurnTime )
{
    lastTurnTimeRight_ = lastTurnTimeLeft_ = lastTurnTime;
    return *this;
}

#endif // ARMAGETRONAD_SRC_TRON_GCYCLEMOVEMENT_H_INCLUDED

---