space.h

/*
 * See Licensing and Copyright notice in naev.h
 */
#pragma once
 
#include "space_fdecl.h"
 
#include "commodity.h"
#include "explosion.h"
#include "faction.h"
#include "mission_markers.h"
#include "opengl.h"
#include "pilot.h"
#include "shipstats.h"
#include "tech.h"
#include "asteroid.h"
 
#define SYSTEM_SIMULATE_TIME_PRE   25. 
#define SYSTEM_SIMULATE_TIME_POST   5. 
#define MAX_HYPERSPACE_VEL    25. 
/*
 * Spob services.
 */
#define SPOB_SERVICE_LAND         (1<<0) 
#define SPOB_SERVICE_REFUEL       (1<<1) 
#define SPOB_SERVICE_MISSIONS     (1<<2) 
#define SPOB_SERVICE_COMMODITY    (1<<3) 
#define SPOB_SERVICE_OUTFITS      (1<<4) 
#define SPOB_SERVICE_SHIPYARD     (1<<5) 
#define SPOB_SERVICE_BAR          (1<<6) 
#define SPOB_SERVICE_INHABITED    (1<<7) 
#define SPOB_SERVICE_BLACKMARKET  (1<<8) 
#define SPOB_SERVICES_MAX         (SPOB_SERVICE_BLACKMARKET<<1)
#define spob_hasService(p,s)      ((p)->services & s) 
/*
 * Spob flags.
 */
#define SPOB_KNOWN       (1<<0) 
#define SPOB_BLACKMARKET (1<<1) 
#define SPOB_NOMISNSPAWN (1<<2) 
#define SPOB_UNINHABITED (1<<3) 
#define SPOB_MARKED      (1<<4) 
#define SPOB_NOLANES     (1<<5) 
#define SPOB_RADIUS      (1<<10) 
#define spob_isFlag(p,f)    ((p)->flags & (f)) 
#define spob_setFlag(p,f)   ((p)->flags |= (f)) 
#define spob_rmFlag(p,f)    ((p)->flags &= ~(f)) 
#define spob_isKnown(p) spob_isFlag(p,SPOB_KNOWN) 
typedef struct MapOverlayPos_ {
   float radius;     
   float text_offx;  
   float text_offy;  
   float text_width; 
} MapOverlayPos;
 
typedef struct SpobPresence_ {
   int faction;   
   double base;   
   double bonus;  
   int range;     
} SpobPresence;
 
typedef struct VirtualSpob_ {
   char *name;                
   SpobPresence *presences;  
} VirtualSpob;
 
typedef struct Spob_ {
   int id;        
   char *name;    
   char *display; 
   char *feature; 
   vec2 pos;  
   double radius; 
   const SimpleShader *marker; 
   double marker_scale; 
   /* Spob details. */
   char *class;         
   uint64_t population; 
   /* Spob details. */
   SpobPresence presence; 
   double hide;         
   /* Landing details. */
   int can_land;        
   int land_override;   
   char *land_msg;      
   /* Landed details. */
   char *description;      
   char *bar_description;  
   unsigned int services;  
   Commodity **commodities;
   CommodityPrice *commodityPrice; 
   tech_group_t *tech;     
   /* Graphics. */
   glTexture *gfx_space;   
   char *gfx_spaceName;    
   char *gfx_spacePath;    
   char *gfx_exterior;     
   char *gfx_exteriorPath; 
   char *gfx_comm;         
   char *gfx_commPath;     
   /* Misc. */
   char **tags;         
   unsigned int flags;  
   MapOverlayPos mo;    
   double map_alpha;    
   int markers;         
   /* Lua stuff. */
   char *lua_file;   
   nlua_env lua_env; 
   int lua_mem;      
   int lua_init;     
   int lua_load;     
   int lua_unload;   
   int lua_can_land; 
   int lua_land;     
   int lua_render;   
   int lua_update;   
   int lua_comm;     
   int lua_population; 
   int lua_barbg;    
} Spob;
 
/*
 * Star system flags
 */
