ParticleEngine Class Reference

#include <particle.h>

Collaboration diagram for ParticleEngine:

[legend]List of all members.

Public Types
	NoESmoke
	LittleESmoke
	BigESmoke
enum	ESmokeStyle { NoESmoke, LittleESmoke, BigESmoke }
Public Member Functions
	ParticleEngine (uint time=100)
void	AddPeriodic (const Point2i &position, particle_t type, bool upper, double angle=-1, double norme=-1)
Static Public Member Functions
static void	Init ()
static void	FreeMem ()
static Sprite *	GetSprite (particle_spr type)
static void	AddNow (const Point2i &position, uint nb_particles, particle_t type, bool upper, double angle=-1, double norme=-1)
static void	AddNow (Particle *particle)
static void	AddExplosionSmoke (const Point2i &pos, const uint &radius, ESmokeStyle &style)
static void	Refresh ()
static void	Draw (bool upper)
static void	Stop ()
static PhysicalObj *	IsSomethingMoving ()
Static Private Member Functions
static void	AddLittleESmoke (const Point2i &pos, const uint &radius)
static void	AddBigESmoke (const Point2i &pos, const uint &radius)
Private Attributes
uint	m_last_refresh
uint	m_time_between_add
Static Private Attributes
static Sprite *	particle_sprite [particle_spr_nbr]
static std::list< Particle * >	lst_particles

---

Detailed Description

Definition at line 83 of file particle.h.

---

Member Enumeration Documentation

enum ParticleEngine::ESmokeStyle

Enumerator:

NoESmoke
LittleESmoke
BigESmoke

Definition at line 112 of file particle.h.

{ NoESmoke, LittleESmoke, BigESmoke }; // Style of smoke explosion (quantitie of smoke)

---

Constructor & Destructor Documentation

ParticleEngine::ParticleEngine

(

uint

time = 100

)

Definition at line 114 of file particle.cpp.

{
  m_time_between_add = time ;
  m_last_refresh = Time::GetInstance()->Read();
}

Here is the call graph for this function:

---

Member Function Documentation

void ParticleEngine::AddBigESmoke	(	const Point2i &	pos,
		const uint &	radius
	)			[static, private]

Definition at line 240 of file particle.cpp.

