#include "Fireball.h";

Fireball::Fireball(D3DXVECTOR3& position, LPD3DXMESH mesh){
    this->position = position;
    this->mesh = mesh;
}

Notice that we include the Fireball.h header file which holds function signatures and variables definitions.

#ifndef __Fireball_h__
#define __Fireball_h__


#include <d3d9.h> 
#include <d3dx9.h>

class Fireball
{
public:
    D3DXVECTOR3 position;
    LPD3DXMESH mesh;

    Fireball(D3DXVECTOR3& position, LPD3DXMESH mesh);
};

#endif

The Fireball's class constructor accepts position and mesh pointer of virtually any object, making it possible to use this class for many purposes.

#include "Fireball.h"

Now we have to decide what object we are going to use to store the collection of fireballs. In this project we are going to work with vector. Although it provides a sequentional access to its elements which is quiet slow, we have chosen to use it because most of the developers are usually familiar with the vector object. So if for instance you prefer to use a list to store your fireballs feel free to do so. In order to work with vector we have to include it in our application:

#include <vector>

We then define the fireballs vector where we can store multiple objects of the type Fireball we have created earlier.

vector<Fireball> fireballs;

The drawBoxFireMove() method is responsible for drawing each move of the fireball in our world. It takes the position and the mesh as parameters.

void drawBoxFireMove(D3DXVECTOR3 & position, LPD3DXMESH mesh){

    if(position.z >= MAX_FIREBALL_Z) return;
    
    D3DXCreateSphere(
    directXDevice,
    0.2f, // radius
    8, // slices
    2, // stacks
    &mesh,
    0);
    
    D3DXVECTOR3 direction = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 vectorA, vectorB;
    D3DXMATRIX matrix;

    vectorA = D3DXVECTOR3(position.x, position.y, position.z);
    position.z -= timeDelta;
    vectorB = D3DXVECTOR3(position.x, position.y, position.z);

    direction = vectorA - vectorB;
    D3DXVec3Normalize(&direction, &direction);
    position = vectorA + (direction * timeDelta);
    D3DXMatrixTranslation(&matrix, position.x, position.y, position.z);

    directXDevice->SetTransform(D3DTS_WORLD, &matrix);
    mesh->DrawSubset(0);
}

Since any given fireball can be rendered by using this method we have to take care that only the visible fireballs (these who did not yet reach the maximum z position value defined by MAX_FIREBALL_Z constant) are rendered and the rest is ignored. We then create a sphere object which holds the mesh of a fireball. In order to move an object from a position A to a position B we perform calculations with vectors that should not be difficult to understand if you have some fundamental knowledge of Linear Algebra.

// draw fireballs    
for(vector<Fireball>::reverse_iterator iterFireballs = fireballs.rbegin();
    iterFireballs != fireballs.rend(); ++iterFireballs){
    drawBoxFireMove(iterFireballs->position, iterFireballs->mesh);
}

Inside the DlgProcControlPanel() method we define a static variable to hold the number of fireballs fired by the flying box so far (note that this is not the number of elements in the fireballs vector):

static int    numberOfFireballsFired = 0;

and we add the processing of the following case:

case ID_FIREBALLS:
    numberOfFireballsFired += 1;
    SetDlgItemText(hwnd, ID_FIREBALLS, 
    (LPCSTR)CStr(numberOfFireballsFired).c_str());
break;

Then inside the WndProc() method we add the processing of [SPACE] keydown event:

case VK_SPACE: // box fireball
{
    D3DXVECTOR3 posFireball = posBox;
    LPD3DXMESH meshFireball = 0;
    Fireball fireball(posFireball, meshFireball);
    fireballs.push_back(fireball);
    SendMessage(hwndControlPanel, WM_COMMAND, ID_FIREBALLS, 0);
}
break;

If [SPACE] key is pressed we create new Fireball and add it to the fireballs vector by calling push_back() vector's method. Then we send a message to the hwndControlPanel window for further processing.