1 reply to this topic

[daviangel]

Anyone else have this book and using VS2005 with the source code?

The reason I ask is that I'm having a hard time trying to get the code to compile under VS2005 since I think the source code was originally compiled under VC6 since the first error I ran into is the for loop variable not found error since the scope changes from VC6 to VC2005 but I easily fixed those.
Then I ran into strmiids.lib linker errors which I found out was due to missing directshow library files which aren't included with latest DX SDK(I'm using oct 06 version). I fixed that by downloading latest vista platform sdk which includes directshow stuff.
Anyways the final error that I need help with is a vector.erase error that I think needs a cast to work properly but I can't figure it out so I just commented it out for now the line in question is this:
open.erase(&open[bestPlace]); // Take the best node out of the Open list

more code in context below
Thanks for any help since there's nowhere else to turn...

code:

std::vector<INTPOINT> TERRAIN::GetPath(INTPOINT start, INTPOINT goal, bool considerUnits, MAPOBJECT *unit)
{
	try
	{
		//Check that the two points are within the bounds of the map
		MAPTILE *startTile = GetTile(start);
		MAPTILE *goalTile = GetTile(goal);
		
		if(!Within(start) || !Within(goal) || start == goal || startTile == NULL || goalTile == NULL)
			return std::vector<INTPOINT>();

		//Check if a path exists
		if(!startTile->m_walkable || !goalTile->m_walkable || startTile->m_set != goalTile->m_set)
			return std::vector<INTPOINT>();

		//Check that goal tile isnt busy if considering units
		if(considerUnits && goalTile->m_pMapObject != NULL)
			goal = GetClosestFreeTile(goal, start);

		if(H(start, goal) < 10 && considerUnits && !PositionAccessible(unit, goal))
			return std::vector<INTPOINT>();

		//Init Search
		long numTiles = m_size.x * m_size.y;
		for(long l=0;l<numTiles;l++)
		{
			m_pMapTiles[l].f = m_pMapTiles[l].g = INT_MAX;		//Clear F,G
			m_pMapTiles[l].open = m_pMapTiles[l].closed = false;	//Reset Open and Closed
		}

		std::vector<MAPTILE*> open;				//Create Our Open list
		startTile->g = 0;						//Init our starting point (SP)
		startTile->f = H(start, goal);
		startTile->open = true;
		open.push_back(startTile);				//Add SP to the Open list

		bool found = false;					// Search as long as a path hasnt been found,

		while(!found && !open.empty())		// or there is no more tiles to search
		{	
			MAPTILE * best = open[0];        // Find the best tile (i.e. the lowest F value)
			int bestPlace = 0;
			for(int i=1;i<open.size();i++)
				if(open[i] != NULL && open[i]->f < best->f)
				{
					best = open[i];
					bestPlace = i;
				}
			
			if(best == NULL)break;			//No path found
			if(considerUnits && open.size() > 100)break;

			open[bestPlace]->open = false;
		open.erase(&open[bestPlace]);	// Take the best node out of the Open list

			if(best->m_mappos == goal)		//If the goal has been found
			{
				std::vector<INTPOINT> p, p2;
				MAPTILE *point = best;

				while(point->m_mappos != start && point != NULL)	// Generate path
				{
					p.push_back(point->m_mappos);
					point = point->m_pParent;

					if(p.size() > 500)		//Too long path, something is wrong
						return std::vector<INTPOINT>();
				}

				for(int i=p.size()-1;i!=0;i--)	// Reverse path
					p2.push_back(p[i]);
				p2.push_back(goal);

				return p2;
			}
			else
			{
				for(int i=0;i<8;i++)					// otherwise, check the neighbors of the
					if(best->neighbors[i] != NULL)	// best tile
						if(!considerUnits || best->neighbors[i]->m_pMapObject == NULL)
						{
							bool inList = false;		// Generate new G and F value
							float newG = best->g + 1.0f;
							float d = H(best->m_mappos, best->neighbors[i]->m_mappos);
							float newF = newG + H(best->neighbors[i]->m_mappos, goal) + best->neighbors[i]->m_cost * 5.0f * d;

							if(best->neighbors[i]->open || best->neighbors[i]->closed)
							{
								if(newF < best->neighbors[i]->f)	// If the new F value is lower
								{
									best->neighbors[i]->g = newG;	// update the values of this tile
									best->neighbors[i]->f = newF;
									best->neighbors[i]->m_pParent = best;								
								}
								inList = true;
							}

							if(!inList)			// If the neighbor tile isn't in the Open or Closed list
							{
								best->neighbors[i]->f = newF;		//Set the values
								best->neighbors[i]->g = newG;
								best->neighbors[i]->m_pParent = best;
								best->neighbors[i]->open = true;
								open.push_back(best->neighbors[i]);	//Add it to the open list	
							}
						}

				best->closed = true;		//The best tile has now been searched, add it to the Closed list
			}
		}

		return std::vector<INTPOINT>();		//No path found, return an empty path		
	}
	catch(...)
	{
		debug.Print("Error in TERRAIN::GetPath()");
		return std::vector<INTPOINT>();
	}
}

[dave_]

Thats an easy one.
operator [] returns a reference, erase takes an iterator. You need to do this: open.erase(open.begin()+bestPlace));

Iterators allow you to easily interchange container types, so perhaps you could use them instead of bestPlace and i

Next time I suggest you post the actual error message, and a bit less code. Perhaps try to reproduce it in a test application.