difficulty.c

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdlib.h>
 
#include "naev.h"
 
#include "difficulty.h"
 
#include "array.h"
#include "conf.h"
#include "ndata.h"
#include "nxml.h"
 
#define DIFFICULTY_XML_ID "difficulty"
 
static Difficulty       *difficulty_stack   = NULL;
static const Difficulty *difficulty_default = NULL;
static const Difficulty *difficulty_global  = NULL;
static const Difficulty *difficulty_local   = NULL;
static const Difficulty *difficulty_current = NULL;

int difficulty_load( void )
{
   char **difficulty_files = ndata_listRecursive( DIFFICULTY_PATH );
   difficulty_stack        = array_create( Difficulty );
   for ( int i = 0; i < array_size( difficulty_files ); i++ ) {
      Difficulty d;
      xmlDocPtr  doc;
      xmlNodePtr node, cur;
 
      /* Load and read the data. */
      doc = xml_parsePhysFS( difficulty_files[i] );
      if ( doc == NULL )
         continue;
 
      /* Check to see if document exists. */
      node = doc->xmlChildrenNode;
      if ( !xml_isNode( node, DIFFICULTY_XML_ID ) ) {
         WARN( _( "Malformed '%s' file: missing root element '%s'" ),
               difficulty_files[i], DIFFICULTY_XML_ID );
         xmlFreeDoc( doc );
         continue;
      }
 
      /* Initialize. */
      memset( &d, 0, sizeof( Difficulty ) );
 
      /* Properties. */
      xmlr_attr_strd( node, "name", d.name );
      xmlr_attr_int_opt( node, "default", d.def );
 
      /* Get the stats. */
      cur = node->xmlChildrenNode;
      do {
         xml_onlyNodes( cur );
 
         /* Load the description. */
         xmlr_strd( cur, "description", d.description );
 
         /* Rest should be ship stats. */
         ShipStatList *ll = ss_listFromXML( cur );
         if ( ll != NULL ) {
            ll->next = d.stats;
            d.stats  = ll;
            continue;
         }
         WARN( _( "Difficulty '%s' has unknown node '%s'" ), d.name,
               cur->name );
      } while ( xml_nextNode( cur ) );
 
      xmlFreeDoc( doc );
 
      array_push_back( &difficulty_stack, d );
   }
 
   /* Find out default. */
   for ( int i = 0; i < array_size( difficulty_stack ); i++ ) {
      Difficulty *dd = &difficulty_stack[i];
      if ( dd->def ) {
         if ( difficulty_default )
            WARN( _( "More than one difficulty with default flag set!" ) );
         difficulty_default = dd;
      }
   }
   if ( difficulty_default == NULL ) {
      WARN( _( "No default difficulty set!" ) );
      difficulty_default = difficulty_stack;
   }
   difficulty_current = difficulty_default; /* Load default. */
 
   /* Load the global difficulty. */
   if ( conf.difficulty != NULL )
      difficulty_setGlobal( difficulty_get( conf.difficulty ) );
 
   for ( int i = 0; i < array_size( difficulty_files ); i++ )
      free( difficulty_files[i] );
   array_free( difficulty_files );
   return 0;
}

void difficulty_free( void )
{
   for ( int i = 0; i < array_size( difficulty_stack ); i++ ) {
      Difficulty *d = &difficulty_stack[i];
      free( d->name );
      free( d->description );
      ss_free( d->stats );
   }
   array_free( difficulty_stack );
}

const Difficulty *difficulty_cur( void )
{
   return difficulty_current;
}

const Difficulty *difficulty_getAll( void )
{
   return difficulty_stack;
}
 
static const Difficulty *difficulty_getDefault( void )
{
   if ( difficulty_global != NULL )
      return difficulty_global;
   else
      return difficulty_default;
}

const Difficulty *difficulty_get( const char *name )
{
   if ( name == NULL )
      return difficulty_getDefault();
   for ( int i = 0; i < array_size( difficulty_stack ); i++ ) {
      const Difficulty *d = &difficulty_stack[i];
      if ( strcmp( name, d->name ) == 0 )
         return d;
   }
   WARN( _( "Unknown difficulty setting '%s'" ), name );
   return difficulty_default;
}
 
static void difficulty_update( void )
{
   if ( difficulty_local != NULL )
      difficulty_current = difficulty_local;
   else if ( difficulty_global != NULL )
      difficulty_current = difficulty_global;
   else
      difficulty_current = difficulty_default;
}

void difficulty_setGlobal( const Difficulty *d )
{
   difficulty_global = d;
   difficulty_update();
}

void difficulty_setLocal( const Difficulty *d )
{
   difficulty_local = d;
   difficulty_update();
}

char *difficulty_display( const Difficulty *d )
{
   int   l;
   char *display = malloc( STRMAX );
   l = scnprintf( display, STRMAX, _( "Difficulty %s" ), _( d->name ) );
   l += scnprintf( &display[l], STRMAX - l, "\n" );
   if ( d->description != NULL )
      l += scnprintf( &display[l], STRMAX - l, "%s\n", _( d->description ) );
   l += scnprintf( &display[l], STRMAX - l,
                   _( "This difficulty applies the following effect to the "
                      "player ships:" ) );
   ss_statsListDesc( d->stats, &display[l], STRMAX - l, 1 );
   return display;
}

int difficulty_apply( ShipStats *s )
{
   return ss_statsMergeFromList( s, difficulty_current->stats );
}