damagetype.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <inttypes.h>
#include "SDL.h"
 
#include "naev.h"
#include "damagetype.h"
 
#include "array.h"
#include "log.h"
#include "ndata.h"
#include "nxml.h"
#include "pause.h"
#include "pilot.h"
#include "rng.h"
#include "shipstats.h"
 
#define DTYPE_XML_ID     "dtype"   
typedef struct DTYPE_ {
   char* name;    
   double sdam;   
   double adam;   
   double knock;  
   size_t soffset; 
   size_t aoffset; 
} DTYPE;
 
static DTYPE* dtype_types  = NULL;  
/*
 * prototypes
 */
static int DTYPE_parse( DTYPE *temp, const char *file);
static void DTYPE_free( DTYPE *damtype );
static DTYPE* dtype_validType( int type );
 
static int DTYPE_parse( DTYPE *temp, const char *file )
{
   xmlNodePtr node, parent;
   xmlDocPtr doc;
   char *stat;
 
   /* Load and read the data. */
   doc = xml_parsePhysFS( file );
   if (doc == NULL)
      return -1;
 
   /* Check to see if document exists. */
   parent = doc->xmlChildrenNode;
   if (!xml_isNode(parent,DTYPE_XML_ID)) {
      WARN(_("Malformed '%s' file: missing root element '%s'"), file, DTYPE_XML_ID);
      return -1;
   }
 
   /* Clear data. */
   memset( temp, 0, sizeof(DTYPE) );
 
   xmlr_attr_strd( parent, "name", temp->name );
 
   /* Extract the data. */
   node = parent->xmlChildrenNode;
   do {
      xml_onlyNodes(node);
 
      if (xml_isNode(node, "shield")) {
         temp->sdam = xml_getFloat(node);
 
         xmlr_attr_strd( node, "stat", stat );
         if (stat != NULL) {
            temp->soffset = ss_offsetFromType( ss_typeFromName(stat) );
            free(stat);
         }
 
         continue;
      }
      else if (xml_isNode(node, "armour")) {
         temp->adam = xml_getFloat(node);
 
         xmlr_attr_strd( node, "stat", stat );
         if (stat != NULL) {
            temp->aoffset = ss_offsetFromType( ss_typeFromName(stat) );
            free(stat);
         }
 
         continue;
      }
      xmlr_float(node, "knockback", temp->knock);
 
      WARN(_("Unknown node of type '%s' in damage node '%s'."), node->name, temp->name);
   } while (xml_nextNode(node));
 
#define MELEMENT(o,s) \
   if (o) WARN(_("DTYPE '%s' invalid '"s"' element"), temp->name) 
   MELEMENT(temp->sdam<0.,"shield");
   MELEMENT(temp->adam<0.,"armour");
   MELEMENT(temp->knock<0.,"knockback");
#undef MELEMENT
 
   /* Clean up. */
   xmlFreeDoc(doc);
 
   return 0;
}
 
static void DTYPE_free( DTYPE *damtype )
{
   free(damtype->name);
   damtype->name = NULL;
}
 
int dtype_get( const char* name )
{
   for (int i=0; i<array_size(dtype_types); i++)
      if (strcmp(dtype_types[i].name, name)==0)
         return i;
   WARN(_("Damage type '%s' not found in stack."), name);
   return -1;
}
 
static DTYPE* dtype_validType( int type )
{
   if ((type < 0) || (type >= array_size(dtype_types))) {
      WARN(_("Damage type '%d' is invalid."), type);
      return NULL;
   }
   return &dtype_types[ type ];
}
 
const char* dtype_damageTypeToStr( int type )
{
   DTYPE *dmg = dtype_validType( type );
   if (dmg == NULL)
      return NULL;
   return dmg->name;
}
 
int dtype_load (void)
{
   const DTYPE normal = {
      .name = strdup(N_("normal")),
      .sdam = 1.,
      .adam = 1.,
      .knock = 0.,
      .soffset = 0,
      .aoffset = 0,
   };
   char **dtype_files = ndata_listRecursive( DTYPE_DATA_PATH );
 
   /* Load up the individual damage types. */
   dtype_types = array_create(DTYPE);
   array_push_back( &dtype_types, normal );
 
   for (int i=0; i<array_size(dtype_files); i++) {
      DTYPE dtype;
      int ret = DTYPE_parse( &dtype, dtype_files[i] );
      if (ret == 0)
         array_push_back( &dtype_types, dtype );
      free( dtype_files[i] );
   }
   array_free( dtype_files );
 
   /* Shrink back to minimum - shouldn't change ever. */
   array_shrink( &dtype_types );
 
   return 0;
}
 
void dtype_free (void)
{
   /* clear the damtypes */
   for (int i=0; i<array_size(dtype_types); i++)
      DTYPE_free( &dtype_types[i] );
   array_free( dtype_types );
   dtype_types    = NULL;
}
 
int dtype_raw( int type, double *shield, double *armour, double *knockback )
{
   DTYPE *dtype = dtype_validType( type );
   if (dtype == NULL)
      return -1;
   if (shield != NULL)
      *shield = dtype->sdam;
   if (armour != NULL)
      *armour = dtype->adam;
   if (knockback != NULL)
      *knockback = dtype->knock;
   return 0;
}
 
void dtype_calcDamage( double *dshield, double *darmour, double absorb, double *knockback, const Damage *dmg, const ShipStats *s )
{
   DTYPE *dtype;
   char *ptr;
   double multiplier;
 
   /* Must be valid. */
   dtype = dtype_validType( dmg->type );
   if (dtype == NULL)
      return;
 
   /* Set if non-nil. */
   if (dshield != NULL) {
      if ((dtype->soffset <= 0) || (s == NULL))
         *dshield    = dtype->sdam * dmg->damage * absorb;
      else {
         /*
          * If an offset has been specified, look for a double at that offset
          * in the ShipStats struct, and used it as a multiplier.
          *
          * The 1. - n logic serves to convert the value from absorption to
          * damage multiplier.
          */
         ptr = (char*) s;
         memcpy(&multiplier, &ptr[ dtype->soffset ], sizeof(double));
         multiplier = MAX( 0., 1. - multiplier );
         *dshield = dtype->sdam * dmg->damage * absorb * multiplier;
      }
   }
   if (darmour != NULL) {
      if ((dtype->aoffset) <= 0 || (s == NULL))
         *darmour    = dtype->adam * dmg->damage * absorb;
      else {
         ptr = (char*) s;
         memcpy(&multiplier, &ptr[ dtype->aoffset ], sizeof(double));
         multiplier = MAX( 0., 1. - multiplier );
         *darmour = dtype->adam * dmg->damage * absorb * multiplier;
      }
   }
 
   if (knockback != NULL)
      *knockback  = dtype->knock;
}