globals.h

Go to the documentation of this file.

#pragma once

// RakNet
#include <WinSock2.h>
#include <WS2tcpip.h>
#include <Windows.h>

#include <d3dx9.h>

#include "../Common/server.h"
#include <vector>
#include "buildings.h"

//#define smoketestC
//#define treetestC

#define csC                                                             8.0f // For lower cloud layer texture span times 2km
#define farplaneC                                               384.0f//559.20f //5592.0f 8388.6f // Limitation of floating point for w
#define cutplaneC                                               256.0f//221.7f//370.0f //3954.1f 4150.0f // sqrtf(8388.6f^2/3)
#define nearplaneC                                              0.001f // ground out left window of MuVER is a good test
#define cockplanenearC                                  0.0001f // t-handles in cockpit are easy test of this
#define cockplanefarC                                   0.1f // far walls of sim bay are a good test at 0.025
#define maxpolyC                        26 // meshes
#define maxstarC                        10 // universe objects including docks now at end
#define maxdockC                                                3
#define cityscaleC                                              0.0039f
#define shipdockscaleC                                  0.00034822f
#define INTERIOR_SCALE                                  0.000006570188679f // km per unit

// synced with the server
#define Kg2Lbs                                                  2.2046226218f
#define ZeroCelsiusToKelvin                             273.15f
#define trimlimiterC                                    0.26179938779914943653855361527329f // in radians, 15� stop
#define MaxAcceleration                                 327.67f // G force max an occupant can have from containing ship

#define landformtextureC                                32
#define transitiontextureC                              31 // 1-31
#define shiptextureC                                    208
#define cockpittextureC                                 30 // E-series
#define docktextureC                                    68
#define runninglightsC                                  125 // 1 for lightsph, 9 for E-10, 15 for P-13, 8 for A-4, 8 for C-2, 10 for Muver, 15 for DIHV, 6 for steerhead, 16 for Phantom, 11 for Stratomaster, 5 for Mammoth, 12 for new Steerhead
#define citytextureC                                    175
#define RTStextureC                                             74
#define weaponanimateC                                  16
#define elmoAnimateC                                    4
#ifdef smoketestC
#define smoketrailC                                             128
#endif
#define firework1C                                              128
#define firework2C                                              92
#define firework3C                                              45
#define dihvanimateC                                    64
#define heartanimateC                                   29
#define buildingVBC                                             64
#define drawlistC                                               3205
#define visiblevertC                                    36528 // 98304 is absolute worst case, 7168 was best case with triangle fan, 30720 is my guess
#define cockpitvertC                                    13812 // new control tower 7293 // apartment is 13812!
#define dockvertC                                               2994 // max vertices for any dock (Cutter's is 2994)
#define cloudindicesC                                   19230

#define maxcompareC                                             2147483648 // for strobes, etc
#define maxcomparebitC                  32 // long storage format

#define vphelpC                                                 128

#define starsC                                                  18469
#define weaponfuzerreadyC                               0.85f//2.85f
#define weaponsinkerreadyC                              1.15f//2.85f
#define weaponlongarmreadyC                             2.85f//2.85f
#define MAX_RAINDROPS                                   8192
#define ACLlightningC                                   8

#define MAX_ANI                                                 15 // matched with Makeship
#define MAX_STEPS                                               10 // matched with Makeship

#define mu                                                              97386.86f // nothing to do with braking, this is for orbital parameters
#define skydomeC                                                194 // sides that make up the skyring

#define rhoOver2SlugsCuFt2                              0.003085346f // for aerodynamics, Earth number is 0.0011885 ... Vieneo is 2.596x
#define bulkElasticModulusDryAirGPa             142000.0f // for Mach and TAT calculations, based on Earth air composition!!
#define adiabaticIndex                                  1.4f // for Mach and TAT calculations, based on Earth air composition!!
#define gasConstantm2s2K                                286.0f // for Mach and TAT calculations, based on Earth air composition!!

