cockpit_generic.h

Go to the documentation of this file.

#ifndef _COCKPIT_GENERIC_H_
#define _COCKPIT_GENERIC_H_
#include "xml_support.h"
#include "cmd/container.h"
#include <vector>
#include "gfx/vec.h"
#include "vsfilesystem.h"
using namespace XMLSupport;
enum VIEWSTYLE
{
    CP_FRONT, CP_BACK, CP_LEFT, CP_RIGHT, CP_VIEWTARGET, CP_PANINSIDE, CP_CHASE, CP_PAN, CP_PANTARGET, CP_TARGET, CP_FIXED,
    CP_FIXEDPOS, CP_FIXEDPOSTARGET, CP_NUMVIEWS
};
#ifdef NETCOMM_WEBCAM
#define MAXVDUS (13)
#else
#define MAXVDUS (12)
#endif
class Unit;
class Camera;
class Animation;
class NavigationSystem;
namespace Radar
{
    class Sensor;
}
#include "in.h"
#include "cmd/images.h"
class Cockpit
{
protected:
    enum VIEWSTYLE view;
    int   currentcamera;
    float radar_time;
    float gauge_time[UnitImages < void > ::NUMGAUGES];

    float StartArmor[9]; //short fix

    float maxfuel, maxhull;
    UnitContainer parent;
    UnitContainer parentturret;
    int   unitfaction;
    float shakin;
    std::string unitmodname;
//Gauge *gauges[UnitImages::NUMGAUGES];
//0 means no autopilot...positive autopilto in progress
    float autopilot_time;
    UnitContainer autopilot_target; //usually null
    float cockpit_offset, viewport_offset;
    virtual void LoadXML( const char *file ) {}
    virtual void LoadXML( VSFileSystem::VSFile &f ) {}
    static void beginElement( void *userData, const XML_Char *name, const XML_Char **atts );
    static void endElement( void *userData, const XML_Char *name );
    virtual void beginElement( const string &name, const AttributeList &attributes ) {}
    virtual void endElement( const string &name ) {}
    virtual void Delete();
    virtual void DrawNavigationSymbol( const Vector &loc, const Vector &p, const Vector &q, float size ) {}
    virtual float computeLockingSymbol( Unit *par )
    {
        return 1;
    }
    virtual void DrawTargetBox() {}
    virtual void DrawTargetBoxes(const Radar::Sensor&) {}
    virtual void DrawTurretTargetBoxes() {}
    virtual void DrawTacticalTargetBox() {}
    virtual void DrawRadar(const Radar::Sensor&) {}
    virtual void DrawGauges( Unit *un ) {}
    float  cockpit_time;
    bool   ejecting;
    bool   going_to_dock_screen;
    int    partial_number_of_attackers;

private:
    std::vector< std::string > unitfilename;
    std::vector< std::string > unitsystemname;
    std::vector< std::string > unitbasename;
    
public:
    double secondsWithZeroEnergy;
    int    number_of_attackers;
    unsigned int retry_dock;
    double TimeOfLastCollision;
    char   jumpok;
    virtual void setTargetLabel( const string &msg ) {}
    virtual string getTargetLabel()
    {
        return string();
    }
    void updateAttackers();
    static bool tooManyAttackers(); //checks config file and declares if too many folks are attacking any of the players (to avoid expensive tests where unnecessary).
    virtual void ReceivedTargetInfo() {}
    bool autoInProgress()
    {
        return autopilot_time > 0;
    }
    bool unitInAutoRegion( Unit *un );
    
    void SetView( const enum VIEWSTYLE tmp )
    {
        view = tmp;
    }
    enum VIEWSTYLE GetView()
    {
        return view;
    }
    virtual void InitStatic();
    virtual void Shake( float amt, int level /*0 = shield, 1 = armor 2 = hull*/ ) {}
    float godliness;
    virtual int Autopilot( Unit *target );
    void RestoreGodliness();
    virtual void RestoreViewPort() {}
    
    std::string& GetUnitFileName(unsigned int which = 0)
    {
        while ( which >= unitfilename.size() )
            unitfilename.push_back("");
        return unitfilename[which];
    }
    
