commodity.c

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdio.h>
#include <stdint.h>
#include "physfs.h"
 
#include "naev.h"
#include "commodity.h"
 
#include "conf.h"
#include "array.h"
#include "economy.h"
#include "gatherable.h"
#include "hook.h"
#include "log.h"
#include "ndata.h"
#include "nstring.h"
#include "ntime.h"
#include "nxml.h"
#include "pilot.h"
#include "player.h"
#include "rng.h"
#include "space.h"
#include "spfx.h"
 
#define XML_COMMODITY_ID      "commodity" 
#define CRED_TEXT_MAX         (ECON_CRED_STRLEN-4) /* Maximum length of just credits2str text, no markup */
 
/* commodity stack */
Commodity* commodity_stack = NULL; 
static Commodity** commodity_temp = NULL; 
/* @TODO remove externs. */
extern int *econ_comm;
 
/*
 * Prototypes.
 */
/* Commodity. */
static void commodity_freeOne( Commodity* com );
static int commodity_parse( Commodity *temp, const char *filename );
 
void credits2str( char *str, credits_t credits, int decimals )
{
   if (decimals < 0) {
      /* TODO support , separator like fmt.credits(). */
      snprintf( str, CRED_TEXT_MAX, _("%.*f ¤"), 0, (double)credits );
   }
   else if (credits >= 1000000000000000000LL)
      snprintf( str, CRED_TEXT_MAX, _("%.*f E¤"), decimals, (double)credits / 1e18 );
   else if (credits >= 1000000000000000LL)
      snprintf( str, CRED_TEXT_MAX, _("%.*f P¤"), decimals, (double)credits / 1e15 );
   else if (credits >= 1000000000000LL)
      snprintf( str, CRED_TEXT_MAX, _("%.*f T¤"), decimals, (double)credits / 1e12 );
   else if (credits >= 1000000000L)
      snprintf( str, CRED_TEXT_MAX, _("%.*f G¤"), decimals, (double)credits / 1e9 );
   else if (credits >= 1000000)
      snprintf( str, CRED_TEXT_MAX, _("%.*f M¤"), decimals, (double)credits / 1e6 );
   else if (credits >= 1000)
      snprintf( str, CRED_TEXT_MAX, _("%.*f k¤"), decimals, (double)credits / 1e3 );
   else
      snprintf (str, CRED_TEXT_MAX, _("%.*f ¤"), decimals, (double)credits );
}
 
void price2str(char *str, credits_t price, credits_t credits, int decimals )
{
   char buf[ CRED_TEXT_MAX ];
 
   if (price <= credits) {
      credits2str( str, price, decimals );
      return;
   }
 
   credits2str( buf, price, decimals );
   snprintf( str, ECON_CRED_STRLEN, "#r%s#0", (char*)buf );
}
 
void tonnes2str( char *str, int tonnes )
{
   snprintf( str, ECON_MASS_STRLEN, n_( "%d tonne", "%d tonnes", tonnes ), tonnes );
}
 
Commodity* commodity_getAll (void)
{
   return commodity_stack;
}
 
Commodity* commodity_get( const char* name )
{
   Commodity *c = commodity_getW( name );
   if (c!=NULL)
      return c;
   WARN(_("Commodity '%s' not found in stack"), name);
   return NULL;
}
 
Commodity* commodity_getW( const char* name )
{
   for (int i=0; i<array_size(commodity_stack); i++)
      if (strcmp(commodity_stack[i].name, name) == 0)
         return &commodity_stack[i];
   for (int i=0; i<array_size(commodity_temp); i++)
      if (strcmp(commodity_temp[i]->name, name) == 0)
         return commodity_temp[i];
   return NULL;
}
 
int commodity_getN (void)
{
   return array_size(econ_comm);
}
 
Commodity* commodity_getByIndex( const int indx )
{
   if (indx < 0 || indx >= array_size(econ_comm)) {
      WARN(_("Commodity with index %d not found"),indx);
      return NULL;
   }
   return &commodity_stack[econ_comm[indx]];
}
 
static void commodity_freeOne( Commodity* com )
{
   CommodityModifier *this,*next;
   free(com->name);
   free(com->description);
   free(com->price_ref);
   gl_freeTexture(com->gfx_store);
   gl_freeTexture(com->gfx_space);
   next = com->spob_modifier;
   com->spob_modifier = NULL;
   while (next != NULL ) {
      this = next;
      next = this->next;
      free(this->name);
      free(this);
   }
   next = com->faction_modifier;
   com->faction_modifier = NULL;
   while (next != NULL ) {
      this=next;
      next=this->next;
      free(this->name);
      free(this);
   }
   array_free(com->illegalto);
   /* Clear the memory. */
   memset(com, 0, sizeof(Commodity));
}
 
