#include "extdll.h"

#include "util.h"

#include "cbase.h"

#include "monsters.h"

#include "weapons.h"

#include "animation.h"

#include "effects.h"

#include "nodes.h"

#include "explode.h"

#include "player.h"

#define FIRE_SPRITE_NAME		"particles/fire.aur"

#define BURNIND_SOUND_NAME		"ambience/burning1.wav"

// must match definition in modelgen.h

enum synctype_t

{

  ST_SYNC=0,

  ST_RAND

};

// TODO: shorten these?

typedef struct {

  int			ident;

  int			version;

  int			type;

  int			texFormat;

  float		boundingradius;

  int			width;

  int			height;

  int			numframes;

  float		beamlength;

  synctype_t	synctype;

} dsprite_t;

class CPropExplosion : public CGrenade

{

  void Spawn( void );

  void Precache( void );

  int	 BloodColor( void ) { return DONT_BLEED; };

  void EXPORT PropThink( void );

  void RunFire( void );

  void StartExplode( void );

  float CalculationSpriteScale( );

  void KeyValue( KeyValueData *pkvd );

  virtual int		Save( CSave &save );

  virtual int		Restore( CRestore &restore );

  static	TYPEDESCRIPTION m_SaveData[];

  string_t m_iszParentName;

  int		m_startHealth;

  float	m_firetime;

  float	m_explosiontime;

  float	m_dmgradius;

  bool	m_isfire;

};

LINK_ENTITY_TO_CLASS( prop_explosion, CPropExplosion );

TYPEDESCRIPTION	CPropExplosion::m_SaveData[] =

{

  DEFINE_FIELD( CPropExplosion, m_startHealth, FIELD_INTEGER ),

  DEFINE_FIELD( CPropExplosion, m_firetime, FIELD_FLOAT ),

  DEFINE_FIELD( CPropExplosion, m_explosiontime, FIELD_FLOAT ),

  DEFINE_FIELD( CPropExplosion, m_dmgradius, FIELD_FLOAT ),

  DEFINE_FIELD( CPropExplosion, m_isfire, FIELD_INTEGER ),

};

IMPLEMENT_SAVERESTORE( CPropExplosion, CGrenade );

void CPropExplosion :: KeyValue( KeyValueData *pkvd )

{

  if (FStrEq(pkvd->szKeyName, "health"))//skin is used for content type

  {

    m_startHealth = atoi(pkvd->szValue);

    pkvd->fHandled = TRUE;

  }

  else if (FStrEq(pkvd->szKeyName, "firetime"))

  {

    m_firetime = atof(pkvd->szValue);

    pkvd->fHandled = TRUE;

  }

  else if (FStrEq(pkvd->szKeyName, "damageradius"))

  {

    m_dmgradius = atof(pkvd->szValue);

    pkvd->fHandled = TRUE;

  }

  else

    CGrenade::KeyValue( pkvd );

}

void CPropExplosion :: Spawn( void )

{

  Precache( );

  // motor

  pev->movetype = MOVETYPE_FLY;

  pev->solid = SOLID_BBOX;

  SET_MODEL( ENT(pev), STRING(pev->model) );

  Vector mins;

  Vector maxs;

  ExtractBbox( pev->sequence, mins, maxs );

  UTIL_SetSize(pev, mins, maxs ); //Whi it is not using for other entities ?

  UTIL_SetOrigin(this, pev->origin );

  DROP_TO_FLOOR( edict() );

  pev->nextthink = gpGlobals->time + 0.1;

  //	SetTouch( PropTouch ); //maybe later

  SetThink( PropThink );

  //If not defined, add standart value

  if(!m_startHealth )

  {

    m_startHealth = 50;

  }

  if(!m_firetime)

  {

    m_firetime = 4;

  }

  if(!m_dmgradius )

  {

    m_dmgradius = 100;

  }

  m_isfire = false;

  pev->flags |= FL_MONSTER;

  pev->takedamage		= DAMAGE_YES;

  pev->health			= m_startHealth;

  pev->dmg			= 50;

}

void CPropExplosion::Precache( void )

{

  PRECACHE_MODEL((char *)STRING(pev->model));

  PRECACHE_MODEL( FIRE_SPRITE_NAME );

  PRECACHE_SOUND( BURNIND_SOUND_NAME );

}

void CPropExplosion::PropThink( void )

{

  if( pev->health	< m_startHealth )

  {

    if(!m_explosiontime)

    {

      m_explosiontime = gpGlobals->time + m_firetime;

    }

    else

    {

      if( m_explosiontime < gpGlobals->time )

      {

        StartExplode( );

      }

      else

      {

        RunFire( );

      }

    }

  }

  pev->nextthink = gpGlobals->time + 0.1;

}

void CPropExplosion::RunFire( void )

{

  if(!m_isfire )

  {

    CSprite *pSprite = CSprite::SpriteCreate( FIRE_SPRITE_NAME, pev->origin, TRUE );

    pSprite->AnimateAndDie( m_firetime );

    pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation );

    pSprite->SetScale( CalculationSpriteScale() );

    EMIT_SOUND(ENT(pev), CHAN_WEAPON, BURNIND_SOUND_NAME, 1, ATTN_NORM);

    m_isfire = true;

  }

}

void CPropExplosion::StartExplode( void )

{

  STOP_SOUND( ENT(pev), CHAN_WEAPON, BURNIND_SOUND_NAME );

  UTIL_ScreenShake( pev->origin, 16, 200, 5, m_dmgradius );

  ExplosionCreate( pev->origin, pev->angles, edict(), (int)m_dmgradius, true );

  UTIL_Remove( this );

}

float CPropExplosion::CalculationSpriteScale( )

{

  dsprite_t *szSprite = NULL;

  float SpriteX = 0;

  float SpriteY = 0;

  float ModelX = 0;

  float ModelY = 0;

  szSprite = (dsprite_t *)g_engfuncs.pfnLoadFileForMe( FIRE_SPRITE_NAME, NULL );

  if (!szSprite)

  {

    ALERT( at_aiconsole,"Couldn't open fire sprites !\n");

    return 1.0;

  }

  SpriteX = szSprite->width;

  SpriteY = szSprite->height;

  g_engfuncs.pfnFreeFile( szSprite );

  Vector mins;

  Vector maxs;

  ExtractBbox( pev->sequence, mins, maxs );

  ModelX = maxs.x - mins.x;

  ModelY = maxs.z - mins.z;

  float FullSprSizeX = ModelX * 3; //pixel to unit ~ 2 ???

  float FullSprSizeY = ModelY * 3;

  float ScaleX = FullSprSizeX / SpriteX;

  float ScaleY = FullSprSizeY / SpriteY;

  float Averagescale = ( ScaleX + ScaleY ) / 2;

  //Debug

  /*

  	ALERT( at_console, "Sprite: x = %f, y = %f\n", SpriteX, SpriteY  );

  	ALERT( at_console, "Model:  x = %f, y = %f\n", ModelX,  ModelY   );

  	ALERT( at_console, "Full Sprite size:  x = %f, y = %f\n", SpriteX * Averagescale,  SpriteY * Averagescale );

  	ALERT( at_console, "Scale:  x = %f, y = %f\n", ScaleX,  ScaleY  );

  	ALERT( at_console, "Average Scale: %f", Averagescale );

  	*/

  return Averagescale;

}