src/network/nConfig.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_NET_CONFIGURATION_H
#define ArmageTron_NET_CONFIGURATION_H

#include "tConfiguration.h"
#include "nNetwork.h"

template<class T> inline bool sn_compare(T&a, T&b)
{
    return (a!=b);
}

inline bool sn_compare(float&a, float &b)
{
    return (1000 * fabs(a-b) > fabs(a) + fabs(b));
}

class nConfItemBase;

class nIConfItemWatcher
{
public:
    nIConfItemWatcher( nConfItemBase & item );            

    inline void Change( bool nonDefault );                
    inline bool Writable() const;                         
protected:
    virtual ~nIConfItemWatcher()=0;                       

    nConfItemBase & watched_;                             
private:
    virtual void OnChange( bool nonDefault ) = 0;         
    virtual bool DoWritable() const = 0;                  

    // disable copying and default construction
    nIConfItemWatcher();            
    nIConfItemWatcher(nIConfItemWatcher const &);            
    nIConfItemWatcher& operator=(nIConfItemWatcher const &); 
};

class nConfItemBase:public virtual tConfItemBase
{
    friend class nIConfItemWatcher;
private:
    double lastChangeTime_;             
    unsigned long lastChangeMessage_;   
    nIConfItemWatcher * watcher_;       
protected:
    nConfItemBase();
public:
    //  nConfItemBase(const char *title,const char *help);
    nConfItemBase(const char *title);
    virtual ~nConfItemBase();

    virtual void NetReadVal(nMessage &m)=0;
    virtual void NetWriteVal(nMessage &m)=0;

    static void s_GetConfigMessage(nMessage &m);

    virtual void WasChanged(bool nonDefault);

    virtual bool Writable();

    static void s_SendConfig(bool force=true, int peer=-1);
    void          SendConfig(bool force=true, int peer=-1);

    static void s_RevertToDefaults();       
    inline void RevertToDefaults();         

    static void s_SaveValues();             
    inline void SaveValue();                

    static void s_RevertToSavedValues();    
    inline void RevertToSavedValue();       
private:
    virtual void OnRevertToDefaults()=0;      

    virtual void OnSaveValue()=0;             
    virtual void OnRevertToSavedValue()=0;    
};


template<class T> class nConfItem
            : public nConfItemBase,
            public tConfItem<T>,
            public virtual tConfItemBase
{
protected:
    nConfItem(T& t)
            :tConfItemBase(""), tConfItem<T>("", t),default_(t),saved_(t){}

public:
    nConfItem(const char *title,const char *help,T& t)
            :tConfItem<T>(t),
            tConfItemBase(title, help ),
            default_(t),
    saved_(t){}
    virtual ~nConfItem(){}


    virtual void NetReadVal(nMessage &m){
        T dummy;
        m >> dummy;
        if (sn_compare(dummy,*this->target)){
            if (printChange)
            {
                tOutput o;
                o.SetTemplateParameter(1, title);
                o.SetTemplateParameter(2, *this->target);
                o.SetTemplateParameter(3, dummy);
                o << "$nconfig_value_changed";
                con << con.ColorString(1,.3,.3) << o;
            }
            *this->target=dummy;
            this->ExecuteCallback();
            changed=true;
        }
    }

    virtual void NetWriteVal(nMessage &m){
        m << *this->target;
    }

    void Set( const T& newval )
    {
        bool changed = ( newval != *this->target );
        *this->target = newval;

        if ( changed )
        {
            WasChanged();
        }
    }

    virtual void OnRevertToDefaults()      
    {
        Set( default_ );
    }

    virtual void OnSaveValue()             
    {
        saved_ = *this->target;
    }

    virtual void OnRevertToSavedValue()    
    {
        Set( saved_ );
    }
private:
    void WasChanged()
    {
        nConfItemBase::WasChanged( ! (*this->target == default_) );
    }

    T default_;     
    T saved_;       
};

