ntime.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdio.h>
#include <stdlib.h>
 
#include "naev.h"
#include "ntime.h"
 
#include "economy.h"
#include "hook.h"
#include "nstring.h"
 
#define NT_SECONDS_DIV   (1000)      /* Divider for extracting seconds. */
#define NT_SECONDS_DT    (30)        /* Update rate, how many seconds are in a real second. */
#define NT_CYCLE_SECONDS   ((ntime_t)NT_CYCLE_PERIODS*(ntime_t)NT_PERIOD_SECONDS) /* Seconds in a cycle */
#define NT_PERIODS_DIV   ((ntime_t)NT_PERIOD_SECONDS*(ntime_t)NT_SECONDS_DIV) /* Divider for extracting periods. */
#define NT_CYCLES_DIV   ((ntime_t)NT_CYCLE_SECONDS*(ntime_t)NT_SECONDS_DIV) /* Divider for extracting cycles. */
 
typedef struct NTimeUpdate_s {
   struct NTimeUpdate_s *next; 
   ntime_t inc; 
} NTimeUpdate_t;
static NTimeUpdate_t *ntime_inclist = NULL; 
static ntime_t naev_time = 0; 
static double naev_remainder = 0.; 
static int ntime_enable = 1; 
void ntime_update( double dt )
{
   double dtt, tu;
   ntime_t inc;
 
   /* Only if we need to update. */
   if (!ntime_enable)
      return;
 
   /* Calculate the effective time. */
   dtt = naev_remainder + dt*NT_SECONDS_DT*NT_SECONDS_DIV;
 
   /* Time to update. */
   tu             = floor( dtt );
   inc            = (ntime_t) tu;
   naev_remainder = dtt - tu; /* Leave remainder. */
 
   /* Increment. */
   naev_time     += inc;
   hooks_updateDate( inc );
}
 
ntime_t ntime_create( int scu, int stp, int stu )
{
   ntime_t tscu, tstp, tstu;
   tscu = scu;
   tstp = stp;
   tstu = stu;
   return tscu*NT_CYCLES_DIV + tstp*NT_PERIODS_DIV + tstu*NT_SECONDS_DIV;
}
 
ntime_t ntime_get (void)
{
   return naev_time;
}
 
void ntime_getR( int *cycles, int *periods, int *seconds, double *rem )
{
   *cycles = ntime_getCycles( naev_time );
   *periods = ntime_getPeriods( naev_time );
   *seconds = ntime_getSeconds( naev_time );
   *rem = ntime_getRemainder( naev_time ) + naev_remainder;
}
 
int ntime_getCycles( ntime_t t )
{
   return (t / NT_CYCLES_DIV);
}
 
int ntime_getPeriods( ntime_t t )
{
   return (t / NT_PERIODS_DIV) % NT_CYCLE_PERIODS;
}
 
int ntime_getSeconds( ntime_t t )
{
   return (t / NT_SECONDS_DIV) % NT_PERIOD_SECONDS;
}
 
double ntime_convertSeconds( ntime_t t )
{
   return ((double)t / (double)NT_SECONDS_DIV);
}
 
double ntime_getRemainder( ntime_t t )
{
   return (double)(t % NT_SECONDS_DIV);
}
 
char* ntime_pretty( ntime_t t, int d )
{
   char str[64];
   ntime_prettyBuf( str, sizeof(str), t, d );
   return strdup(str);
}
 
void ntime_prettyBuf( char *str, int max, ntime_t t, int d )
{
   ntime_t nt;
   int cycles, periods, seconds;
 
   if (t==0)
      nt = naev_time;
   else
      nt = t;
 
   /* UST (Universal Synchronized Time) - unit is seconds */
   cycles = ntime_getCycles( nt );
   periods = ntime_getPeriods( nt );
   seconds = ntime_getSeconds( nt );
   if ((cycles == 0) && (periods == 0)) /* only seconds */
      snprintf( str, max, _("%04d s"), seconds );
   else if ((cycles == 0) || (d==0))
      snprintf( str, max, _("%.*f p"), d, periods + 0.0001 * seconds );
   else /* UST format */
      snprintf( str, max, _("UST %d:%.*f"), cycles, d, periods + 0.0001 * seconds );
}
 
void ntime_set( ntime_t t )
{
   naev_time      = t;
   naev_remainder = 0.;
}
 
void ntime_setR( int cycles, int periods, int seconds, double rem )
{
   naev_time   = ntime_create( cycles, periods, seconds );
   naev_time  += floor(rem);
   naev_remainder = fmod( rem, 1. );
}
 
void ntime_inc( ntime_t t )
{
   naev_time += t;
   economy_update( t );
 
   /* Run hooks. */
   if (t > 0)
      hooks_updateDate( t );
}
 
void ntime_allowUpdate( int enable )
{
   ntime_enable = enable;
}
 
void ntime_incLagged( ntime_t t )
{
   NTimeUpdate_t *ntu, *iter;
 
   /* Create the time increment. */
   ntu = malloc(sizeof(NTimeUpdate_t));
   ntu->next = NULL;
   ntu->inc = t;
 
   /* Only member. */
   if (ntime_inclist == NULL)
      ntime_inclist = ntu;
 
   else {
      /* Find end of list. */
      for (iter = ntime_inclist; iter->next != NULL; iter = iter->next);
      /* Append to end. */
      iter->next = ntu;
   }
}
 
void ntime_refresh (void)
{
   NTimeUpdate_t *ntu;
 
   /* We have to run all the increments one by one to ensure all hooks get
    * run and that no collisions occur. */
   while (ntime_inclist != NULL) {
      ntu = ntime_inclist;
 
      /* Run hook stuff and actually update time. */
      naev_time += ntu->inc;
      economy_update( ntu->inc );
 
      /* Remove the increment. */
      ntime_inclist = ntu->next;
 
      /* Free the increment. */
      free(ntu);
   }
}