#define ScaleHeightC                                    6.923432133f // for density calculation based on altitude
#define SeaLevelPressureMb                              2630.4f
#define MbPerFoot                                               0.03378431f // @ref https://sciencing.com/how-6183062-calculate-cabin-differential-pressure.html

#define radiusC                                                 2939.6f
#define gravityC                                                0.01127f // km/s/s
#define gForceKmSSC                                             0.00980665f
#define oneOvergForceKmSSC                              101.971621f
#define cloudTopsMslC                                   10.0f // this is actually the tops in MSL
#define cloudBufferMslC                                 9.5f // to keep them from going up down up down if they are hanging out at 10km
#define cloudTopsRadiusC                                2949.6f // 10 km
#define aftersdC                                                52.5f // kilometers between UCL and 63km

#define sunrC                                                   0.825f
#define sungC                                                   0.9125f
#define sunbC                                                   1.0f

#define D3DFVF_VERTEX                                   ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 )
#define D3DFVF_VERTEX2                                  ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX2 )
#define D3DFVF_SKYDOME                                  ( D3DFVF_XYZ | D3DFVF_DIFFUSE )
#define D3DFVF_RAINDROP                                 ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE )
#define D3DFVF_SKYRING                                  ( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1 )
#define D3DFVF_STATICSTARS                              ( D3DFVF_XYZ | D3DFVF_PSIZE | D3DFVF_DIFFUSE )
#define D3DFVF_NOPSIZE                                  ( D3DFVF_XYZ | D3DFVF_DIFFUSE )
#define D3DFVF_NONORMAL                                 ( D3DFVF_XYZ | D3DFVF_TEX1 )
#define D3DFVF_SCREEN                                   ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE )
#define D3DFVF_INSTRUMENT                               ( D3DFVF_XYZRHW | D3DFVF_TEX1 )
#define D3DFVF_INSTCOLOR                                ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ) // assay grid, weather radar
#define D3DFVF_LOCALGRID                                ( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1) // cloud base
#define D3DFVF_LOCALGRID2                               ( D3DFVF_XYZ | D3DFVF_DIFFUSE| D3DFVF_SPECULAR | D3DFVF_TEX1) // terrain

extern const D3DXVECTOR3 northpoleC;
extern const D3DXVECTOR3 eastpole;
extern const D3DXVECTOR3 meridian;
extern const D3DXVECTOR3 centerC;

extern D3DXVECTOR3 leveler, velocity;
extern float levelerpitch, levelerroll;
extern float f_AGL; // f_AGL must be 1.0f so the AGL tape isn't sitting on 0 in orbit
extern float f_ACL, f_BCL;

extern bool g_bRoad;
extern bool g_bAboveClouds;
extern float g_UniverseTime, f_Uphours;
extern unsigned char ourmoonC, BCLobjC, UCLobjC, ourstarC, ourplanetC;

extern float aoaRad, f_augment;
extern float f_MSL;
extern float groundSpeedKms, groundclose, grounditerate;
extern bool g_bOutside, g_bStrapon;

extern float dockprogress;
extern D3DXVECTOR3 dockMarker;
extern D3DXVECTOR3 dockInterface;

extern char dead;
extern float deathinhibit;

extern float bear, mark, bearVel, markVel;

extern bool g_bAugment;

extern float flasher, oldflasher;

extern DWORD m_dwSunViz;
extern float touchdownG;

extern short dihvanimate;
extern short olddihvanimate;
extern long dihvtimeseq;
extern float dihvelapsed;
extern bool dihvcoming;

#ifdef treetestC
extern unsigned short treesC;
extern D3DXVECTOR3 treelist[16384];
extern float treedist[16384];
extern D3DXVECTOR3 treepos[16384];
#endif

// All for user waypoints
extern long WPtargetT, WPtargetsel;
extern unsigned char WPtargetselgrp;

extern short draglineitemo, draglineitemi;
extern long scanscroll, topscroll;