template<class T> class nSettingItem:public nConfItem<T>{
private:
public:
    //  nSettingItem(const char *title,const char *help,T& t)
    //    :nConfItem<T>(t), tConfItemBase(title, help){}
    //  virtual ~nSettingItem(){}

    nSettingItem(const char *title,T& t,tConfItemBase::callbackFunc *cb=0)
            :tConfItemBase(title, cb), nConfItem<T>(t){}
    virtual ~nSettingItem(){}

    virtual bool Save(){return false;}
};


class nConfItemLine:public nConfItem<tString>{
protected:
public:
    //  nConfItemLine(const char *title,const tOutput &help,tString &s)
    //    :nConfItem<tString>(s), tConfItemBase(title,help){};
    nConfItemLine(const char *title,tString &s);
#ifndef SWIG
    nConfItemLine(const char *title,tString &s, callbackFunc *cb);
#endif

    virtual ~nConfItemLine();

    virtual void ReadVal(std::istream &s);
};

enum nConfigItemBehavior
{
    Behavior_Nothing = 0, 
    Behavior_Revert = 1,  
    Behavior_Block = 2,   
    Behavior_Default = 3  
};

class nConfItemVersionWatcher;
tCONFIG_ENUM( nConfigItemBehavior );

class nConfItemVersionWatcher: public nIConfItemWatcher
{
public:
    enum Group
    {
        Group_Breaking,  
        Group_Bumpy,     
        Group_Annoying,  
        Group_Cheating,  
        Group_Visual,    

        Group_Max
    };

    typedef nConfigItemBehavior Behavior;

    nConfItemVersionWatcher( nConfItemBase & item, Group group, int min, int max = -1 );          
    virtual ~nConfItemVersionWatcher();                      

    static void AdaptVersion( nVersion & version );          
    static void OnVersionChange( nVersion const & version ); 

    Behavior GetBehavior( void ) const;                      
    nConfItemVersionWatcher const & GetBehavior( Behavior & behavior ) const;   

    void FillTemplateParameters( tOutput & o ) const;        
private:
    virtual void OnChange( bool nonDefault );                
    virtual bool DoWritable() const;                         

    nVersion version_;                                       
    bool nonDefault_;                                        
    bool reverted_;                                          

    Group group_;                                            
    Behavior overrideGroupBehavior_;                         
    tSettingItem< Behavior > overrideGroupBehaviorConf_;     
};

template<class T> class nSettingItemWatched
{
public:
    typedef nConfItemVersionWatcher::Group Group;

    // constructor
    nSettingItemWatched( char const * title, T & value, Group group, int min, int max = -1 )
            : setting_( title, value )
            , watcher_( setting_, group, min, max )
    {
    }

    void Set( T const & value )
    {
        this->setting_.Set( value );
    }
private:
    nSettingItem< T > setting_;
    nConfItemVersionWatcher watcher_;
};

// *******************************************************************************************
// *
// *    Change
// *
// *******************************************************************************************
// *******************************************************************************************

void nIConfItemWatcher::Change( bool nonDefault )
{
    this->OnChange( nonDefault );
}

// *******************************************************************************************
// *
// *    RevertToDefaults
// *
// *******************************************************************************************
// *******************************************************************************************

void nConfItemBase::RevertToDefaults( void )
{
    // inform watcher
    if (this->watcher_ )
        this->watcher_->Change( false );

    // reset last change information
    lastChangeMessage_ = 0;
    lastChangeTime_ = -1000000;

    this->OnRevertToDefaults();
}

// *******************************************************************************************
// *
// *    SaveValue
// *
// *******************************************************************************************
// *******************************************************************************************

void nConfItemBase::SaveValue( void )
{
    this->OnSaveValue();
}

// *******************************************************************************************
// *
// *    RevertToSavedValue
// *
// *******************************************************************************************
// *******************************************************************************************

void nConfItemBase::RevertToSavedValue( void )
{
    this->OnRevertToSavedValue();
}

// *******************************************************************************************
// *
// *    Writable
// *
// *******************************************************************************************
// *******************************************************************************************

bool nIConfItemWatcher::Writable( void ) const
{
    return this->DoWritable();
}

#endif

---