gatherable.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "vec2.h"
#include <stdio.h>
 
#include "naev.h"
 
#include "gatherable.h"
 
#include "array.h"
#include "hook.h"
#include "player.h"
#include "rng.h"
 
/* Gatherables */
#define GATHER_DIST 30. 
 
/* gatherables stack */
static Gatherable *gatherable_stack =
   NULL; 
static float   noscoop_timer = 1.; 
static IntList gather_qtquery;     
 
/* Prototypes. */
static int gatherable_gather( Gatherable *got, Pilot *p );

int gatherable_load( void )
{
   gatherable_stack = array_create( Gatherable );
   il_create( &gather_qtquery, 1 );
   return 0;
}

void gatherable_cleanup( void )
{
   array_free( gatherable_stack );
   gatherable_stack = NULL;
   il_destroy( &gather_qtquery );
}

int gatherable_init( const Commodity *com, const vec2 *pos, const vec2 *vel,
                     double lifeleng, int qtt, unsigned int player_only )
{
   Gatherable *g = &array_grow( &gatherable_stack );
   memset( g, 0, sizeof( Gatherable ) );
   g->type        = com;
   g->pos         = *pos;
   g->vel         = *vel;
   g->timer       = 0.;
   g->quantity    = qtt;
   g->sx          = RNG( 0, com->gfx_space->sx - 1 );
   g->sy          = RNG( 0, com->gfx_space->sy - 1 );
   g->player_only = player_only;
 
   if ( lifeleng < 0. )
      g->lifeleng = RNGF() * 100. + 50.;
   else
      g->lifeleng = lifeleng;
 
   return g - gatherable_stack;
}

void gatherable_update( double dt )
{
   Pilot *const *pilot_stack = pilot_getAll();
 
   /* Update the timer for "full cargo" message. */
   noscoop_timer += dt;
 
   for ( int i = array_size( gatherable_stack ) - 1; i >= 0; i-- ) {
      Gatherable *g = &gatherable_stack[i];
      const int   r = ceil( GATHER_DIST );
      int         x, y;
 
      g->timer += dt;
      g->pos.x += dt * g->vel.x;
      g->pos.y += dt * g->vel.y;
 
      /* Remove the gatherable */
      if ( g->timer > g->lifeleng ) {
         array_erase( &gatherable_stack, g, g + 1 );
         continue;
      }
 
      /* Only player can gather player only stuff. */
      if ( g->player_only ) {
         if ( ( player.p != NULL ) &&
              vec2_dist2( &player.p->solid.pos, &g->pos ) <=
                 pow2( GATHER_DIST ) )
            gatherable_gather( g, player.p );
         continue;
      }
 
      /* Check if can be picked up. */
      x = round( g->pos.x );
      y = round( g->pos.y );
      pilot_collideQueryIL( &gather_qtquery, x - r, y - r, x + r, y + r );
      for ( int j = 0; j < il_size( &gather_qtquery ); j++ ) {
         Pilot *p = pilot_stack[il_get( &gather_qtquery, j, 0 )];
 
         /* See if in distance. */
         if ( vec2_dist2( &p->solid.pos, &g->pos ) > pow2( GATHER_DIST ) )
            continue;
 
         /* Try to pick up. */
         if ( gatherable_gather( g, p ) )
            break;
      }
   }
}

void gatherable_free( void )
{
   array_erase( &gatherable_stack, array_begin( gatherable_stack ),
                array_end( gatherable_stack ) );
}

void gatherable_render( void )
{
   for ( int i = 0; i < array_size( gatherable_stack ); i++ ) {
      const Gatherable *gat = &gatherable_stack[i];
      gl_renderSprite( gat->type->gfx_space, gat->pos.x, gat->pos.y, gat->sx,
                       gat->sy, NULL );
   }
}

int gatherable_getClosest( const vec2 *pos, double rad )
{
   int    curg    = -1;
   double mindist = INFINITY;
 
   for ( int i = 0; i < array_size( gatherable_stack ); i++ ) {
      Gatherable *gat     = &gatherable_stack[i];
      double      curdist = vec2_dist( pos, &gat->pos );
      if ( ( curdist < mindist ) && ( curdist < rad ) ) {
         curg    = i;
         mindist = curdist;
      }
   }
   return curg;
}

int gatherable_getPos( vec2 *pos, vec2 *vel, int id )
{
   Gatherable *gat;
 
   if ( ( id < 0 ) || ( id > array_size( gatherable_stack ) - 1 ) ) {
      vectnull( pos );
      vectnull( vel );
      return 0;
   }
 
   gat  = &gatherable_stack[id];
   *pos = gat->pos;
   *vel = gat->vel;
 
   return 1;
}

static int gatherable_gather( Gatherable *gat, Pilot *p )
{
   int q;
 
   /* Must not be dead. */
   if ( pilot_isFlag( p, PILOT_DELETE ) || pilot_isFlag( p, PILOT_DEAD ) )
      return 0;
 
   /* Must not be hidden nor invisible. */
   if ( pilot_isFlag( p, PILOT_HIDE ) || pilot_isFlag( p, PILOT_INVISIBLE ) )
      return 0;
 
   /* Disabled pilots can't pick up stuff. */
   if ( pilot_isDisabled( p ) )
      return 0;
 
   /* Try to add cargo to pilot. */
   q = pilot_cargoAdd( p, gat->type, gat->quantity, 0 );
 
   if ( q > 0 ) {
      if ( pilot_isPlayer( p ) ) {
         HookParam hparam[3];
         player_message(
            n_( "%d ton of %s gathered", "%d tons of %s gathered", q ), q,
            _( gat->type->name ) );
 
         /* Run hooks. */
         hparam[0].type        = HOOK_PARAM_COMMODITY;
         hparam[0].u.commodity = (Commodity *)gat->type; /* TODO not cast. */
         hparam[1].type        = HOOK_PARAM_NUMBER;
         hparam[1].u.num       = q;
         hparam[2].type        = HOOK_PARAM_SENTINEL;
         hooks_runParam( "gather", hparam );
      }
 
      /* Remove the object from space. */
      array_erase( &gatherable_stack, gat, gat + 1 );
 
      /* Test if there is still cargo space */
      if ( ( pilot_cargoFree( p ) < 1 ) && ( pilot_isPlayer( p ) ) )
         player_message( _( "No more cargo space available" ) );
      return 1;
   } else if ( ( pilot_isPlayer( p ) ) && ( noscoop_timer > 2. ) ) {
      noscoop_timer = 0.;
      player_message(
         _( "Cannot gather material: no more cargo space available" ) );
   }
   return 0;
}