vegaevo_doc/html/cockpit_8h_source.html

// -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*-


#ifndef _COCKPIT_H_

#define _COCKPIT_H_

#include "gfx/cockpit_generic.h"

#include "gfxlib.h"

#include "gfxlib_struct.h"

#include <vector>

#include <list>

using namespace XMLSupport;

class TextPlane;

class VSSprite;

class Gauge;

class Unit;

class NavigationSystem;

#include "radar/radar.h"

#include "radar/sensor.h"

#include "vdu.h"

#include "camera.h"

#include "physics.h"

#include "nav/navscreen.h"

#define NUM_CAM CP_NUMVIEWS


struct soundContainer   //used to contain static sounds that will only be

{

    //created once and will get deleted automatically

    int sound;

    soundContainer()

    {

        sound = -2;

    }

    void loadsound( string sooundfile, bool looping = false );

    void playsound();

    ~soundContainer();

};


struct soundArray

{

    soundContainer *ptr;

    soundArray()

    {

        ptr = NULL;

    }

    void deallocate()

    {

        if (ptr != NULL) {

            delete[] ptr;

            ptr = NULL;

        }

    }

    void allocate( int siz )

    {

        deallocate();

        ptr = new soundContainer[siz];

    }

    ~soundArray()

    {

        deallocate();

    }

};


class GameCockpit : public Cockpit

{

    Camera    cam[NUM_CAM];


    float     insidePanYaw, insidePanPitch;

    float     insidePanYawSpeed, insidePanPitchSpeed;


    float     vdu_time[MAXVDUS];

    std::list< Matrix >headtrans;

    float     shake_time;

    int       shake_type;

    Vector    oaccel;

    float     smooth_fov;

    float     last_locktime;

    float     last_mlocktime;

    bool      armor8;

    bool      shield8;

    std::vector< class Mesh* >mesh;

    int       soundfile;

    VSSprite *Pit[4];

    VSSprite *radarSprites[2];

    std::auto_ptr<Radar::Display> radarDisplay;

    std::vector< VDU* >vdu;

    std::string targetLabel;

    void      *labeledTargetUnit;

    GFXColor   textcol;

    TextPlane *text;

    Gauge     *gauges[UnitImages < void > ::NUMGAUGES];

    std::vector< VSSprite* >Panel;

    bool     draw_all_boxes;

    bool     draw_line_to_target, draw_line_to_targets_target;

    bool     draw_line_to_itts;

    bool     always_itts;

    bool     steady_itts;

    //colors of blips/targetting boxes

    GFXColor friendly, enemy, neutral, targeted, targetting, planet;


    float  projection_limit_x, projection_limit_y;

    float  inv_screen_aspect_ratio; //Precomputed division 1 / g_game.aspect.

    virtual void SetParent( Unit *unit, const char *filename, const char *unitmodname, const QVector &startloc );

    void LoadXML( const char *file );

    void LoadXML( VSFileSystem::VSFile &f );

    void beginElement( const string &name, const AttributeList &attributes );

    void endElement( const string &name );

    void Delete();

    void DrawNavigationSymbol( const Vector &loc, const Vector &p, const Vector &q, float size );

    float computeLockingSymbol( Unit *par );

    void DrawTargetBox(const Radar::Sensor&);

    void DrawTargetBoxes(const Radar::Sensor&);

    void DrawTurretTargetBoxes(const Radar::Sensor&);

    void DrawTacticalTargetBox(const Radar::Sensor&);

    void DrawCommunicatingBoxes();

    void DrawRadar(const Radar::Sensor&);

    void DrawTargetGauges( Unit *target );

    void DrawGauges( Unit *un );

    NavigationSystem ThisNav;

    //Draw the arrow pointing to the target.

    void DrawArrowToTarget(const Radar::Sensor&, Unit*);

    void DrawArrowToTarget(const Radar::Sensor&, Vector LocalCoordinates);

    void updateRadar(Unit * un);

public:

    std::string textMessage;

    bool editingTextMessage;

    std::string autoMessage;

    float autoMessageTime;

    virtual void setTargetLabel( const string &msg );

    virtual string getTargetLabel();

    void ReceivedTargetInfo();

    static void NavScreen( const KBData&, KBSTATE k ); //scheherazade

    static string getsoundending( int which = 0 );

    static string getsoundfile( string filename );

    void InitStatic();

    void Shake( float amt, int level /*0= shield 1=armor 2=hull*/ );

    int Autopilot( Unit *target );

    void RestoreViewPort();

    GameCockpit( const char *file, Unit *parent, const std::string &pilotname );

    ~GameCockpit();

    float LookupTargetStat( int stat, Unit *target );

    float LookupUnitStat( int stat, Unit *target );

    void Init( const char *file );

    void Draw();

    //void Update();//respawns and the like.

    void UpdAutoPilot();

    void SetupViewPort( bool clip = true );

    int getVDUMode( int vdunum );

    void VDUSwitch( int vdunum );

    void ScrollVDU( int vdunum, int howmuch );

    void ScrollAllVDU( int howmuch );

    int getScrollOffset( unsigned int whichtype );

    void SelectProperCamera();

    void Eject();

    void EjectDock();

    static void Respawn( const KBData &, KBSTATE );

    static void SwitchControl( const KBData &, KBSTATE );

    static void ForceSwitchControl( const KBData &, KBSTATE );

    static void TurretControl( const KBData &, KBSTATE );

    void SetSoundFile( std::string sound );

    int GetSoundFile()

    {

        return soundfile;

    }

    void SetCommAnimation( Animation *ani, Unit *un );

    void SetStaticAnimation();

    NavigationSystem * AccessNavSystem()

    {

        return &ThisNav;

    }

    virtual std::string GetNavSelectedSystem();

    Camera * AccessCamera()

    {

        return &cam[currentcamera];

    }

    Camera * AccessCamera( int );

    void SelectCamera( int );

    void SetViewport()

    {

        cam[currentcamera].UpdateGFX();

    }


    virtual bool SetDrawNavSystem( bool );

    virtual bool CanDrawNavSystem();

    virtual bool DrawNavSystem();

    virtual bool CheckCommAnimation( Unit *un );

    virtual void visitSystem( std::string systemName );

    void AutoLanding();

    void DoAutoLanding(Unit *, Unit *);


    virtual void SetInsidePanYawSpeed( float speed );

    virtual void SetInsidePanPitchSpeed( float speed );


    bool IsPaused() const;

    // Game is paused

    void OnPauseBegin();

    void OnPauseEnd();

    // Ship has undocked from station

    void OnDockEnd(Unit *station, Unit *unit);

    // Ship is jumping

    void OnJumpBegin(Unit *unit);

    void OnJumpEnd(Unit *unit);

};

#endif