src/tron/cockpit/cCockpit.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.

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

*/


#include "tXmlParser.h"
#include "tSafePTR.h"
#include "ePlayer.h"
#include <deque>
#include <list>
#include <map>
#include <set>

#include <memory>
#include <typeinfo>

#include "tValue.h"

#ifndef ARMAGETRON_COCKPIT_H
#define ARMAGETRON_COCKPIT_H

#ifndef DEDICATED

#define FOREACH_COCKPIT(cockpit) for(std::list<cCockpit *>::const_iterator cockpit = cCockpit::Cockpits().begin(); cockpit != cCockpit::Cockpits().end(); ++cockpit)

namespace cWidget {
class Base;
}
class ePlayerNetID;
class gCycle;

class cCockpit : public tXmlResource, public eCockpitPrototype {
    static std::list<cCockpit *> m_Cockpits;
public:
    static std::list<cCockpit *> const &Cockpits() {return m_Cockpits;}

    enum cockpit_type {
        VIEWPORT_TOP,
        VIEWPORT_CYCLE,
        VIEWPORT_ALL
    }; 

private:
    cockpit_type m_Type;
public:

    enum cameras {
        custom        = 0001,
        follow        = 0002,
        free          = 0004,
        in            = 0010,
        server_custom = 0020,
        smart         = 0040,
        mer           = 0100,
        all           = 0177
    }; 

    cCockpit(cockpit_type type); 
    ~cCockpit(); 

    void SetPlayer(ePlayer *player); 
    void SetCycle(gCycle const &cycle); 

    // Example how to call this:
    // theHud.SetViewMode(cCockpit::custom
    //                  & cCockpit::server_custom);
    // See the top of this file for all modes
    void SetCam(int Cam) { m_Cam = Cam; }; 
    void AddEventHandler(int id, cWidget::Base *widget); 

    void Render(); 
    //void RenderRootwindow(); //!< Renders the main viewport (all widgets that belong to the entire screen)
    //void RenderPlayer(float factor); //!< Renders all widgets that belong to the currently active player

    //void RenderCycle(gCycle const &cycle); //!< Render the cockpit elements above a cycle

    void ProcessCockpit(void); 

    ePlayer *GetPlayer(); 
    gCycle *GetFocusCycle(void); 
private:
    static cCockpit* _instance; 

    int m_Cam; 
    ePlayer* m_Player; 
    ePlayerNetID *m_FocusPlayer; 
    ePlayerNetID *m_ViewportPlayer; 
    gCycle *m_FocusCycle; 
    typedef std::vector<tJUST_CONTROLLED_PTR< cWidget::Base> > widget_list_t;
    widget_list_t m_Widgets; 

    void ProcessWidgets(node cur); 
    std::auto_ptr<cWidget::Base> ProcessWidgetType(node cur); 

    //this should be done by the cWidget::Base class one day
    void ProcessWidgetCamera(node cur, cWidget::Base &widget); 
    void ProcessWidgetCore(node cur, cWidget::Base &widget); 
    void ProcessWidget(node cur, cWidget::Base &widget); 

    void ClearWidgets(void); 

public:


    //callback functions for subwidgets
    tValue::BasePtr cb_CurrentRubber(void);           
    tValue::BasePtr cb_CurrentAcceleration(void);           
    tValue::BasePtr cb_CurrentPing(void);             
    tValue::BasePtr cb_CurrentSpeed(void);            
    tValue::BasePtr cb_MaxSpeed(void);                
    tValue::BasePtr cb_CurrentBrakingReservoir(void); 

    tValue::BasePtr cb_AliveEnemies(void);            
    tValue::BasePtr cb_AliveTeammates(void);          

    tValue::BasePtr cb_Framerate(void);               
    tValue::BasePtr cb_RunningTime(void);             
    tValue::BasePtr cb_CurrentTimeMinutes(void);      
    tValue::BasePtr cb_CurrentTimeHours(void);        
    tValue::BasePtr cb_CurrentTimeHours12h(void);     
    tValue::BasePtr cb_CurrentTimeSeconds(void);      

    tValue::BasePtr cb_CurrentScore(void);            
    tValue::BasePtr cb_TopScore(void);                
    tValue::BasePtr cb_CurrentScoreTeam(void);            
    tValue::BasePtr cb_TopScoreTeam(void);                
    tValue::BasePtr cb_FastestSpeed(void);            
    tValue::BasePtr cb_FastestName(void);             
    tValue::BasePtr cb_FastestSpeedRound(void);            
    tValue::BasePtr cb_FastestNameRound(void);             

    tValue::BasePtr cb_TimeToImpactFront(void);             
    tValue::BasePtr cb_TimeToImpactRight(void);             
    tValue::BasePtr cb_TimeToImpactLeft(void);             
    tValue::BasePtr cb_CurrentSong(void);                   
    tValue::BasePtr cb_CurrentName(void);                   
    tValue::BasePtr cb_CurrentColoredName(void);                    
    tValue::BasePtr cb_CurrentPosX(void);                   
    tValue::BasePtr cb_CurrentPosY(void);                   

    static bool ProcessKey1(float i=0);
    static bool ProcessKey2(float i=0);
    static bool ProcessKey3(float i=0);
    static bool ProcessKey4(float i=0);
    static bool ProcessKey5(float i=0);
    std::multimap<int, cWidget::Base *> m_EventHandlers;
    bool HandleEvent(int id, bool state);

    void Readjust(void); 
    void Readjust(float factor); 
};

extern const std::map<tString, tValue::Callback<cCockpit>::cb_ptr> stc_callbacks;
extern std::set<tString> stc_forbiddenCallbacks;

#endif
#endif

---