{
  //Add many little smoke particles
  // Sin / cos  precomputed value, to avoid recomputing them and speed up.
  // see the commented value of 'angle' to see how it was generated
  const uint little_partic_nbr = 10;
  const float little_cos[] = { 1.000000, 0.809017, 0.309017, -0.309017, -0.809017, -1.000000, -0.809017, -0.309017, 0.309017, 0.809017 };
  const float little_sin[] = { 0.000000, 0.587785, 0.951057, 0.951056, 0.587785, -0.000000, -0.587785, -0.951056, -0.951056, -0.587785 };

  Particle *particle = NULL;
  float norme;
  uint size;

  for(uint i=0; i < little_partic_nbr ; i++)
  {
//      angle = (float) i * M_PI * 2.0 / (float) little_partic_nbr;
      size = uint(radius / 1.5);
      norme = 2.5 * radius / 3.0;

      particle = new ExplosionSmoke(size);
      particle->SetOnTop(true);

      Point2i pos = position; //Set position to center of explosion
      pos = pos - size / 2;       //Set the center of the smoke to the center..
      pos = pos + Point2i(int(norme * little_cos[i]),int(norme * little_sin[i])); //Put inside the circle of the explosion

      particle->SetXY(pos);
      lst_particles.push_back(particle);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParticleEngine::AddExplosionSmoke	(	const Point2i &	pos,
		const uint &	radius,
		ESmokeStyle &	style
	)			[static]

Definition at line 301 of file particle.cpp.

{
  if(style == NoESmoke) return;
  AddLittleESmoke (position, radius);
  if(style == BigESmoke) AddBigESmoke (position, radius);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParticleEngine::AddLittleESmoke	(	const Point2i &	pos,
		const uint &	radius
	)			[static, private]

Definition at line 271 of file particle.cpp.

{
  //Add a few big smoke particles
  const uint big_partic_nbr = 5;
  // Sin / cos  precomputed value, to avoid recomputing them and speed up.
  // see the commented value of 'angle' to see how it was generated
  const float big_cos[] = { 1.000000, -0.809017, 0.309017, 0.309017, -0.809017 };
  const float big_sin[] = { 0.000000, 0.587785, -0.951056, 0.951057, -0.587785 };

  Particle *particle = NULL;
  float norme;
  uint size;
  for(uint i=0; i < big_partic_nbr ; i++)
  {
//      angle = (float) i * M_PI * 4.0 / (float)big_partic_nbr;
      size = radius;
      norme = radius / 3.0;

      Point2i pos = position; //Set position to center of explosion
      pos = pos - size / 2;       //Set the center of the smoke to the center..
      pos = pos + Point2i(int(norme * big_cos[i]),int(norme * big_sin[i])); //Put inside the circle of the explosion

      particle = new ExplosionSmoke(size);
      particle->SetXY(pos);
      particle->SetOnTop(true);

      lst_particles.push_back(particle);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParticleEngine::AddNow

(

Particle *

particle

)

[static]

Definition at line 235 of file particle.cpp.

{
  lst_particles.push_back(particle);
}

void ParticleEngine::AddNow	(	const Point2i &	position,
		uint	nb_particles,
		particle_t	type,
		bool	upper,
		double	angle = -1,
		double	norme = -1
	)			[static]

Definition at line 178 of file particle.cpp.

{
  Particle *particle = NULL;
  double tmp_angle, tmp_norme;

  for (uint i=0 ; i < nb_particles ; i++) {
    switch (type) {
      case particle_SMOKE : particle = new Smoke();
                            break;
      case particle_ILL_BUBBLE : particle = new IllBubble();
                            break;
      case particle_DARK_SMOKE : particle = new DarkSmoke();
                            break;
      case particle_FIRE : particle = new FireParticle();
                           break;
      case particle_STAR : particle = new StarParticle();
                           break;
      case particle_BULLET : particle = new BulletParticle();
                           break;
      case particle_POLECAT_FART : particle = new PolecatFart();
                           break;
      case particle_GROUND : particle = new GroundParticle(Point2i(10,10), position);
                           break;
      case particle_AIR_HAMMER : particle = new GroundParticle(Point2i(21,18), position); 
        // Half the size of the airhammer impact
        // Dirty, but we have no way to read the
        // impact size from here ...
                           break;
      case particle_MAGIC_STAR : particle = new MagicStarParticle();
                                 break;
      default : particle = NULL;
                assert(0);
                break;
    }

    if (particle != NULL) {
      if( norme == -1 )
                  tmp_norme = double(randomObj.GetLong(0, 5000))/100;
      else
                  tmp_norme = norme;

      if( angle == -1 )
                  tmp_angle = - double(randomObj.GetLong(0, 3000))/1000;
      else
                  tmp_angle = angle;

      particle->SetXY(position);
      particle->SetOnTop(upper);
      particle->SetSpeed(tmp_norme, tmp_angle);
      lst_particles.push_back(particle);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParticleEngine::AddPeriodic	(	const Point2i &	position,
		particle_t	type,
		bool	upper,
		double	angle = -1,
		double	norme = -1
	)

Definition at line 121 of file particle.cpp.

{
  // time spent since last refresh (in milliseconds)
  uint time = Time::GetInstance()->Read() - m_last_refresh;
  uint tmp = Time::GetInstance()->Read();

  uint delta = uint(m_time_between_add * double(randomObj.GetLong(3,40))/10);
  if (time >= delta) {
    m_last_refresh = tmp;
    ParticleEngine::AddNow(position, 1, type, upper, angle, norme);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParticleEngine::Draw

(

bool

upper

)

[static]

Definition at line 308 of file particle.cpp.

{
  std::list<Particle *>::iterator Particle_it;
  // draw the particles
  for (Particle_it=lst_particles.begin(); Particle_it!=lst_particles.end(); ++Particle_it){
    if ( (*Particle_it)->IsOnTop() == upper) {
      (*Particle_it)->Draw();
    }
  }

}

Here is the caller graph for this function:

void ParticleEngine::FreeMem

(

)

[static]

Definition at line 166 of file particle.cpp.

{
  for(int i=0; i<particle_spr_nbr ; i++)
    delete global_particle_engine.particle_sprite[i];
}

Sprite * ParticleEngine::GetSprite

(

particle_spr

type

)

[static]

Definition at line 172 of file particle.cpp.

{
  assert(type < particle_spr_nbr);
  return new Sprite(*(global_particle_engine.particle_sprite[type]));
}

Here is the caller graph for this function:

void ParticleEngine::Init

(

)

[static]

Definition at line 142 of file particle.cpp.

{
  // Pre-load the sprite of each particle
  Profile *res = resource_manager.LoadXMLProfile( "weapons.xml", false);
  particle_sprite[SMOKE_spr] = resource_manager.LoadSprite(res,"smoke");
  particle_sprite[EXPLOSION_SMOKE_spr] = resource_manager.LoadSprite(res,"smoke_explosion");
  particle_sprite[ILL_BUBBLE_spr] = resource_manager.LoadSprite(res,"ill_bubble");
  particle_sprite[FIRE_spr]  = resource_manager.LoadSprite(res,"fire_particle");
  particle_sprite[FIRE_spr]->EnableRotationCache(32);
  particle_sprite[STAR_spr]  = resource_manager.LoadSprite(res,"star_particle");
  particle_sprite[DARK_SMOKE_spr]  = resource_manager.LoadSprite(res,"dark_smoke");
  particle_sprite[MAGIC_STAR_R_spr] = resource_manager.LoadSprite(res,"pink_star_particle");
  particle_sprite[MAGIC_STAR_R_spr]->EnableRotationCache(32);
  particle_sprite[MAGIC_STAR_Y_spr] = resource_manager.LoadSprite(res,"yellow_star_particle");
  particle_sprite[MAGIC_STAR_Y_spr]->EnableRotationCache(32);
  particle_sprite[MAGIC_STAR_B_spr] = resource_manager.LoadSprite(res,"blue_star_particle");
  particle_sprite[MAGIC_STAR_B_spr]->EnableRotationCache(32);
  particle_sprite[BULLET_spr] = resource_manager.LoadSprite(res,"bullet_particle");
  particle_sprite[BULLET_spr]->EnableRotationCache(6);
  particle_sprite[POLECAT_FART_spr] = resource_manager.LoadSprite(res,"polecat_fart");
  particle_sprite[POLECAT_FART_spr]->EnableRotationCache(6);
  resource_manager.UnLoadXMLProfile(res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PhysicalObj * ParticleEngine::IsSomethingMoving

(

)

[static]

Definition at line 349 of file particle.cpp.

{
  std::list<Particle *>::iterator Particle_it;
  // check if particle need to be check in end of turn
  for (Particle_it=lst_particles.begin(); Particle_it!=lst_particles.end(); ++Particle_it)
    if ((*Particle_it)->CheckOnEndTurn() && (*Particle_it)->StillUseful())
      return *Particle_it;
  return NULL;
}

Here is the caller graph for this function:

void ParticleEngine::Refresh

(

)

[static]

Definition at line 320 of file particle.cpp.

{
  // remove old particles
  std::list<Particle*>::iterator it=lst_particles.begin(), end=lst_particles.end();
  while (it != end) {
    if (! (*it)->StillUseful()) {
      delete *it;
      it = lst_particles.erase(it);
    }
    else
      it++;
  }

  // update the particles
  for(it=lst_particles.begin(); it!=lst_particles.end(); ++it) {
    (*it)->Refresh();
  }
}

Here is the caller graph for this function:

void ParticleEngine::Stop

(

)

[static]

Definition at line 339 of file particle.cpp.

{
  // remove all the particles
  std::list<Particle*>::iterator it=lst_particles.begin(), end=lst_particles.end();
  while (it != end) {
    delete *it;
    it = lst_particles.erase(it);
  }
}

Here is the caller graph for this function:

---

Member Data Documentation

std::list< Particle * > ParticleEngine::lst_particles [static, private]

Definition at line 90 of file particle.h.

uint ParticleEngine::m_last_refresh [private]

Definition at line 86 of file particle.h.

uint ParticleEngine::m_time_between_add [private]

Definition at line 87 of file particle.h.

Sprite * ParticleEngine::particle_sprite [static, private]

Definition at line 89 of file particle.h.

---

The documentation for this class was generated from the following files:

• src/particles/particle.h
• src/particles/particle.cpp

---