    std::string& GetUnitSystemName(unsigned int which = 0)
    {
        while ( which >= unitsystemname.size() )
            unitsystemname.push_back("");
        return unitsystemname[which];
    }
    
    std::string& GetUnitBaseName(unsigned int which = 0)
    {
        while ( which >= unitbasename.size() )
            unitbasename.push_back("");
        return unitbasename[which];
    }

    const std::string& GetUnitFileName(unsigned int which = 0) const;
    const std::string& GetUnitSystemName(unsigned int which = 0) const;
    const std::string& GetUnitBaseName(unsigned int which = 0) const;
    
    void RemoveUnit(unsigned int which = 0);
    
    static std::string MakeBaseName(const Unit *base);

    std::string GetUnitModifications()
    {
        return unitmodname;
    }
    
    size_t GetNumUnits() const
    {
        return unitfilename.size();
    }
    
    void PackUnitInfo(vector< std::string > &info) const;

    void UnpackUnitInfo(vector< std::string > &info);

    std::string communication_choices;
    float credits; //how much money player has
    float zoomfactor;
    Cockpit( const char *file, Unit *parent, const std::string &pilotname );
    virtual ~Cockpit();
    virtual float LookupTargetStat( int stat, Unit *target )
    {
        return 1;
    }
    virtual void Init( const char *file, bool defaultCockpit = false );
    void recreate( const std::string &pilotname );
//unsigned int whichcockpit;//0 is the first player, 1 is the second and so forth
    class Flightgroup*fg;
    class StarSystem*activeStarSystem; //used for context switch in Universe
    virtual void SetParent( Unit *unit, const char *filename, const char *unitmodname, const QVector &startloc );
    Unit * GetParent()
    {
        return parent.GetUnit();
    }
    Unit * GetSaveParent();
    virtual void Draw() {}
    bool Update(); //respawns and the like. Returns true if starsystem was reloaded
    virtual void UpdAutoPilot();
    virtual void SetupViewPort( bool clip = true ) {}
    virtual int getVDUMode( int vdunum )
    {
        return 0;
    }
    virtual void VDUSwitch( int vdunum ) {}
    virtual void ScrollVDU( int vdunum, int howmuch ) {}
    virtual void ScrollAllVDU( int howmuch ) {}
    virtual int getScrollOffset( unsigned int whichtype )
    {
        return 1;
    }
    virtual void SelectProperCamera() {}
    virtual void Eject();
    virtual void EjectDock();
    virtual void SetInsidePanYawSpeed( float speed );
    virtual void SetInsidePanPitchSpeed( float speed );
    static void Respawn( const KBData&, KBSTATE ) {}
    static void SwitchControl( const KBData&, KBSTATE ) {}
    static void ForceSwitchControl( const KBData&, KBSTATE ) {}
    static void TurretControl( const KBData&, KBSTATE ) {}
    virtual void SetCommAnimation( Animation *ani, Unit *un ) {}
    virtual void SetStaticAnimation() {}
    class SaveGame*savegame;
    virtual NavigationSystem * AccessNavSystem()
    {
        return NULL;
    }
    virtual std::string GetNavSelectedSystem()
    {
        return "";
    }
    virtual Camera * AccessCamera()
    {
        return NULL;
    }
    virtual Camera * AccessCamera( int )
    {
        return NULL;
    }
    virtual void SelectCamera( int ) {}
    virtual void SetViewport() {}
    virtual void visitSystem( std::string systemName );
    virtual bool SetDrawNavSystem( bool )
    {
        return false;
    }
    virtual bool CanDrawNavSystem()
    {
        return false;
    }
    virtual bool DrawNavSystem()
    {
        return false;
    }
    virtual bool CheckCommAnimation( Unit *un )
    {
        return false;
    }
    // Cockpit events
    virtual void OnPauseBegin() {}
    virtual void OnPauseEnd() {}
    virtual void OnDockEnd(Unit *, Unit *) {}
    virtual void OnJumpBegin(Unit *) {}
    virtual void OnJumpEnd(Unit *) {}
};
#endif