Sorry your browser is not supported!

	//----------------- Laser List Creation -----------------
	std::list<CLaser> lLaser;

	//----------------- Laser Handling ----------------- 
	for (std::list<CLaser>::iterator i = lLaser.begin(); i != lLaser.end(); i++) {
		i->updateLaser();
	}

	//----------------- Laser creation  -----------------
	if (laserTimer1 <= clock()) {
		CLaser x;
		lLaser.push_front(x);
		laserTimer1 = clock() + ( rand() % 10 + 1 ) * CLOCKS_PER_SEC;
	}

	// Draw the image
	dbSprite(25,lasX,lasY,25);
	dbSetSpritePriority(25,1);

#include <stack>

IndexManager::IndexManager(void)
{
	Indices = 0;
}

/**
* @brief	[Constructor] Creates a Stack of IDs
* @param	int size - start number of IDs pushed to the stack from highest to lowest LIFO order.
*/
IndexManager::IndexManager(int size)
{
	Indices = size;
	for(size+=1;size>0;size--){
		UnusedIndexStack.push(size);
	}
}

IndexManager::~IndexManager(void)
{
}

/**
* @brief	Returns the next ID.
* @param	void
* @return	
*/
int IndexManager::Peek(void)
{
	int ID;
	if(UnusedIndexStack.size() == 1)
	{
		ID = Indices + 1;
	}
	else
	{
		ID = UnusedIndexStack.top();
	}
	return(ID);
}

/**
* @brief	Pops ID from stack. If stack is empty it will increase the index return its value as the ID
* @param	void
* @return	[out]int - 
*/
int IndexManager::Pop(void)
{
	int ID;
	if(UnusedIndexStack.size() == 1){
		ID = ++Indices;
	}
	else
	{
		ID = UnusedIndexStack.top();
		UnusedIndexStack.pop();
	}
	UsedIndexList.push_back(ID);
	return(ID);
}

/**
* @brief	Pushes ID to stack for reuse.
* @param	int ID - pushed on to the stack.
* @return	
*/
void IndexManager::Push(int ID)
{
	UnusedIndexStack.push(ID);
	UsedIndexList.remove(ID);
}

/**
* @brief	Returns index total aka number from IDs 1 to n
* @param	int count - value equal total number of Indices
* @return	
*/
int IndexManager::Total(void)
{
	return(Indices);
}

/**
* @brief	Returns count of IDs not used
* @param	int count - value equal number of Indices in not used
* @return	
*/
int IndexManager::Unused(void)
{
	return(UnusedIndexStack.size());
}

/**
* @brief	Returns count of IDs used
* @param	int count - value equal number of Indices used
* @return	
*/
int IndexManager::Used(void)
{
	return(UsedIndexList.size());
}

#define MAXIMUM_INDICES 256
IndexManager UniqueIDManager = new IndexManager(MAXIMUM_INDICES);

int CLaser::SpriteID = UniqueIDManager->Pop();
// Draw the image
dbSprite(CLaser::SpriteID,lasX,lasY,SpriteID);
dbSetSpritePriority(CLaser::SpriteID,1);

dbDeleteSprite(SpriteID);
UniqueIDManager->Push(SpriteID);