int commodity_compareTech( const void *commodity1, const void *commodity2 )
{
   const Commodity *c1, *c2;
 
   /* Get commodities. */
   c1 = * (const Commodity**) commodity1;
   c2 = * (const Commodity**) commodity2;
 
   /* Compare price. */
   if (c1->price < c2->price)
      return +1;
   else if (c1->price > c2->price)
      return -1;
 
   /* It turns out they're the same. */
   return strcmp( c1->name, c2->name );
}
 
Commodity ** standard_commodities (void)
{
   int n = array_size(commodity_stack);
   Commodity **com = array_create_size( Commodity*, n );
   for (int i=0; i<n; i++) {
      Commodity *c = &commodity_stack[i];
      if (commodity_isFlag(c,COMMODITY_FLAG_STANDARD))
         array_push_back( &com, c );
   }
   return com;
}
 
static int commodity_parse( Commodity *temp, const char *filename )
{
   xmlNodePtr node, parent;
   xmlDocPtr doc;
 
   doc = xml_parsePhysFS( filename );
   if (doc == NULL)
      return -1;
 
   parent = doc->xmlChildrenNode; /* Commodities node */
   if (strcmp((char*)parent->name,XML_COMMODITY_ID)) {
      ERR(_("Malformed %s file: missing root element '%s'"), filename, XML_COMMODITY_ID);
      return -1;
   }
 
   /* Clear memory and set defaults. */
   memset( temp, 0, sizeof(Commodity) );
   temp->period   = 200;
   temp->price_mod = 1.;
 
   /* Parse body. */
   node = parent->xmlChildrenNode;
   do {
      xml_onlyNodes(node);
 
      xmlr_strd(node, "name", temp->name);
      xmlr_strd(node, "description", temp->description);
      xmlr_int(node, "price", temp->price);
      xmlr_float(node, "price_mod", temp->price_mod);
      xmlr_strd(node, "price_ref", temp->price_ref);
 
      if (xml_isNode(node,"gfx_space")) {
         temp->gfx_space = xml_parseTexture( node,
               COMMODITY_GFX_PATH"space/%s", 1, 1, OPENGL_TEX_MIPMAPS );
         continue;
      }
      if (xml_isNode(node,"gfx_store")) {
         temp->gfx_store = xml_parseTexture( node,
               COMMODITY_GFX_PATH"%s", 1, 1, OPENGL_TEX_MIPMAPS );
         continue;
      }
      if (xml_isNode(node, "standard")) {
         commodity_setFlag( temp, COMMODITY_FLAG_STANDARD );
         continue;
      }
      if (xml_isNode(node, "always_can_sell")) {
         commodity_setFlag( temp, COMMODITY_FLAG_ALWAYS_CAN_SELL );
         continue;
      }
      if (xml_isNode(node, "price_constant")) {
         commodity_setFlag( temp, COMMODITY_FLAG_PRICE_CONSTANT );
         continue;
      }
      if (xml_isNode(node, "illegalto")) {
         xmlNodePtr cur = node->xmlChildrenNode;
         temp->illegalto = array_create( int );
         do {
            xml_onlyNodes(cur);
            if (xml_isNode(cur, "faction")) {
               int f = faction_get( xml_get(cur) );
               array_push_back( &temp->illegalto, f );
            }
         } while (xml_nextNode(node));
         continue;
      }
      xmlr_float(node, "population_modifier", temp->population_modifier);
      xmlr_float(node, "period", temp->period);
      if (xml_isNode(node, "spob_modifier")) {
         CommodityModifier *newdict = malloc(sizeof(CommodityModifier));
         newdict->next = temp->spob_modifier;
         xmlr_attr_strd(node, "type", newdict->name);
         newdict->value = xml_getFloat(node);
         temp->spob_modifier = newdict;
         continue;
      }
      if (xml_isNode(node, "faction_modifier")) {
         CommodityModifier *newdict = malloc(sizeof(CommodityModifier));
         newdict->next = temp->faction_modifier;
         xmlr_attr_strd(node, "type", newdict->name);
         newdict->value = xml_getFloat(node);
         temp->faction_modifier = newdict;
         continue;
      }
 
      WARN(_("Commodity '%s' has unknown node '%s'"),temp->name, node->name);
   } while (xml_nextNode(node));
 
   if (temp->name == NULL)
      WARN( _("Commodity from %s has invalid or no name"), COMMODITY_DATA_PATH);
 
   if ((temp->price > 0) || (temp->price_ref != NULL)) {
      if (temp->gfx_store == NULL) {
         WARN(_("No <gfx_store> node found, using default texture for commodity \"%s\""), temp->name);
         temp->gfx_store = gl_newImage( COMMODITY_GFX_PATH"_default.webp", 0 );
      }
   }
   if (temp->gfx_space == NULL)
      temp->gfx_space = gl_newImage( COMMODITY_GFX_PATH"space/_default.webp", 0 );
 
   if (temp->price_ref != NULL) {
      if (temp->price > 0.)
         WARN(_("Commodity '%s' is setting both 'price' and 'price_ref'."),temp->name);
   }
 
#if 0 /* shouldn't be needed atm */
#define MELEMENT(o,s)   if (o) WARN( _("Commodity '%s' missing '"s"' element"), temp->name)
   MELEMENT(temp->description==NULL,"description");
   MELEMENT(temp->high==0,"high");
   MELEMENT(temp->medium==0,"medium");
   MELEMENT(temp->low==0,"low");
#undef MELEMENT
#endif
 
   xmlFreeDoc(doc);
 
   return 0;
}
 
