src/tron/gWinZone.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  
***************************************************************************

*/

#ifndef ArmageTron_WinZone_H
#define ArmageTron_WinZone_H

#include "eNetGameObject.h"

#include <vector>

#include "gCycle.h"
#include "rColor.h"
#include "tFunction.h"

// zone expansion speed and size
extern REAL sg_expansionSpeed;
extern REAL sg_initialSize;

// fortress conquest rates
extern REAL sg_conquestDecayRate;
extern REAL sg_conquestRate;
extern REAL sg_defendRate;

class eTeam;

class gZone: public eNetGameObject
{
public:
    gZone(eGrid *grid, const eCoord &pos); 
    gZone(nMessage &m);                    
    ~gZone();                              

    void SetReferenceTime();               

    gZone &         SetPosition         ( eCoord const & position );    
    eCoord          GetPosition         ( void ) const;                 
    gZone const &   GetPosition         ( eCoord & position ) const;    
    gZone &         SetVelocity         ( eCoord const & velocity );    
    eCoord          GetVelocity         ( void ) const;                 
    gZone const &   GetVelocity         ( eCoord & velocity ) const;    
    gZone &         SetRadius           ( REAL radius );                    
    REAL            GetRadius           ( void ) const;                 
    gZone const &   GetRadius           ( REAL & radius ) const;            
    gZone &         SetExpansionSpeed   ( REAL expansionSpeed );            
    REAL            GetExpansionSpeed   ( void ) const;                 
    gZone const &   GetExpansionSpeed   ( REAL & expansionSpeed ) const;
    gZone &         SetRotationSpeed    ( REAL rotationSpeed );         
    REAL            GetRotationSpeed    ( void ) const;                 
    tCoord const &  GetRotation    ( void ) const;                      
    gZone const &   GetRotationSpeed    ( REAL & rotationSpeed ) const; 
    gZone &         SetRotationAcceleration( REAL rotationAcceleration );               
    REAL            GetRotationAcceleration( void ) const;                              
    gZone const &   GetRotationAcceleration( REAL & rotationAcceleration ) const;       
    rColor const &  GetColor( void ) const;     
protected:
    rColor color_;           
    REAL createTime_;            

    REAL referenceTime_;         
    tFunction posx_;             
    tFunction posy_;             
    tFunction radius_;           
    tFunction rotationSpeed_;    
    eCoord    rotation_;         

    virtual bool Timestep(REAL currentTime);     
    virtual void OnVanish();                     

private:
    virtual void WriteCreate(nMessage &m); 
    virtual void WriteSync(nMessage &m);   
    virtual void ReadSync(nMessage &m);    

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

    virtual void OnEnter( gCycle *target, REAL time ); 

    virtual nDescriptor& CreatorDescriptor() const; 

    REAL Radius() const;           

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

    virtual bool RendersAlpha() const;

    inline REAL EvaluateFunctionNow( tFunction const & f ) const;  
    inline void SetFunctionNow( tFunction & f, REAL value ) const; 
};

// all the following zones are hacks until the full zone system is in place

class gWinZoneHack: public gZone
{
public:
    gWinZoneHack(eGrid *grid, const eCoord &pos); 
    gWinZoneHack(nMessage &m);                    
    ~gWinZoneHack();                              

protected:
private:
    virtual void OnEnter( gCycle *target, REAL time ); 
};

class gDeathZoneHack: public gZone
{
public:
    gDeathZoneHack(eGrid *grid, const eCoord &pos );              
    gDeathZoneHack(nMessage &m);                                  
    ~gDeathZoneHack();                                            

protected:
private:
    virtual void OnEnter( gCycle *target, REAL time ); 
};

class gBaseZoneHack: public gZone
{
public:
    gBaseZoneHack(eGrid *grid, const eCoord &pos );               
    gBaseZoneHack(nMessage &m);                                   
    ~gBaseZoneHack();                                             

private:
    virtual bool Timestep(REAL currentTime);     

    virtual void OnEnter( gCycle *target, REAL time ); 
    virtual void OnVanish();                           
    virtual void OnConquest();                         
    virtual void CheckSurvivor();                      

    static void CountZonesOfTeam( eGrid const * grid, eTeam * otherTeam, int & count, gBaseZoneHack * & farthest ); 

    REAL conquered_;                       
    int enemiesInside_;                     
    int ownersInside_;                      

    bool onlySurvivor_;                     

    typedef std::vector< tJUST_CONTROLLED_PTR< eTeam > > TeamArray;
    TeamArray enemies_;                     
    REAL lastEnemyContact_;                 

    REAL teamDistance_;                     

    bool touchy_;                           

    enum State
    {
        State_Safe,        
        State_Conquering,  
        State_Conquered    
    };
    State currentState_;   

    REAL lastSync_;        
};

gZone * sg_CreateWinDeathZone( eGrid * grid, const eCoord & pos );

#endif

---