src/tron/gCycle.h

Go to the documentation of this file.

/*

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

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

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

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 ArmageTron_CYCLE_H
#define ArmageTron_CYCLE_H

//#define USE_HEADLIGHT

#include "gStuff.h"
//#include "rTexture.h"
//#include "rModel.h"
#include "eNetGameObject.h"
#include "tList.h"
#include "nObserver.h"
#include "rDisplayList.h"

#include "gCycleMovement.h"

class rModel;
class gTextureCycle;
class gSensor;
class gNetPlayerWall;
class gPlayerWall;
class eTempEdge;
class gJoystick;
struct gPredictPositionData;

// minimum time between two cycle turns
extern REAL sg_delayCycle;

// Render the headlight effect?
extern bool headlights;

// steering help
extern REAL sg_rubberCycle;


// this class set is responsible for remembering which walls are too
// close together to pass through safely. The AI uses this information,
// so the real declaration of gCylceMemoryEntry can be found in gAIBase.cpp.
class gCycleMemoryEntry;

class gCycleMemory{
    friend class gCycleMemoryEntry;

    tList<gCycleMemoryEntry>     memory;  // memory about other cylces

public:
    // memory functions: access the memory for a cylce
    gCycleMemoryEntry* Remember(const gCycle *cycle);
    int Len() const {return memory.Len();}
    gCycleMemoryEntry* operator() (int i)  const;
    gCycleMemoryEntry* Latest   (int side)  const;
    gCycleMemoryEntry* Earliest (int side)  const;

    void Clear();

    gCycleMemory();
    ~gCycleMemory();
};

// class used to extrapolate the movement of a lightcycle
class gCycleExtrapolator: public gCycleMovement
{
public:
    void CopyFrom( const gCycleMovement& other );                                                       // copies relevant info from other cylce
    void CopyFrom( const SyncData& sync, const gCycle& other );                 // copies relevant info from sync data and everything else from other cycle

    gCycleExtrapolator(eGrid *grid, const eCoord &pos,const eCoord &dir,ePlayerNetID *p=NULL,bool autodelete=1);
    // gCycleExtrapolator(nMessage &m);
    virtual ~gCycleExtrapolator();

    // virtual gDestination* GetCurrentDestination() const;                     // returns the current destination

    virtual bool EdgeIsDangerous(const eWall *w, REAL time, REAL a) const;

    virtual void PassEdge(const eWall *w,REAL time,REAL a,int recursion=1);

    virtual bool TimestepCore(REAL currentTime, bool calculateAcceleration = true );

    // virtual bool DoTurn(int dir);

    REAL                          trueDistance_;                                                                                // distance predicted as best as we can
private:
    // virtual REAL            DoGetDistanceSinceLastTurn  (                               ) const     ;   //!< returns the distance since the last turn

    virtual nDescriptor& CreatorDescriptor() const;

    const gCycleMovement* parent_;                                                                                              // the cycle that is extrapolated
};

class gCycleChatBot;

#ifndef DEDICATED
class gCycleWallsDisplayListManager
{
    friend class gNetPlayerWall;

public:
    gCycleWallsDisplayListManager();

    static bool CannotHaveList( REAL distance, gCycle const * cycle );

    void RenderAll( eCamera const * camera, gCycle * cycle );
    bool Walls() const
    {
        return wallList_ || wallsWithDisplayList_;
    }

    void Clear( int inhibit = 0 )
    {
        displayList_.Clear( inhibit );
    }
private:
    gNetPlayerWall *                wallList_;                      
    gNetPlayerWall *                wallsWithDisplayList_;          
    rDisplayList                    displayList_;                   
    REAL                            wallsWithDisplayListMinDistance_; 
    int                             wallsInDisplayList_;            
};
#endif

// a complete lightcycle
class gCycle: public gCycleMovement
{
    friend class gPlayerWall;
    friend class gNetPlayerWall;
    friend class gDestination;
    friend class gCycleWallRenderer;

    REAL spawnTime_;    
    REAL lastTimeAnim;  

    REAL timeCameIntoView;

    friend class gCycleChatBot;
    std::auto_ptr< gCycleChatBot > chatBot_;

    bool dropWallRequested_; 
public:
    eCoord            lastGoodPosition_;    // the location of the last known good position

    REAL skew,skewDot;                                          // leaning to the side

    bool                                mp;                             // use moviepack or not?

    rModel *body,*front,*rear,
    *customModel;

    gTextureCycle  *wheelTex,*bodyTex;
    gTextureCycle  *customTexture;

    eCoord rotationFrontWheel,rotationRearWheel;        // wheel position (rotation)
    REAL   heightFrontWheel,heightRearWheel;            // wheel (suspension)
public:
    //REAL      brakingReservoir; // reservoir for braking. 1 means full, 0 is empty

    static uActionPlayer s_brake;
    gCycleMemory memory;

    gRealColor color_;
    gRealColor trailColor_;

    // smooth corrections
    // pos is always the correct simulated position; the displayed position is calculated as pos + correctPosSmooth
    // and correctPosSmooth decays with time.
    eCoord correctPosSmooth;
    eCoord predictPosition_; 

    // every frame, a bit of this variable is taken away and added to the step the cycle makes.
    REAL correctDistanceSmooth;

private:
    void TransferPositionCorrectionToDistanceCorrection();

#ifndef DEDICATED
    gCycleWallsDisplayListManager displayList_;                     
#endif

    tCHECKED_PTR(gNetPlayerWall)        currentWall;                    
    tCHECKED_PTR(gNetPlayerWall)        lastWall;                       
    tCHECKED_PTR(gNetPlayerWall)        lastNetWall;                    

    // for network prediction
    SyncData                                                                    lastSyncMessage_;       // the last sync message the cycle received
    tJUST_CONTROLLED_PTR<gCycleExtrapolator>    extrapolator_;          // the cycle copy used for extrapolation
    bool                                                                                resimulate_;            // flag indicating that a new extrapolation should be started

    void        ResetExtrapolator();                                                    // resets the extrapolator to the last known state
    bool        Extrapolate( REAL dt );                                                 // simulate the extrapolator at higher speed
    void        SyncFromExtrapolator();                                                 // take over the extrapolator's data

    virtual void OnNotifyNewDestination(gDestination *dest);   
    virtual void OnDropTempWall        ( gPlayerWall * wall, eCoord const & position, eCoord const & direction );   

    //  unsigned short currentWallID;

    nTimeRolling nextSync, nextSyncOwner;

    void MyInitAfterCreation();

    void SetCurrentWall(gNetPlayerWall *w);

    void PreparePredictPosition( gPredictPositionData & data ); 
    REAL CalculatePredictPosition( gPredictPositionData & data ); 
protected:
    virtual ~gCycle();

    virtual void OnRemoveFromGame(); // called when the cycle is physically removed from the game

    virtual void OnRoundEnd();    

    // virtual REAL            DoGetDistanceSinceLastTurn  (                               ) const     ;   //!< returns the distance since the last turn
public:
    virtual void Die ( REAL time )  ;  
    void KillAt( const eCoord& pos );  

    int WindingNumber() const {return windingNumber_;}

    virtual bool            Vulnerable              ()                                    const     ;   

    // bool CanMakeTurn() const { return pendingTurns <= 0 && lastTime >= nextTurn; }

    virtual void InitAfterCreation();
    gCycle(eGrid *grid, const eCoord &pos,const eCoord &dir,ePlayerNetID *p=NULL);

    static      void    SetWallsStayUpDelay             ( REAL delay );                         
    static      void    SetWallsLength                  ( REAL length);                         
    static      void    SetExplosionRadius              ( REAL radius);                         

    static      REAL    WallsStayUpDelay()       { return wallsStayUpDelay;     }       
    static      REAL    WallsLength()            { return wallsLength;          }       
    REAL                MaxWallsLength() const;                             
    REAL                ThisWallsLength() const;                            
    REAL                WallEndSpeed() const;                               
    static      REAL    ExplosionRadius()        { return explosionRadius;      }       

    bool    IsMe( eGameObject const * other ) const;              

    // the network routines:
    gCycle(nMessage &m);
    virtual void WriteCreate(nMessage &m);
    virtual void WriteSync(nMessage &m);
    virtual void ReadSync(nMessage &m);
    virtual void RequestSyncOwner(); 
    virtual void RequestSyncAll(); 

    virtual void SyncEnemy ( const eCoord& begWall );    
    // virtual void SyncFriend( const eCoord& begWall );    //!< handle sync message for enemy cycles

    virtual void ReceiveControl(REAL time,uActionPlayer *Act,REAL x);
    virtual void PrintName(tString &s) const;
    virtual bool ActionOnQuit();

    virtual nDescriptor &CreatorDescriptor() const;
    virtual bool SyncIsNew(nMessage &m);
    //virtual bool ClearToTransmit(int user) const;

    virtual bool Timestep(REAL currentTime);
    virtual bool TimestepCore(REAL currentTime,bool calculateAcceleration = true);

    virtual void InteractWith(eGameObject *target,REAL time,int recursion=1);

    virtual bool EdgeIsDangerous(const eWall *w, REAL time, REAL a) const;

    virtual void PassEdge(const eWall *w,REAL time,REAL a,int recursion=1);

    virtual REAL PathfindingModifier( const eWall *w ) const;

    virtual bool Act(uActionPlayer *Act,REAL x);

    virtual bool DoTurn(int dir);
    void DropWall( bool buildNew=true );                                    

    // void Turbo(bool turbo);

    virtual void Kill();

    const eTempEdge* Edge();
    const gPlayerWall* CurrentWall();
    // const gPlayerWall* LastWall();

#ifndef DEDICATED
    virtual void Render(const eCamera *cam);
    virtual void Render2D(tCoord scale) const;

    virtual void RenderName( const eCamera *cam );

    virtual bool RenderCockpitFixedBefore(bool primary=true);

    //virtual void SoundMix(unsigned char *dest,unsigned int len,
    //                      int viewer,REAL rvol,REAL lvol);
#endif

    virtual eCoord CamPos() const;
    virtual eCoord PredictPosition() const;
    virtual eCoord  CamTop() const;
    virtual eCoord CamDir()  const;
    virtual eCoord Direction()  const;

    virtual void RightBeforeDeath( int numTries );

#ifdef POWERPAK_DEB
    virtual void PPDisplay();
#endif

    static      void    PrivateSettings();                                                                      // initiate private setting items

    //  virtual void AddRef();
    //  virtual void Release();

private:
    static      REAL    wallsStayUpDelay;                       
    static      REAL    wallsLength;                            
    static      REAL    explosionRadius;                        
    gJoystick *     joystick_;                  
protected:
    virtual     bool                    DoIsDestinationUsed             ( const gDestination *  dest            ) const         ;       
};

#endif

---