gatherable.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdio.h>
#include <stdint.h>
#include "physfs.h"
 
#include "naev.h"
#include "gatherable.h"
 
#include "array.h"
#include "hook.h"
#include "player.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;
}