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"
#include "damagetype.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)) {
      ERR( _("Malformed '%s' file: missing root element '%s'"), START_DATA_PATH, XML_START_ID );
      return -1;
   }
 
   node = node->xmlChildrenNode; /* first system node */
   if (node == NULL) {
      ERR( _("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;
}