extern D3DXVECTOR3 gravityvec, locvelcomp, gravityacc;
extern D3DXVECTOR3 oldvelocity, sumofforces;

extern char outgoing[80], g_bTextInput, prompt[80]; // this is top and bottom
extern unsigned short temptarget;

extern bool g_bShift, g_bControl;
// menutypes are 0=from server, 1=waypoints, 2=PODS menu
// textinput are 0=hotkeys, 1=chat, 2=lineinputtoserver, 3=waypointname, 4=waypointlatlong
//float dialation=1.0f;



// For external configuration file
extern float g_fFOV, f_compareFOV;
extern float g_fhOFF, g_fvOFF;
extern short maxwidth, maxheight;


// for debugging
extern char area[3];
extern VECTOR2SHORT newdepthpos, rts, bump;


extern float weapontimer[2], fuel, deathfuel, payload, cash; // pounds


extern bool                                                             g_bEnabled;
extern bool                                                             g_bGotConclusion;
extern bool                                                             g_bRunning;


#pragma region Used for strides in streams

struct D3DVERTEX
{
        float x, y, z; float nx, ny, nz; float tu, tv;
};

struct D3DVERTEX2
{
        float x, y, z; float nx, ny, nz; float tu, tv, tu2, tv2;
};

struct D3DSKYDOME
{
        float x, y, z; DWORD diffuse;
};

struct D3DRAINDROP
{
        float x, y, z; float nx, ny, nz; DWORD diffuse;
};

struct D3DSKYRING
{
        float x, y, z; DWORD diffuse; float tu, tv;
};

struct D3DSTATICSTARS
{
        float x, y, z; float psize; DWORD diffuse;
};

struct D3DNOPSIZE
{
        float x, y, z; DWORD diffuse;
};

struct D3DSCREEN
{
        float x, y, z, w; DWORD diffuse;
};

struct D3DINSTRUMENT
{
        float x, y, z, w; float tu, tv;
};

struct D3DINSTCOLOR
{
        float x, y, z, w; DWORD diffuse;
};

struct D3DNONORMAL
{
        float x, y, z; float tu, tv;
};

struct D3DLOCALGRID // stride for stream cloud bases
{
        D3DXVECTOR3 position;//, normal;
        DWORD diffuse, specular;
        float tu, tv;
};

struct D3DLOCALGRID2 // stride for stream landforms
{
        D3DXVECTOR3 position;//, normal;
        DWORD raster, specular;
        float tu, tv;
};

#pragma endregion


struct LOCALGRID2 // for terrain to build VB from, returned from CalculateSRV
{
        D3DXVECTOR3 position, cloudpos;
        D3DXCOLOR specular, clouddif;
        PlotType type;

        unsigned char pri_landform; // 255 is flag for not visible
        unsigned char pri_transition; // 0 is none, 255 is not yet set so make it 0
        unsigned char sec_landform; // 32 is flag, should never get to if pri_transition is 0, 255 is flag for RTS (requires transition==0)
        unsigned char sec_transition; // 0 is none, 255 is not yet set so make it 0
        unsigned char ter_landform; // 32 is flag, should never get to if sec_transition is 0
        D3DXCOLOR raster;

        unsigned char zone, roads;
        short buildzoneOrdinal = -1; // -1 if no buildings
        long layout1, layout2, layout3, layout4; // layout1==0 if no buildings
        short elevation;

        VECTOR2SHORT tcp; // for debugging
        bool powered;

        // 0 is normal, 1 is wp to np w/ pm corner
//      unsigned char align;
        
        bool IsUserColony() const
        {
                return type == PlotType::UserEstate || type == PlotType::UserMining || type == PlotType::UserFarming || type == PlotType::UserTownship ||
                        type == PlotType::UserAirfield;
        }

        bool UsesRts() const
        {
                // cities but not prison or O-4 ruins
                return zone == 0 && IsDeois();
        }

        bool IsDeois() const
        {
                return type == PlotType::DeoisFinancial || type == PlotType::DeoisIndustrial || type == PlotType::DeoisCityCenter ||
                        type == PlotType::DeoisTransit || type == PlotType::DeoisPort;
        }
        
