[source="c++"]
// 1. Sprite location is consistantly measured in both *T(x) and *P(x)
// 2. *P(x) is the most accurate as it is in pixels.
// 3. When we add a new destination in to the m_vldestlist we do it as 
//    a difference in tiles from the current location
//    of said sprite.
// 4. We then convert the difference in tiles from the current sprite 
//    to a direct tile location - by either adding or subtracting
//    depending on the value of the number (+, - ).
void CSprite::Set_NewDest(int iMove_Tx, int iMove_Ty)
{
	unsigned int uiDest_X = 0;
	unsigned int uiDest_Y = 0;

	// First of all, does our destination have a different x co-ordinate?
	if( iMove_Tx )
	{
		// We have a movement value for the x co-ordinate and it is positive.
		if( iMove_Tx > 0 )
		{
			// Check to see if the value given is in acceptable range.
			if( (iMove_Tx*32)+m_uiPos_Px < NC_Grab_Map_Width() )
			{
				// Set our destination value.
				uiDest_X = m_iPos_Tx + iMove_Tx;
			}
		}
		// We have a movement value for the x co-ordinate and it is negetive.
		else
		{
			// Check to see if the value given is in acceptable range.
			if( (m_uiPos_Px + (iMove_Tx*32)) >= 0 )
			{
				// Set our destination value.
				uiDest_X = m_iPos_Tx + iMove_Tx;
			}	
		}
	}

	// First of all, does our destination have a different y co-ordinate?
	if( iMove_Ty )
	{
		// We have a movement value for the y co-ordinate and it is positive.
		if( iMove_Ty > 0 )
		{
			// Check to see if the value given is in acceptable range.
			if( (iMove_Ty*32)+m_uiPos_Py  < NC_Grab_Map_Height() )
			{
				// Set our destination value.
				uiDest_Y = m_iPos_Ty + iMove_Ty;
			}
		}
		// We have a movement value for the y co-ordinate and it is negetive.
		else
		{
			// Check to see if the value given is in acceptable range.
			if( (m_uiPos_Py + (iMove_Ty*32)) >= 0 )
			{
				// Set our destination value.
				uiDest_Y = m_iPos_Ty + iMove_Ty;
			}	
		}
	}

	// If one or more values are greater then zero, we're good to go.
	if( uiDest_X || uiDest_Y  )
	{
		// Insert the new destination into the list.
		sLocation sDest = {uiDest_X, uiDest_Y};
		m_vlDestList.push_back(sDest);
	}
	// Return happily.
	return;
}

[source="c++"]
/**********************************************************
Function: void CSprite_Manager::Query_SpriteStatus_LocationQueue_Status()
Description: Go through all of the sprites in the sprite list, checking all of their destinations
in their destination queue seeing if they are at the location of any of them.  If so,
we remove the destination from the queue and they move onto the next one.
The first of two Sprite manager's heartbeat functions.
Parameters: 
Returns: 
***********************************************************/
void CSprite_Manager::Query_SpriteStatus_LocationQueue_Status()
{
	// Our erase iterator.
	vector<sLocation>::iterator iter;

	unsigned int uiDestsID = 0;

	// Go through all of the sprites in the sprite list, checking all of their destinations
	// in their destination queue seeing if they are at the location of any of them.  If so,
	// we remove the destination from the queue and they move onto the next one.
	for (unsigned int uiIndex=0; uiIndex < m_vlpSprList.size(); uiIndex++)
	{
		m_vlpSprList[uiIndex]->Update_Animation();

		for (iter = m_vlpSprList[uiIndex]->m_vlDestList.begin(); iter< m_vlpSprList[uiIndex]->m_vlDestList.end(); iter++)
		{
			// If the sprite's location = the destination location, erase the
			// location from the queue and move on to the next.
			if ( m_vlpSprList[uiIndex]->bHas_ReachedDest(uiDestsID) )
			{
				m_vlpSprList[uiIndex]->m_vlDestList.erase(iter);
				Write_Log("Log: Detail: SpriteManager erased location from Sprite Location Queue.");
			}
			else
			{
				// We have found the first instance of a queue item that hasn't been completed.
				// Get the difference between the sprite's location and the destination's location.
				m_vlpSprList[uiIndex]->Move_Sprite(uiDestsID); 
			}

			// Increment our Destination index appropriately.
			uiDestsID++;
		}
	}
	return;
}

[source="c++"]
/**********************************************************
Function: void CSprite::Move_Sprite()
Description: Get the difference between our location and the destination.
			 if the movement distance is less then that distance, we can get
			 closer to it still without looping infinitely.
Parameters: 
Returns: None.
***********************************************************/
void CSprite::Move_Sprite(int iDestIndex)
{
	// If this index value has a movement value for either x or y...
	if( m_vlDestList[iDestIndex].iMove_Tx || m_vlDestList[iDestIndex].iMove_Ty )
	{
		// Holds the pixel value for our destination. This value is never negetive.
		guiDest_Px = m_vlDestList[iDestIndex].iMove_Tx * 32;
		guiDest_Py = m_vlDestList[iDestIndex].iMove_Ty * 32;

		// Allows us to maintain a contant rate of movement regardless of Frame Rate.
		dwTime = timeGetTime() - dwFrameTime;
		fFrameRatio = (dwTime / gkuiFRAME_RATE);

		// Calculate the distance we should move the player based on the moverate of the players sprite
		// divided by our framerate (to ensure a steady Rate of Movement).
		giSpr_MoveDist = m_iSpr_MoveRate/(fFrameRatio);

		if( guiDest_Py )
		{
			// If we still have iSpr_MoveDist or more pixels to go, great!
			// otherwise, we've reached our destination. 

			// We're headed North.
			//
			if( guiDest_Py < m_uiPos_Py )
			{
				// Find the absolute distance between location and destination.
				guiDiff_y = m_uiPos_Py - guiDest_Py;
				if( guiDiff_y >= giSpr_MoveDist )
					m_uiPos_Py -= giSpr_MoveDist;
			}

			// We're headed South.
			else if( guiDest_Py > m_uiPos_Py )
			{
				// Find the absolute distance between location and destination.
				guiDiff_y = guiDest_Py - m_uiPos_Py;
				if( guiDiff_y >= giSpr_MoveDist ) 
					m_uiPos_Py += giSpr_MoveDist;
			}
		}

		if( guiDest_Px )
		{
			//
			// We're headed West.
			if( guiDest_Px < m_uiPos_Px )
			{
				// Find the absolute distance between location and destination.
				guiDiff_x = m_uiPos_Px - guiDest_Px;
				if( guiDiff_x >= giSpr_MoveDist )
					m_uiPos_Px -= giSpr_MoveDist;
			}

			// We're headed East.
			else if( guiDest_Px > m_uiPos_Px )
			{
				// Find the absolute distance between location and destination.
				guiDiff_x = guiDest_Px - m_uiPos_Px;
				if( guiDiff_x >= giSpr_MoveDist ) 
					m_uiPos_Px += giSpr_MoveDist;
			}
		}

		// Get the current tile location of the Sprite.
		m_iPos_Tx = (m_uiPos_Px / 32);
		m_iPos_Ty = (m_uiPos_Py / 32);
	}
	// Return nothing, qed. ;)
	return;
}

[source="c++"]
if(KeyDown(cKeys,DIK_RIGHT))
{

	m_pSprMan->Clear_Sprite_Personal_Queue(1);
	m_pSprMan->Queue_Destination(1, 1, 0 );
	m_pSprMan->Set_Sprite_Facing(1, RIGHT);
}