particle.c

Linux游戏编程源码

#include <math.h>
#include <stdlib.h>
#include "gamedefs.h"
#include "particle.h"

particle_t particles[MAX_PARTICLES];
int active_particles = 0;

static void AddParticle(particle_p particle);
static void DeleteParticle(int index);
static Uint16 CreateHicolorPixel(SDL_PixelFormat * fmt, Uint8 red,
				 Uint8 green, Uint8 blue);

static void AddParticle(particle_p particle)
{
    /* If there are already too many particles, forget it. */
    if (active_particles >= MAX_PARTICLES)
	return;

    particles[active_particles] = *particle;
    active_particles++;
}

/* Removes a particle from the system (by index). */
static void DeleteParticle(int index)
{
    /* Replace the particle with the one at the end
       of the list, and shorten the list. */
    particles[index] = particles[active_particles - 1];
    active_particles--;
}

/* Draws all active particles on the screen. */
void DrawParticles(SDL_Surface * dest, int camera_x, int camera_y)
{
    int i;
    Uint16 *pixels;

    /* Lock the target surface for direct access. */
    if (SDL_LockSurface(dest) != 0)
	return;
    pixels = (Uint16 *) dest->pixels;

    for (i = 0; i < active_particles; i++) {
	int x, y;
	Uint16 color;

	/* Convert world coords to screen coords. */
	x = particles[i].x - camera_x;
	y = particles[i].y - camera_y;
	if ((x < 0) || (x >= SCREEN_WIDTH))
	    continue;
	if ((y < 0) || (y >= SCREEN_HEIGHT))
	    continue;

	/* Find the color of this particle. */
	color = CreateHicolorPixel(dest->format,
				   particles[i].r,
				   particles[i].g, particles[i].b);

	/* Draw the particle. */
	pixels[(dest->pitch / 2) * y + x] = color;
    }

    /* Release the screen. */
    SDL_UnlockSurface(dest);
}

/* Updates the position of each particle. Kills particles with
   zero energy. */
void UpdateParticles(void)
{
    int i;

    for (i = 0; i < active_particles; i++) {
	particles[i].x += particles[i].energy *
	    cos(particles[i].angle * PI / 180.0) * time_scale;
	particles[i].y += particles[i].energy *
	    -sin(particles[i].angle * PI / 180.0) * time_scale;

	/* Fade the particle's color. */
	particles[i].r--;
	particles[i].g--;
	particles[i].b--;
	if (particles[i].r < 0)
	    particles[i].r = 0;
	if (particles[i].g < 0)
	    particles[i].g = 0;
	if (particles[i].b < 0)
	    particles[i].b = 0;

	/* If the particle has faded to black, delete it. */
	if ((particles[i].r + particles[i].g + particles[i].b) == 0) {
	    DeleteParticle(i);

	    /* DeleteParticle replaces the current particle with the one
	       at the end of the list, so we'll need to take a step back. */
	    i--;
	}
    }
}

/* Creates a particle explosion of the given relative size and position. */
void CreateParticleExplosion(int x, int y, int r, int g, int b, int energy,
			     int density)
{
    int i;
    particle_t particle;

    /* Create a number of particles proportional to the size of the explosion. */
    for (i = 0; i < density; i++) {

	particle.x = x;
	particle.y = y;
	particle.angle = rand() % 360;
	particle.energy = (double) (rand() % (energy * 1000)) / 1000.0;

	/* Set the particle's color. */
	particle.r = r;
	particle.g = g;
	particle.b = b;

	/* Add the particle to the particle system. */
	AddParticle(&particle);
    }
}

/* This is directly from another code listing. It creates a 16-bit pixel. */
static Uint16 CreateHicolorPixel(SDL_PixelFormat * fmt, Uint8 red,
				 Uint8 green, Uint8 blue)
{
    Uint16 value;

    /* This series of bit shifts uses the information from the SDL_Format
       structure to correctly compose a 16-bit pixel value from 8-bit red,
       green, and blue data. */
    value = (((red >> fmt->Rloss) << fmt->Rshift) +
	     ((green >> fmt->Gloss) << fmt->Gshift) +
	     ((blue >> fmt->Bloss) << fmt->Bshift));

    return value;
}