        bool IsO4() const
        {
                return type == PlotType::O4Ruin1 || type == PlotType::O4Ruin2 || type == PlotType::O4Ruin3 || type == PlotType::O4Ruin4;
        }
};
extern LOCALGRID2 gridarray[64][64];


extern D3DXVECTOR3 insidearray[63][63][3]; // row 0 and column 0 are not used (can't be calculated)


struct BATCHINDEX2
{
        unsigned short startindex;
        unsigned char u, v;
        unsigned char runways, roads; // rivers;
        unsigned char runwayLights;
        unsigned char primitives;
        unsigned char pri_landform, pri_transition, sec_landform, sec_transition, ter_landform;
};
extern BATCHINDEX2 drawlist[drawlistC];


struct s_polygon_extras2
{
        D3DVERTEX* vertexbackup = nullptr;
        D3DXVECTOR3 center[4500];
        short index[4500];
};


struct s_light_effect
{
        unsigned char primitive;
        D3DXVECTOR3 normal, position;
        D3DXCOLOR diffuse; // color
        unsigned long sequencing; // pattern
        float speed, power;
        short attachto;
};

extern char buffer1[16384];

struct s_polygon_object
{
        short vertices, polygons;
        LPDIRECT3DVERTEXBUFFER9 VB = nullptr;
        std::vector<s_light_effect> effects;
};
extern s_polygon_object polyobjects[maxpolyC];


#ifdef smoketestC
struct SSmokeTrail
{
        unsigned char animate;
        D3DXVECTOR3 offset; // so we can do one transformation
};
#endif


struct SWeaponData
{
        double precisionx, precisiony, precisionz;
        D3DXVECTOR3 velocity;
        D3DXVECTOR3 positer, posleft, veliter, velleft;
        char type, reference;
        float animate;
        float scale;
        float tilt, elapsed;
        bool active, exploded;
        unsigned short origin, target;
        VECTOR2SHORT olddepthpos;
        float yieldKg; // kg

#ifdef smoketestC
        SSmokeTrail smoketrail[smoketrailC];
        unsigned char smokestep;
        D3DXVECTOR3 barycentric, smokeprog;
#endif
};


struct s_mesh_component
{
        // Static
        unsigned char type; // 1 is gear
        short attachto; // associations
        UINT startvertex, primitives; // in VB

        short texture; // array map number
        bool useLightMap;
        float speedExtend, speedRetract; // in scaled units per second
        float boundsphere; // in km radius from module's free CG
//      float mass; // non-dimensional value to resist forces and to average weighted CG's

        D3DXVECTOR3 nominalxyz; // from primary CG
        D3DXVECTOR3 nominalypr; // from primary quaternion

        D3DXVECTOR3 nominalCG; // local offset from free CG for rotation or scale for cities on RTS

        // Not used by cities
        D3DXVECTOR3 extendby; // nominalxyz+=extendby*extended
        D3DXVECTOR3 hingeCG, hingeaxis; // assume nominalypr sets up in center of range so this is �
        float hingeextent;

        // Dynamic
        float extended = 0.0f; // extended is percentage, used for timing for animations too
        D3DXMATRIX matWorld = D3DXMATRIX();
        bool visible = false;
};


struct RTSGRID
{
        unsigned char rotation, texture;
};


extern char buffer2[16384];


struct BUILDZONE
{
        LPDIRECT3DVERTEXBUFFER9 VB = nullptr;
        LPDIRECT3DVERTEXBUFFER9 RTSVB = nullptr;

        std::vector<s_light_effect> effects;

        D3DXVECTOR3 terpos = centerC;
        D3DXMATRIX matrixBase;
        short u = 0, v = 0;
        PlotType type = PlotType::NotZoned;
        float emissive = 0.0f;

