ParticleSystem_Interactive Class Reference

This is an alternative class for particle systems. More...

#include <particlesystem_interactive.hpp>

Inherits GameObject.

Inherited by CometParticleSystem, and RainParticleSystem.

List of all members.

Public Member Functions
	ParticleSystem_Interactive ()
virtual	~ParticleSystem_Interactive ()
virtual void	draw (DrawingContext &context)
	The GameObject should draw itself onto the provided DrawingContext if this function is called.
Protected Member Functions
int	collision (Particle *particle, Vector movement)
Protected Attributes
int	z_pos
std::vector< Particle * >	particles
float	virtual_width
float	virtual_height
Classes
class	Particle

---

Detailed Description

This is an alternative class for particle systems.

It is responsible for storing a set of particles with each having an x- and y-coordinate the number of the layer where it should be drawn and a texture. This version of the particle system class doesn't use virtual screen coordinates, but Interactive ones. Particle systems which need Interactive levels coordinates, such as rain, should be implemented here. Classes that implement a particle system should subclass from this class, initialize particles in the constructor and move them in the simulate function.

Definition at line 38 of file particlesystem_interactive.hpp.

---

Constructor & Destructor Documentation

ParticleSystem_Interactive::ParticleSystem_Interactive

(

)

Definition at line 27 of file particlesystem_interactive.cpp.

References SCREEN_HEIGHT, SCREEN_WIDTH, virtual_height, virtual_width, and z_pos.

                                                       :
  z_pos(),
  particles(),
  virtual_width(),
  virtual_height()
{
  virtual_width = SCREEN_WIDTH;
  virtual_height = SCREEN_HEIGHT;
  z_pos = 0;
}

ParticleSystem_Interactive::~ParticleSystem_Interactive

(

)

[virtual]

Definition at line 38 of file particlesystem_interactive.cpp.

References particles.

{
  std::vector<Particle*>::iterator i;
  for(i = particles.begin(); i != particles.end(); ++i) {
    delete *i;
  }
}

---

Member Function Documentation

void ParticleSystem_Interactive::draw

(

DrawingContext &

context

)

[virtual]

The GameObject should draw itself onto the provided DrawingContext if this function is called.

Implements GameObject.

Definition at line 46 of file particlesystem_interactive.cpp.

References DrawingContext::draw_surface(), particles, DrawingContext::pop_transform(), DrawingContext::push_transform(), and z_pos.

{
  context.push_transform();

  std::vector<Particle*>::iterator i;
  for(i = particles.begin(); i != particles.end(); ++i) {
    Particle* particle = *i;
    context.draw_surface(particle->texture, particle->pos, z_pos);
  }

  context.pop_transform();
}

int ParticleSystem_Interactive::collision	(	Particle *	particle,
		Vector	movement
	)			[protected]

Definition at line 60 of file particlesystem_interactive.cpp.

References Sector::current(), collision::intersects(), CollisionHit::left, Rectf::move(), ParticleSystem_Interactive::Particle::pos, collision::rectangle_aatriangle(), CollisionHit::right, collision::set_rectangle_rectangle_constraints(), Tile::SOLID, Sector::solid_tilemaps, Tile::WATER, Vector::x, and Vector::y.

Referenced by RainParticleSystem::update(), and CometParticleSystem::update().

{
  using namespace collision;

  // calculate rectangle where the object will move
  float x1, x2;
  float y1, y2;
  x1 = object->pos.x;
  x2 = x1 + 32 + movement.x;
  y1 = object->pos.y;
  y2 = y1 + 32 + movement.y;
  bool water = false;

  // test with all tiles in this rectangle
  int starttilex = int(x1-1) / 32;
  int starttiley = int(y1-1) / 32;
  int max_x = int(x2+1);
  int max_y = int(y2+1);

  Rectf dest(x1, y1, x2, y2);
  dest.move(movement);
  Constraints constraints;

  for(std::list<TileMap*>::const_iterator i = Sector::current()->solid_tilemaps.begin(); i != Sector::current()->solid_tilemaps.end(); i++) {
    TileMap* solids = *i;
    // FIXME Handle a nonzero tilemap offset
    for(int x = starttilex; x*32 < max_x; ++x) {
      for(int y = starttiley; y*32 < max_y; ++y) {
        const Tile* tile = solids->get_tile(x, y);
        if(!tile)
          continue;
        // skip non-solid tiles, except water
        if(! (tile->getAttributes() & (Tile::WATER | Tile::SOLID)))
          continue;

        Rectf rect = solids->get_tile_bbox(x, y);
        if(tile->is_slope ()) { // slope tile
          AATriangle triangle = AATriangle(rect, tile->getData());

          if(rectangle_aatriangle(&constraints, dest, triangle)) {
            if(tile->getAttributes() & Tile::WATER)
              water = true;
          }
        } else { // normal rectangular tile
          if(intersects(dest, rect)) {
            if(tile->getAttributes() & Tile::WATER)
              water = true;
            set_rectangle_rectangle_constraints(&constraints, dest, rect);
          }
        }
      }
    }
  }

  // TODO don't use magic numbers here...

  // did we collide at all?
  if(!constraints.has_constraints())
    return -1;

  const CollisionHit& hit = constraints.hit;
  if (water) {
    return 0; //collision with water tile - don't draw splash
  } else {
    if (hit.right || hit.left) {
      return 2; //collision from right
    } else {
      return 1; //collision from above
    }
  }

  return 0;
}

---

Member Data Documentation

int ParticleSystem_Interactive::z_pos [protected]

Definition at line 68 of file particlesystem_interactive.hpp.

Referenced by draw(), RainParticleSystem::parse(), CometParticleSystem::parse(), and ParticleSystem_Interactive().

std::vector<Particle*> ParticleSystem_Interactive::particles [protected]

Definition at line 69 of file particlesystem_interactive.hpp.

Referenced by CometParticleSystem::CometParticleSystem(), draw(), RainParticleSystem::RainParticleSystem(), RainParticleSystem::update(), CometParticleSystem::update(), and ~ParticleSystem_Interactive().

float ParticleSystem_Interactive::virtual_width [protected]

Definition at line 70 of file particlesystem_interactive.hpp.

Referenced by CometParticleSystem::CometParticleSystem(), ParticleSystem_Interactive(), RainParticleSystem::RainParticleSystem(), RainParticleSystem::update(), and CometParticleSystem::update().

float ParticleSystem_Interactive::virtual_height [protected]

Definition at line 71 of file particlesystem_interactive.hpp.

Referenced by CometParticleSystem::CometParticleSystem(), ParticleSystem_Interactive(), and RainParticleSystem::RainParticleSystem().

---

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

• src/object/particlesystem_interactive.hpp
• src/object/particlesystem_interactive.cpp

---