#define SYSTEM_KNOWN       (1<<0) 
#define SYSTEM_MARKED      (1<<1) 
#define SYSTEM_CMARKED     (1<<2) 
#define SYSTEM_CLAIMED     (1<<3) 
#define SYSTEM_DISCOVERED  (1<<4) 
#define SYSTEM_HIDDEN      (1<<5) 
#define SYSTEM_HAS_KNOWN_LANDABLE (1<<6) 
#define SYSTEM_HAS_LANDABLE (1<<7) 
#define SYSTEM_NOLANES     (1<<8) 
#define SYSTEM_PMARKED     (1<<9) 
#define SYSTEM_INTEREST    (1<<10) 
#define sys_isFlag(s,f)    ((s)->flags & (f)) 
#define sys_setFlag(s,f)   ((s)->flags |= (f)) 
#define sys_rmFlag(s,f)    ((s)->flags &= ~(f)) 
#define sys_isKnown(s)     (sys_isFlag((s),SYSTEM_KNOWN)) 
#define sys_isMarked(s)    sys_isFlag((s),SYSTEM_MARKED) 
typedef struct SystemPresence_ {
   int faction;      
   double base;      
   double bonus;     
   double value;     
   double curUsed;   
   double timer;     
   int disabled;     
} SystemPresence;
 
/*
 * Jump point flags.
 */
#define JP_AUTOPOS      (1<<0) 
#define JP_KNOWN        (1<<1) 
#define JP_HIDDEN       (1<<2) 
#define JP_EXITONLY     (1<<3) 
#define JP_NOLANES      (1<<4) 
#define jp_isFlag(j,f)    ((j)->flags & (f)) 
#define jp_setFlag(j,f)   ((j)->flags |= (f)) 
#define jp_rmFlag(j,f)    ((j)->flags &= ~(f)) 
#define jp_isKnown(j)     jp_isFlag(j,JP_KNOWN) 
#define jp_isUsable(j)    (jp_isKnown(j) && !jp_isFlag(j,JP_EXITONLY))
 
typedef struct JumpPoint_ JumpPoint;
struct JumpPoint_ {
   StarSystem *from; 
   int targetid;     
   StarSystem *target; 
   JumpPoint *returnJump; 
   vec2 pos;     
   double radius;    
   unsigned int flags;
   double hide;      
   double angle;     
   double map_alpha; 
   /* Cached stuff. */
   double cosa;      
   double sina;      
   int sx;           
   int sy;           
   MapOverlayPos mo; 
};
extern glTexture *jumppoint_gfx; 
typedef struct MapShader_ {
   char *name;       
   GLuint program;   
   GLuint vertex;    
   GLuint projection;
   GLuint alpha;     
   GLuint time;      
   GLuint globalpos; 
} MapShader;
 
struct StarSystem_ {
   int id;                 
   char *filename;         
   /* General. */
   char* name;             
   vec2 pos;               
   int spacedust;          
   double interference;    
   double nebu_hue;        
   double nebu_density;    
   double nebu_volatility; 
   double radius;          
   char *background;       
   char *features;         
   /* Spobs. */
   Spob **spobs;           
   int *spobsid;           
   int faction;            
   VirtualSpob **spobs_virtual; 
   /* Jumps. */
   JumpPoint *jumps;       
   /* Asteroids. */
   AsteroidAnchor *asteroids; 
   AsteroidExclusion *astexclude; 
   double asteroid_density;
   /* Calculated. */
   double *prices;      
   /* Presence. */
   SystemPresence *presence; 
   int spilled;         
   double ownerpresence;
   /* Markers. */
   int markers_computer;
   int markers_low;     
   int markers_high;    
   int markers_plot;    
   /* Map shader. */
   char *map_shader;    
   const MapShader *ms; 
   /* Economy. */
   CommodityPrice *averagePrice;
 
   /* Misc. */
   char **tags;         
   unsigned int flags;  
   ShipStatList *stats; 
   char *note;          
   int claims_soft;     
};
 
/* Some useful externs. */
extern StarSystem *cur_system; 
extern int space_spawn; 
/*
 * loading/exiting
 */
void space_init( const char* sysname, int do_simulate );
int space_load (void);
int space_loadLua (void);
void space_exit (void);
 
/*
 * spob stuff
 */
Spob *spob_new (void);
const char *spob_name( const Spob *p );
int spob_luaInit( Spob *spb );
void spob_gfxLoad( Spob *p );
int spob_hasSystem( const Spob *spb );
const char* spob_getSystem( const char* spobname );
Spob* spob_getAll (void);
Spob* spob_get( const char* spobname );
Spob* spob_getIndex( int ind );
void spob_setKnown( Spob *p );
int spob_index( const Spob *p );
int spob_exists( const char* spobname );
const char *spob_existsCase( const char* spobname );
char **spob_searchFuzzyCase( const char* spobname, int *n );
const char* spob_getServiceName( int service );
int spob_getService( const char *name );
const char* spob_getClassName( const char *class );
credits_t spob_commodityPrice( const Spob *p, const Commodity *c );
credits_t spob_commodityPriceAtTime( const Spob *p, const Commodity *c, ntime_t t );
int spob_averageSpobPrice( const Spob *p, const Commodity *c, credits_t *mean, double *std);
void spob_averageSeenPricesAtTime( const Spob *p, const ntime_t tupdate );
/* Misc modification. */
int spob_setFaction( Spob *p, int faction );
int spob_addCommodity( Spob *p, Commodity *c );
int spob_addService( Spob *p, int service );
int spob_rmService( Spob *p, int service );
int spob_rename( Spob *p, char *newname );
/* Land related stuff. */
char spob_getColourChar( const Spob *p );
const char *spob_getSymbol( const Spob *p );
const glColour* spob_getColour( const Spob *p );
void spob_updateLand( Spob *p );
/* Lua stuff. */
void spob_luaInitMem( const Spob *spob );
 