        long layout1 = 0L, layout2 = 0L, layout3 = 0L, layout4 = 0L;
        unsigned short components = 0, rtscomponents = 0;
        s_mesh_component *componentarray = nullptr;
        s_mesh_component *rtscomponentarray = nullptr;
        RTSGRID *rts = nullptr;
};
extern BUILDZONE buildzone[buildingVBC];

// For buildings
struct Ssorter
{
        float dist;
        short buildzone;
};
extern Ssorter sortme[buildingVBC], sortmetemp;


extern char buffer3[16384];


struct s_universe_object
{
        short type; // type of object

        float revprog, rotprog; // dynamic location
        float revoffset, rotoffset; // start radians in ecliptic
        float inclination;

        float range; // range for spheres to orbit at from Vieneo core

        float rotation; // radians per second
        float revolution; // radians per second

        float scale; // scalar for matrix 
        float tilt; // axial tilt 

        D3DXMATRIX matrixWorld, matrixBase, matrixReal;

        D3DXVECTOR3 position; // needed for distance?

        // For docks
        unsigned short components;
        s_mesh_component* componentarray = nullptr;

        D3DXQUATERNION orientation;
        D3DXVECTOR3 velocity;
        float distance;
        float bound;
        bool powered;

        unsigned long compare; // comparison for running lights
        float speed, timer; // also for running lights

};
extern s_universe_object allobjects[maxstarC];


struct s_city_stuff
{
        //      D3DXMATRIX matrixReal, matrixWorld, matrixBase;

        //      VECTOR2SHORT depthpos;
        float elevation = 0.0f; // this keeps track of the building height below for the radar altimeter
        float floorelev, curbelev;

        //      unsigned short components;
        //      s_mesh_component* componentarray;

        unsigned long compare[PlotType::PlotTypeEnum]; // comparison for running lights
        float speed[PlotType::PlotTypeEnum], timer[PlotType::PlotTypeEnum]; // also for running lights
};
extern s_city_stuff citystuff;


struct s_network_objects // Ships can go anywhere, docks are in orbit
{
        D3DXCOLOR specular; // to store ground lighting where they are
        unsigned char type = 0; // which model (mesh and aerodynamic) we use, 0 is Unassigned, 1 is PODS, 2 is E-10, 3 is DIHV

        char IVR[7]; // must be able to store null terminator ... 3317-A is the worst offender
        char hullname[23];

        DWORD trimcolor;
        char logofile[8];

        D3DXVECTOR3 velocity = centerC, barycentric = centerC, dockingvel = centerC;
        D3DXVECTOR3 positer = centerC, posleft = centerC, veliter = centerC, velleft = centerC;
        D3DXVECTOR3 acc = centerC, acciter = centerC, accleft = centerC; // acceleration in G
        float tx = 0.0f, ty = 0.0f, tz = 0.0f; // thrust in km/s/s
        float txiter = 0.0f, tyiter = 0.0f, tziter = 0.0f; // thrust in km/s/s
        float txleft = 0.0f, tyleft = 0.0f, tzleft = 0.0f; // thrust in km/s/s
        char reference = -127;
        short inarray = -1; // which slot his parent ship is in
        unsigned char bay = 0; // which bay he is in in his parent ship
        D3DXVECTOR3 position = centerC, dockoffset = centerC;
        double precisionx = 0.0f, precisiony = 0.0f, precisionz = 0.0f;

        unsigned long compare; // comparison for running lights
        float speed, timer; // also for running lights

        D3DXMATRIX matrixWorld; // translated and oriented
        D3DXMATRIX matrixBase, dor, matrixInvOrientation;

        D3DXQUATERNION orientation, orientiter, orientleft;

        float pitch, roll, yaw; // radians
        float pitchleft, pitchiter, rollleft, rolliter, yawleft, yawiter; // radians
        float pitchdeflect, rolldeflect, yawdeflect; // scalar -1 to +1
        float steerLimitRadian, tireCircumferenceKm;

