start.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
 
#include "start.h"
 
#include "log.h"
#include "ndata.h"
#include "nxml.h"
 
#define XML_START_ID "Start" 

typedef struct ndata_start_s {
   char        *name;     
   char        *ship;     
   char        *shipname; 
   char        *acquired; 
   char        *gui;      
   unsigned int credits;  
   ntime_t      date;     
   char        *system;   
   double       x;        
   double       y;        
   char        *mission;  
   char        *event;    
   char        *chapter;  
   char        *spob_lua_default;  
   char        *dtype_default;     
   char        *local_map_default; 
} ndata_start_t;
static ndata_start_t start_data; 

int start_load( void )
{
   int        date_set = 0;
   xmlNodePtr node;
   xmlDocPtr  doc;
 
   memset( &start_data, 0, sizeof( ndata_start_t ) );
 
   /* Try to read the file. */
   doc = xml_parsePhysFS( START_DATA_PATH );
   if ( doc == NULL )
      return -1;
 
   node = doc->xmlChildrenNode;
   if ( !xml_isNode( node, XML_START_ID ) ) {
      WARN( _( "Malformed '%s' file: missing root element '%s'" ),
            START_DATA_PATH, XML_START_ID );
      return -1;
   }
 
   node = node->xmlChildrenNode; /* first system node */
   if ( node == NULL ) {
      WARN( _( "Malformed '%s' file: does not contain elements" ),
            START_DATA_PATH );
      return -1;
   }
   do {
      xml_onlyNodes( node );
 
      xmlr_strd( node, "name", start_data.name );
 
      if ( xml_isNode( node,
                       "player" ) ) { /* we are interested in the player */
         xmlNodePtr cur = node->children;
         do {
            xml_onlyNodes( cur );
 
            xmlr_uint( cur, "credits", start_data.credits );
            xmlr_strd( cur, "mission", start_data.mission );
            xmlr_strd( cur, "event", start_data.event );
            xmlr_strd( cur, "chapter", start_data.chapter );
            xmlr_strd( cur, "gui", start_data.gui );
 
            if ( xml_isNode( cur, "ship" ) ) {
               xmlr_attr_strd( cur, "name", start_data.shipname );
               xmlr_attr_strd( cur, "acquired", start_data.acquired );
               xmlr_strd( cur, "ship", start_data.ship );
            } else if ( xml_isNode( cur, "system" ) ) {
               xmlNodePtr tmp = cur->children;
               do {
                  xml_onlyNodes( tmp );
                  xmlr_strd( tmp, "name", start_data.system );
                  /* position */
                  xmlr_float( tmp, "x", start_data.x );
                  xmlr_float( tmp, "y", start_data.y );
                  WARN( _( "'%s' has unknown system node '%s'." ),
                        START_DATA_PATH, tmp->name );
               } while ( xml_nextNode( tmp ) );
               continue;
            }
            WARN( _( "'%s' has unknown player node '%s'." ), START_DATA_PATH,
                  cur->name );
         } while ( xml_nextNode( cur ) );
         continue;
      }
 
      if ( xml_isNode( node, "date" ) ) {
         int cycles, periods, seconds;
         xmlr_attr_int( node, "scu", cycles );
         xmlr_attr_int( node, "stp", periods );
         xmlr_attr_int( node, "stu", seconds );
 
         /* Post process. */
         start_data.date = ntime_create( cycles, periods, seconds );
         date_set        = 1;
         continue;
      }
 
      xmlr_strd( node, "spob_lua_default", start_data.spob_lua_default );
      xmlr_strd( node, "dtype_default", start_data.dtype_default );
      xmlr_strd( node, "local_map_default", start_data.local_map_default );
 
      WARN( _( "'%s' has unknown node '%s'." ), START_DATA_PATH, node->name );
   } while ( xml_nextNode( node ) );
 
   /* Clean up. */
   xmlFreeDoc( doc );
 
   /* Safety checking. */
#define MELEMENT( o, s )                                                       \
   if ( o )                                                                    \
   WARN( _( "Module start data missing/invalid '%s' element" ),                \
         s ) 
   MELEMENT( start_data.name == NULL, "name" );
   MELEMENT( start_data.credits == 0, "credits" );
   MELEMENT( start_data.ship == NULL, "ship" );
   MELEMENT( start_data.gui == NULL, "gui" );
   MELEMENT( start_data.acquired == NULL, "acquired" );
   MELEMENT( start_data.system == NULL, "player system" );
   MELEMENT( start_data.chapter == NULL, "chapter" );
   MELEMENT( !date_set, "date" );
#undef MELEMENT
 
   return 0;
}

void start_cleanup( void )
{
   free( start_data.name );
   free( start_data.shipname );
   free( start_data.acquired );
   free( start_data.gui );
   free( start_data.ship );
   free( start_data.system );
   free( start_data.mission );
   free( start_data.event );
   free( start_data.chapter );
   free( start_data.spob_lua_default );
   free( start_data.dtype_default );
   free( start_data.local_map_default );
   memset( &start_data, 0, sizeof( start_data ) );
}

const char *start_name( void )
{
   return start_data.name;
}

const char *start_ship( void )
{
   return start_data.ship;
}

const char *start_shipname( void )
{
   return start_data.shipname;
}

const char *start_acquired( void )
{
   return start_data.acquired;
}

const char *start_gui( void )
{
   return start_data.gui;
}

unsigned int start_credits( void )
{
   return start_data.credits;
}

ntime_t start_date( void )
{
   return start_data.date;
}

const char *start_system( void )
{
   return start_data.system;
}

void start_position( double *x, double *y )
{
   *x = start_data.x;
   *y = start_data.y;
}

const char *start_mission( void )
{
   return start_data.mission;
}

const char *start_event( void )
{
   return start_data.event;
}

const char *start_chapter( void )
{
   return start_data.chapter;
}

const char *start_spob_lua_default( void )
{
   return start_data.spob_lua_default;
}

const char *start_dtype_default( void )
{
   return start_data.dtype_default;
}

const char *start_local_map_default( void )
{
   return start_data.local_map_default;
}