int commodity_checkIllegal( const Commodity *com, int faction )
{
   for (int i=0; i<array_size(com->illegalto); i++) {
      if (com->illegalto[i] == faction)
         return 1;
   }
   return 0;
}
 
int commodity_isTemp( const char* name )
{
   for (int i=0; i<array_size(commodity_temp); i++)
      if (strcmp(commodity_temp[i]->name, name) == 0)
         return 1;
   for (int i=0; i<array_size(commodity_stack); i++)
      if (strcmp(commodity_stack[i].name,name)==0)
         return 0;
 
   WARN(_("Commodity '%s' not found in stack"), name);
   return 0;
}
 
Commodity* commodity_newTemp( const char* name, const char* desc )
{
   Commodity **c;
   if (commodity_temp == NULL)
      commodity_temp = array_create( Commodity* );
 
   c              = &array_grow(&commodity_temp);
   *c             = calloc( 1, sizeof(Commodity) );
   (*c)->istemp   = 1;
   (*c)->name     = strdup(name);
   (*c)->description = strdup(desc);
   return *c;
}
 
int commodity_tempIllegalto( Commodity *com, int faction )
{
   int *f;
 
   if (!com->istemp) {
      WARN(_("Trying to modify temporary commodity '%s'!"), com->name);
      return -1;
   }
 
   if (com->illegalto==NULL)
      com->illegalto = array_create( int );
 
   /* Don't add twice. */
   for (int i=0; i<array_size(com->illegalto); i++) {
      if (com->illegalto[i] == faction)
         return 0;
   }
 
   f = &array_grow(&com->illegalto);
   *f = faction;
 
   return 0;
}
 
int commodity_load (void)
{
   char **commodities = ndata_listRecursive( COMMODITY_DATA_PATH );
   Uint32 time = SDL_GetTicks();
 
   commodity_stack = array_create( Commodity );
   econ_comm = array_create( int );
 
   gatherable_load();
 
   for (int i=0; i<array_size(commodities); i++) {
      Commodity c;
      int ret = commodity_parse( &c, commodities[i] );
      if (ret == 0) {
         array_push_back( &commodity_stack, c );
 
         /* See if should get added to commodity list. */
         if (c.price > 0.) {
            int *e = &array_grow( &econ_comm );
            *e = array_size(commodity_stack)-1;
         }
 
         /* Render if necessary. */
         naev_renderLoadscreen();
      }
      free( commodities[i] );
   }
   array_free( commodities );
 
   if (conf.devmode) {
      time = SDL_GetTicks() - time;
      DEBUG( n_( "Loaded %d Commodity in %.3f s", "Loaded %d Commodities in %.3f s", array_size(commodity_stack) ), array_size(commodity_stack), time/1000. );
   }
   else
      DEBUG( n_( "Loaded %d Commodity", "Loaded %d Commodities", array_size(commodity_stack) ), array_size(commodity_stack) );
 
   return 0;
}
 
void commodity_free (void)
{
   for (int i=0; i<array_size(commodity_stack); i++)
      commodity_freeOne( &commodity_stack[i] );
   array_free( commodity_stack );
   commodity_stack = NULL;
 
   for (int i=0; i<array_size(commodity_temp); i++) {
      commodity_freeOne( commodity_temp[i] );
      free( commodity_temp[i] );
   }
   array_free( commodity_temp );
   commodity_temp = NULL;
 
   /* More clean up. */
   array_free( econ_comm );
   econ_comm = NULL;
 
   gatherable_cleanup();
}