        bool logolight, headlight, active, visible, clientinit, geardown, baydoor, domelight, inhibitvisibility;
        bool police, specialight, tow, docked, simulator, brakelight;
        char align, portassigned = -1;
        float flapdown;

        unsigned short vehicleId = 0; // actual vehicle PK id

        float bound, distance, cloaking, baydoorextent;
        float tireRotationRadians; // Distance from ourshipC

        short VB;

        unsigned short components = 0;
        s_mesh_component* componentarray = nullptr;

        // optimization
        bool drawflag, groundvehicle; // takes active, visible, and cone based on lookdir

        // these are new for Mode AC
        int allegiance;
        char owner[13];
        int ownerId;
        bool reposess;
        bool stolen;
        unsigned short sequence;
        float closurerate = 0.0f;
        
        // reverse lookup only in TCAS
        int ordinal = -1;
        WCHAR tcasOnly[16];
        float msl = -1.0f;
        float vsi = 0.0f;
};
extern s_network_objects playerships[MAX_SCAN];


struct Scockpit
{
        // lots of these things are set by the texturelib changing...
        bool gndvehicle; // deprecated... use playerships[0].gndvehicle instead
        bool wheeled, spaceCapable;
        bool radioPower, remoteAssayPower, weatherRadarPower;

        char startcycle; float startupextend, power; // this is for the power-up state and animations

        float fwdthrustlimit, revthrustlimit, uptranslimit, dntranslimit, lrtranslimit, spoolTime;
        float attenuate;
        short oldtexturelib, texturelib, screentexture, projecttexture; // dynamic texture is screentexture
        D3DXVECTOR3 headlight;

        // this is temporary fix, eventually this will be handled/restricted by the server
        float chairfwd, chairfwdeye, chairFwdRemaining; // 0.0f to 1.0f lerp of the available movement, keyboard control

        D3DXVECTOR3 chaireye; // this is the km scale location based on our movement
        D3DXVECTOR3 position; // this is the km scale result of our movement and accel displacement
        D3DXVECTOR3 cockpitArmKm; // this is the km scale location of the cockpit CG from vehicle CG (cockpit CG is collocated with the player eye)
        float gearextent, strutlength, strutabsorb;
        float strutsrettoCG, rooftoCG; // these determine exterior model position off surface
        bool sentgearvoice;
        unsigned short components;
        char radioplaying[99], tires, steerTires;

        char bays, engines;

        float emptyWeightLbs; // lbs
        float maxGrossLbs; // lbs
        float serviceCeilingKm; // km 0=none
        float momentp, momentr, momenty;
        float f25, f27, f20FrontBackDragCoeff, f28, h9RudderSqFt, d17VTailWithRudderSqFt, h12, i12WingAreaOneSideSqFt, h6ElevatorSqFt;
        float d16HTailWithElevatorSqFt, b9DistanceToVTailM, b6DistanceToHTailM, b12WingRollArmM, b15WingPitchArmM, c9WingYawArmM;
        float d65wasd61, e65wase61, i66wasi62, k66wask62, i65wasi61, k65wask61, wingspanM, rcsYParmM;
        float Vs1, VcMSL, Vs2, Vne, Vr;
        float ffmax, ffidle, fuelmax;
        float appitagr, aprolagr; // pit and rol aggressiveness for autoflyte
        float i48CriticalEngineYawArmM;
        float noseWheelToCgKm;
        float steerLimitRadian;

        // calculated from vdat
        bool radioEquipped, remoteAssayEquipped, weatherRadarEquipped;
        float scanrange, usage;

        // calculated per frame for stats
        float currentFuelFlowPoundsPerSecond;

        // GV only?
        float tach, tirespeedKph, clutchhold, clutchtime;
        char gearshift, fwdgears;
        float ratios[8]; // max is T-120 with 0=rev, 1-7 fwd

        float flapExtent; // 0-1 of max extension
        std::vector<int> flapSettings; // degrees

