ntime.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */

#include <stdio.h>
#include <stdlib.h>
 
#include "ntime.h"
 
#include "economy.h"
#include "hook.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 );
   }
}