space.h

/*
 * See Licensing and Copyright notice in naev.h
 */
#pragma once
 
#include "space_fdecl.h" // IWYU pragma: export
 
#include "asteroid.h"
#include "commodity.h"
#include "mission_markers.h"
#include "nxml.h"
#include "opengl_tex.h"
#include "pilot.h"
#include "shipstats.h"
#include "tech.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_BAR ( 1 << 2 )       
#define SPOB_SERVICE_MISSIONS ( 1 << 3 )  
#define SPOB_SERVICE_OUTFITS ( 1 << 4 )   
#define SPOB_SERVICE_SHIPYARD ( 1 << 5 )  
#define SPOB_SERVICE_COMMODITY ( 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_HOSTILE ( 1 << 6 )     
#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_ {
   char *filename; 
   int   id;       
   char *name;     
   char *display;  
   char  *feature; 
   vec2   pos;     
   double radius;  
   const SimpleShader *marker;       
   double              marker_scale; 
 
   /* Spob details. */
   char *class; 
   double 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. */
   double      gfx_space3d_size;
   GltfObject *gfx_space3d;
   char       *gfx_space3dName;
   char       *gfx_space3dPath;
   GLuint      gfx_fbo;
   GLuint      gfx_dtex;
   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_raw; 
   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;      
   int lua_distress;   
} 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_HAS_KNOWN_SPOB ( 1 << 8 ) 
#define SYSTEM_HAS_KNOWN_FACTION_SPOB                                          \
   ( 1 << 9 ) 
#define SYSTEM_NOLANES                                                         \
   ( 1 << 10 ) 
#define SYSTEM_PMARKED ( 1 << 11 ) 
#define SYSTEM_INTEREST                                                        \
   ( 1 << 12 ) 
#define SYSTEM_NEBULATRAIL ( 1 << 13 ) 
#define SYSTEM_HIDENEBULADAMAGE                                                \
   ( 1 << 14 ) 
#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; 
   double local; 
} 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_ {
   char *filename; 
   int   id;       
 
   /* General. */
   char *name;      
   char *display;   
   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 );
StarSystem *spob_getSystem( const Spob *spob );
const char *spob_getSystemName( 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 );
void spob_distress( Spob *spb, const Pilot *p, const Pilot *attacker );
/* 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 );
const char *system_name( const StarSystem *sys );
const char *system_nameKnown( const StarSystem *sys );
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_addJump( StarSystem *sys, StarSystem *target );
int         system_rmJump( StarSystem *sys, StarSystem *target );
 
/*
 * 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 );
SystemPresence       *system_getFactionPresence( StarSystem *sys, int faction );
const SystemPresence *system_getFactionPresenceConst( const StarSystem *sys,
                                                      int faction );
double system_getReputation( const StarSystem *sys, int faction );
double system_getReputationOrGlobal( const StarSystem *sys, int faction );
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 );
 
/*
 * Save/Loading.
 */
int space_playerSave( xmlTextWriterPtr writer );
int space_playerLoad( xmlNodePtr parent, const char *version );