        // related to our character, probably needs to be moved?
        short ourplyrC = 0;
        float moving; // 0=standing
        float turnin; // 0=standing
        float impatientime; // standing still how long
        unsigned char hitpoints;
        float dexterity = -999.0f;
        unsigned char playerWeightKg;
        char character[30]; // needed for cargo manifest ... this or a bus value
        char handle[13]; // needed for cargo manifest ... this or a bus value

        SVesselDC vdat;
        bool vdatChanged = false;
        float vdatTime = 0.0f;

        unsigned char cargoloadtype, cargoload, paxdest;

        std::vector<unsigned char> personalInventory;
        std::vector<unsigned char> vehicleInventory;

        s_mesh_component* componentarray = nullptr;

        bool nextgen = false; // uses new monitor render surface size

        // stuff unavailable on bus that we need in displays
        float aoiWingRad = 0.0f;

        bool parkingBrake = false;

        int inventoryItemInUseType = 0;
        int intentoryItemInUseVehicleId = 0;
        int inventoryItemInUseId = 0;
        float engineCriticalAltitude = 0.0f;
        float l48AverageEnginePitchArmM = 0.0f;
        int flapMaxDegrees = 0;
        float flapAreaModLE;
        float flapAreaModTE;
        float d15TotalWingAreaSqFt;
        float aileronAreaMod;
        float elevatorAreaMod;

        float dockOffsetKmZ;
        float dockOffsetKmY;
        float dockingOrientationZ;
        short scanDisplayVesselLimit;

        // 0.02f is probably pinnacle of insulation material factor
        float exteriorInsulationHeatTransferCoefficient;
        bool lowfuel = false;
        float k12flapsAreaSqMTE;
        float j12flapsAreaSqMLE;
        float tireRadiusKm;
        float pitchLimitRadians;
        float speedLimiterKph;
        float machAngleDragScalar;
        int sonicBooms;
        float engineEfficiencyAtSeaLevelScalar;
};
extern Scockpit ourcockpit;


struct LIGHTNINGABOVE
{
        bool inuse;
        float timeleft;
        float intensity;
        bool trend;
        short panel;
        short texture;
};
extern LIGHTNINGABOVE lightningabove[ACLlightningC];


// these two were in the MYAPPLICATION container before lightning was changed
//LOCALGRID cloudgrid[64][64];
struct LIGHTNINGBELOW
{
        bool inuse;
        float timeleft;
        float intensity, distance;
        bool trend;
        short texture;
        D3DXVECTOR3 groundpos, cloudpos;
};
extern LIGHTNINGBELOW lightningbelow;


#define fireworksC      8
struct FIREWORKS
{
        bool inuse;
        short texture;
        char type;
        D3DXCOLOR color;
        D3DXVECTOR3 position;
};
extern FIREWORKS fireworks[fireworksC];


struct Sinteractive
{
        bool avail;
        unsigned char menutype;
        short outboundMenuSelect = -1;
        VECTOR2SHORT tcp;

        union
        {
                SPlotData tempplot;
                SDockingPorts tempdock;
        };

        float colonistsforbuilding, mincoltorun;
        short type1built, type2built, type3built, type4built, type5built, type6built, type7built, type8built, type9built;
};
extern Sinteractive interactive;


// each player has a "ani", so if someone starts walking, we get the "start walking" 
// if they continue walking, when we get to the end of the "start walking" ani we go to the loop
// always finish the ANI we are working on?
// or we can store "queue ani" and if "current ani" != "queue ani" that will lerp from our
//  current keyframe to the "queue ani"'s first keyframe?
struct Sani
{
        float start; // time
        float end; // time (if 0.0f then unused)
        D3DXVECTOR3 ypr[16] {};
        D3DXVECTOR3 xyz {};
};
extern Sani aniarray[MAX_ANI][10]; // animation, step


struct SShockWave
{
        float timetoshock = 0.0f;
        float shockramp = 0.0f;
        float shockspeed = 0.0f;

        D3DXVECTOR3 shockmag = centerC;
};
extern std::vector<SShockWave> shockwaves;