claim.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
 
#include "claim.h"
 
#include "array.h"
#include "event.h"
#include "log.h"
#include "mission.h"
#include "space.h"

struct Claim_s {
   int    active; 
   int   *ids;    
   char **strs;   
   int exclusive; 
};
 
static char **claimed_strs = NULL; 

Claim_t *claim_create( int exclusive )
{
   Claim_t *claim   = malloc( sizeof( Claim_t ) );
   claim->active    = 0;
   claim->ids       = NULL;
   claim->strs      = NULL;
   claim->exclusive = exclusive;
 
   return claim;
}

int claim_addStr( Claim_t *claim, const char *str )
{
   assert( !claim->active );
   /* Allocate if necessary. */
   if ( claim->strs == NULL )
      claim->strs = array_create( char * );
 
   /* New ID. */
   array_push_back( &claim->strs, strdup( str ) );
   return 0;
}

int claim_addSys( Claim_t *claim, int ss_id )
{
   assert( !claim->active );
   /* Allocate if necessary. */
   if ( claim->ids == NULL )
      claim->ids = array_create( int );
 
   /* New ID. */
   array_push_back( &claim->ids, ss_id );
   return 0;
}

int claim_isNull( const Claim_t *claim )
{
   if ( claim == NULL )
      return 1;
 
   if ( array_size( claim->ids ) == 0 )
      return 1;
 
   return 0;
}

int claim_test( const Claim_t *claim )
{
   int exc;
 
   /* Must actually have a claim. */
   if ( claim == NULL )
      return 0;
 
   exc = claim->exclusive;
 
   /* See if the system is claimed. */
   for ( int i = 0; i < array_size( claim->ids ); i++ ) {
      const StarSystem *sys     = system_getIndex( claim->ids[i] );
      int               claimed = sys_isFlag( sys, SYSTEM_CLAIMED );
      if ( claimed || ( exc && ( sys->claims_soft > 0 ) ) )
         return 1;
   }
 
   /* Check strings. */
   for ( int i = 0; i < array_size( claim->strs ); i++ ) {
      for ( int j = 0; j < array_size( claimed_strs ); j++ ) {
         if ( strcmp( claim->strs[i], claimed_strs[j] ) == 0 )
            return 1;
      }
   }
 
   return 0;
}

int claim_testStr( const Claim_t *claim, const char *str )
{
   /* Must actually have a claim. */
   if ( claim == NULL )
      return 0;
 
   /* Check strings. */
   for ( int i = 0; i < array_size( claim->strs ); i++ ) {
      if ( strcmp( claim->strs[i], str ) == 0 )
         return 1;
   }
 
   return 0;
}

int claim_testSys( const Claim_t *claim, int sys )
{
   /* Must actually have a claim. */
   if ( claim == NULL )
      return 0;
 
   /* See if the system is claimed. */
   for ( int i = 0; i < array_size( claim->ids ); i++ )
      if ( claim->ids[i] == sys )
         return 1;
 
   return 0;
}

void claim_destroy( Claim_t *claim )
{
   if ( claim->active ) {
      for ( int i = 0; i < array_size( claim->ids ); i++ ) {
         StarSystem *sys = system_getIndex( claim->ids[i] );
         if ( claim->exclusive )
            sys_rmFlag( sys, SYSTEM_CLAIMED );
         else
            sys->claims_soft--;
      }
   }
   array_free( claim->ids );
 
   for ( int i = 0; i < array_size( claim->strs ); i++ ) {
      if ( claim->active ) {
         for ( int j = 0; j < array_size( claimed_strs ); j++ ) {
            if ( strcmp( claim->strs[i], claimed_strs[j] ) == 0 ) {
               free( claimed_strs[j] );
               array_erase( &claimed_strs, &claimed_strs[j],
                            &claimed_strs[j + 1] );
               break;
            }
         }
      }
      free( claim->strs[i] );
   }
   array_free( claim->strs );
   free( claim );
}

void claim_clear( void )
{
   /* Clears all the flags. */
   StarSystem *sys = system_getAll();
   for ( int i = 0; i < array_size( sys ); i++ ) {
      sys_rmFlag( &sys[i], SYSTEM_CLAIMED );
      sys[i].claims_soft = 0;
   }
 
   for ( int i = 0; i < array_size( claimed_strs ); i++ )
      free( claimed_strs[i] );
   array_free( claimed_strs );
   claimed_strs = NULL;
}

void claim_activateAll( void )
{
   claim_clear();
   event_activateClaims();
   missions_activateClaims();
}

void claim_activate( Claim_t *claim )
{
   /* Add flags. */
   for ( int i = 0; i < array_size( claim->ids ); i++ ) {
      StarSystem *sys = system_getIndex( claim->ids[i] );
      if ( claim->exclusive )
         sys_setFlag( sys, SYSTEM_CLAIMED );
      else
         sys->claims_soft++;
   }
 
   /* Add strings. */
   if ( ( claimed_strs == NULL ) && ( array_size( claim->strs ) > 0 ) )
      claimed_strs = array_create( char * );
   for ( int i = 0; i < array_size( claim->strs ); i++ )
      array_push_back( &claimed_strs, strdup( claim->strs[i] ) );
   claim->active = 1;
}

int claim_xmlSave( xmlTextWriterPtr writer, const Claim_t *claim )
{
   if ( claim == NULL )
      return 0;
 
   xmlw_attr( writer, "exclusive", "%d", claim->exclusive );
 
   for ( int i = 0; i < array_size( claim->ids ); i++ ) {
      StarSystem *sys = system_getIndex( claim->ids[i] );
      if ( sys != NULL )
         xmlw_elem( writer, "sys", "%s", sys->name );
      else
         WARN( _( "System Claim has inexistent system" ) );
   }
 
   for ( int i = 0; i < array_size( claim->strs ); i++ )
      xmlw_elem( writer, "str", "%s", claim->strs[i] );
 
   return 0;
}

Claim_t *claim_xmlLoad( xmlNodePtr parent )
{
   Claim_t   *claim;
   xmlNodePtr node;
   int        exclusive;
 
   /* Exclusiveness defaults to true due to older versions. */
   xmlr_attr_int_def( parent, "exclusive", exclusive, 1 );
 
   /* Create the claim. */
   claim = claim_create( exclusive );
 
   /* Load the nodes. */
   node = parent->xmlChildrenNode;
   do {
      if ( xml_isNode( node, "sys" ) ) {
         const StarSystem *sys = system_get( xml_get( node ) );
         if ( sys != NULL )
            claim_addSys( claim, system_index( sys ) );
         else
            WARN( _( "System Claim trying to load system '%s' which doesn't "
                     "exist" ),
                  xml_get( node ) );
      } else if ( xml_isNode( node, "str" ) ) {
         const char *str = xml_get( node );
         claim_addStr( claim, str );
      }
   } while ( xml_nextNode( node ) );
 
   /* Activate the claim. */
   claim_activate( claim );
 
   return claim;
}