/*
 * Virtual spob stuff.
 */
VirtualSpob* virtualspob_getAll (void);
VirtualSpob* virtualspob_get( const char *name );
 
/*
 * jump stuff
 */
JumpPoint* jump_get( const char* jumpname, const StarSystem* sys );
JumpPoint* jump_getTarget( const StarSystem* target, const StarSystem* sys );
const char *jump_getSymbol( const JumpPoint *jp );
 
/*
 * system adding/removing stuff.
 */
void system_reconstructJumps( StarSystem *sys );
void systems_reconstructJumps (void);
void systems_reconstructSpobs (void);
StarSystem *system_new (void);
int system_addSpob( StarSystem *sys, const char *spobname );
int system_rmSpob( StarSystem *sys, const char *spobname );
int system_addVirtualSpob( StarSystem *sys, const char *spobname );
int system_rmVirtualSpob( StarSystem *sys, const char *spobname );
int system_addJumpDiff( StarSystem *sys, xmlNodePtr node );
int system_rmJump( StarSystem *sys, const char *jumpname );
 
/*
 * render
 */
void space_render( const double dt );
void space_renderOverlay( const double dt );
void spobs_render (void);
 
/*
 * Presence stuff.
 */
void system_presenceCleanupAll (void);
void system_presenceAddSpob( StarSystem *sys, const SpobPresence *ap );
double system_getPresence( const StarSystem *sys, int faction );
double system_getPresenceFull( const StarSystem *sys, int faction, double *base, double *bonus );
void system_addAllSpobsPresence( StarSystem *sys );
void space_reconstructPresences( void );
void system_rmCurrentPresence( StarSystem *sys, int faction, double amount );
 
/*
 * update.
 */
void space_update( double dt, double real_dt );
int space_isSimulation (void);
int space_needsEffects (void);
 
/*
 * Graphics.
 */
void space_gfxLoad( StarSystem *sys );
void space_gfxUnload( StarSystem *sys );
 
/*
 * Getting stuff.
 */
StarSystem* system_getAll (void);
const char *system_existsCase( const char* sysname );
char **system_searchFuzzyCase( const char* sysname, int *n );
StarSystem* system_get( const char* sysname );
StarSystem* system_getIndex( int id );
int system_index( const StarSystem *sys );
int space_sysReachable( const StarSystem *sys );
int space_sysReallyReachable( const char* sysname );
int space_sysReachableFromSys( const StarSystem *target, const StarSystem *sys );
char** space_getFactionSpob( const int *factions, int landable );
const char* space_getRndSpob( int landable, unsigned int services,
      int (*filter)(Spob *p));
double system_getClosest( const StarSystem *sys, int *pnt, int *jp, int *ast, int *fie, double x, double y );
double system_getClosestAng( const StarSystem *sys, int *pnt, int *jp, int *ast, int *fie, double x, double y, double ang );
 
/*
 * Markers.
 */
int space_addMarker( int sys, MissionMarkerType type );
int space_rmMarker( int sys, MissionMarkerType type );
void space_clearKnown (void);
void space_clearMarkers (void);
void space_clearComputerMarkers (void);
int system_hasSpob( const StarSystem *sys );
 
/*
 * Hyperspace.
 */
int space_jumpDistance( const Pilot *p, const JumpPoint *jp );
int space_canHyperspace( const Pilot *p);
int space_hyperspace( Pilot *p );
int space_calcJumpInPos( const StarSystem *in, const StarSystem *out, vec2 *pos, vec2 *vel, double *dir, const Pilot *p );
 
/*
 * Misc.
 */
void system_updateAsteroids( StarSystem *sys );
void system_setFaction( StarSystem *sys );
void space_checkLand (void);
void space_factionChange (void);
void space_queueLand( Spob *pnt );
const char *space_populationStr( const Spob *spb );