I've been searching like a bloodhound through forum archives for some working source code of a particle explosion. Does anyone think they could point me towards a tutorial or just provide some code directly? I'll keep searching but I think human's understand what I'm looking for better than the search algorithm does.

Blargmob's basic approach is good, though I'd recommend that you dispense with the array and just simply maintain a big list of "graphical objects" in your program, all of which can have individual velocity, acceleration, lifetimes, and so on.

In my recent projects, having every sprite/etc. on the screen be considered a "Particle" and treated the same has simplified rendering and updating significantly, at the expense of slightly more memory and CPU usage (that is not an issue at all on a PC built this century).

That's assuming all of your particles in the system are the same texture, and your "big list" isn't optimized to provide similar benefits.

In my case, neither of those assumptions are true, but I agree, mileage may vary.

I think you'd learn even better by trying. Write some thoughts down on how you think it would be done and then try to code it yourself. When you get stuck at this point, then come here and show your work.

Thanks for the advice, but I'm still going to go with learning by example.

I believe the phrase goes something like, "Why reinvent the wheel?"

I'd really appreciate it if someone would post something that I could learn from. I want to learn. I want to.........LEARN!!! :p

And a good way to learn is by doing... Blargmob gave you an algorithm you could implement in your very first reply. Translating it to code shouldn't be too difficult if you just try. Here's an example based on his algorithm (untested, uncompiled) :

And a quick example of usage :

Why use malloc when you're using c++, why use doubles? you don't seem to have the ability to end the life of a particle, or group particles together as distinct units, or reuse the memory for new particles.

The thing is new and delete are part of C++, that is memory allocation and freeing are part of the language, when in C (malloc and free), they are provided by the system library.

When you use new it calls that class constructor if there is one, and delete calls the destructor. If new for some reason can't allocate the memory, the default action is to throw an exception, where malloc just returns a NULL pointer.

You can use malloc to allocate an area in memory for a struct, but you can't really use it to create a class on the heap.

(AFAIK you can use malloc, then manually call the constructor, then manually call the destructor before freeing it, but you are really asking for trouble if you go down that path.)

Edit:
and please for the love of whatever deity you follow, use -> to dereference your pointers

What is the specific task the OP is having trouble with?

Idealius: your example fails. It took me less than a day to learn how to bounce rectangles around on the screen. Ok, I used circles instead of rectangles, but it's the same thing. A particle explosion is much different.

I learned in QBASIC too!

My biggest problem with a particle explosion was always the random direction thing. I could make things go up, down, left, right, or at a 45 degree angle to any of those, but it wasn't until just recently that I learned how to make things go in any direction. I still have trouble with particle effects, though.

I began working with 2d environments a little over 2 weeks ago. Before that, it was all text, learning for and while loops, arrays, etc, etc, all the basics. I'm still not that familiar with implementing physics for objects in 2d. I made a bouncy ball program but I'm pretty sure I cheated.

I'd say I'm probably around step 5.

I'm going to try out some of the examples posted here, although I can already tell that it may be difficult for me to understand. I'll post back later with how I did.

Thanks for all the replies! I woke up this morning and was like, "Whoa! 17 replies!!"

----------

I can't seem to figure out how to add a post right after my last post, so I'm just going to use the "minus bar" and edit this post.

Schyfis, I tried out your code and I threw together a working program below (oh yeah, I don't know how to put it in a cool code window). I'm a little confused about it though, mainly this line:

particle* p = (particle*)malloc(sizeof(particle));

This allocates memory for each particle in the vector, am I right? But, why is it necessary to do this? Is it because particle p has been declared as a pointer? And if so, why not just directly declare p as not a pointer? Full working program below:

#include <allegro.h>
#include <ctime>
#include <math.h>
#include <vector>

using namespace std;

BITMAP* buffer;

//define a particle structure
typedef struct particle {
//we'll need an x and y position for each particle
int x, y;
//the particles are going to be moving,
//so here's x velocity and y velocity
int xvel, yvel;
//let's also keep track of the old
//x and y positions so we can draw the
//particles as lines instead of just points
int oldx, oldy;
};
//create a vector of pointers to particles (kind of like an array)
vector <particle*> particles;
/*
explode: a function to make a particle explosion
parameters:
x: the horizontal position of the explosion's center
y: the vertical position of the explosion's center
num: number of particles in the explosion
*/
void explode(int x, int y, int num) {
//initializes the random number generator with the current time as the seed
srand(time(0));
//for loop to create num particles
for(int i=0; i<num; i++) {
//allocates memory for our new particle
//note that this is a pointer to a particle, not the particle itself
particle* p = (particle*)malloc(sizeof(particle));
//set x, y, oldx, and oldy to the center of the explosion
(*p).x = (*p).oldx = x;
(*p).y = (*p).oldy = y;
//set xvel and yvel to random numbers between -4 and 4
(*p).xvel=rand()%64-rand()%64;
(*p).yvel=rand()%64-rand()%64;
// (*p).xvel=-1;
// (*p).yvel=0;
//add the particle pointer to our vector
particles.push_back(p);
}
}
/*
stepParticles: a function to step the particles through one frame of movement
parameters: none
notes:
-call this function every time you go through your game loop.
-remember that particles is a vector of pointers, so you have to dereference them!
*/
void stepParticles(){
//iterate through our vector of particle pointers
//particles.size() gets the total number of elements in the vector
for(int i=0; i<particles.size(); i++){
//set oldx and oldy to the current values of x and y
(*particles.at(i)).oldx=(*particles.at(i)).x;
(*particles.at(i)).oldy=(*particles.at(i)).y;
//now we add xvel and yvel to x and y so the particles move
(*particles.at(i)).x+=(*particles.at(i)).xvel;
(*particles.at(i)).y+=(*particles.at(i)).yvel;
}
}
/*
drawParticles: a function to draw the particles on the screen
parameters: none
notes: call this function every time you go through your game loop.
*/
void drawParticles() {
//iterate through the vector like last time
for(int i=0; i<particles.size(); i++){
//you'll have to have a BITMAP named buffer for this to work,
//assuming you're double buffering
line(buffer,
(*particles.at(i)).x, (*particles.at(i)).y,
(*particles.at(i)).oldx, (*particles.at(i)).oldy,
makecol(255,127,0));
//it spans many lines to make it easier to read
}
}

int main(){
allegro_init();
install_keyboard();
set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0);
set_color_depth(32);

buffer = create_bitmap(640,480);

// particle.x = 200;
// particle.y = 200;
// particle.xvel = 5;
// particle.yvel = 5;

//an example of your game loop
while(!key[KEY_ESC]){
clear_keybuf();
if(key[KEY_SPACE]){

srand(time(0));
//make explosion at random place on the screen
//explode(rand()%SCREEN_W, rand()%SCREEN_H, 5);
explode(300,240,100);
}

clear(buffer);
stepParticles();
drawParticles();
blit(buffer,screen,0,0,0,0,buffer->w,buffer->h);

rest(20);

}
}
END_OF_MAIN();

Thanks someone972, for showing me how to do the code thing.

By the way, what's a memory leak?

I'll play around with the particles for a while a post back if I run into more trouble with it. Thanks for all the help everyone!

Whenever you allocate memory, either using malloc (plain C) or new (C++), you are putting your hands around a bit of memory that can't be used for anything else. It is good practice to deallocate anything you allocate, either using free (plain C) or delete (C++). Most OS (that is, I believe it is the OS that does this), deallocates memory on the program's exit. However, it's still good practice to do it yourself, and if you are allocating memory for things that only exist for a moment in your program, you are wasting memory and this can cause the entire computer to run out.