MapHelper Namespace Reference

Functions
TilePosition	spiralSearch (TilePosition startLocation, std::tr1::function< bool(TilePosition)> testFunction, int maxRadius=0)
std::set< TilePosition >	floodFill (TilePosition start, std::tr1::function< bool(TilePosition)> testFunction, std::set< TilePosition > targets=std::set< TilePosition >(), std::set< TilePosition > ignoreTiles=std::set< TilePosition >())
std::map< WalkPosition, int >	walkSearch (WalkPosition start, std::tr1::function< bool(WalkPosition)> testFunction, std::set< WalkPosition > targets=std::set< WalkPosition >(), std::set< WalkPosition > ignoreTiles=std::set< WalkPosition >())
bool	isAnyVisible (TilePosition location, BWAPI::UnitType type)
bool	isAllVisible (TilePosition location, BWAPI::UnitType type)
bool	isTileWalkable (TilePosition location)
bool	isTileWalkable (int x, int y)
bool	mapIs (std::string name)
int	getGroundDistance (Position start, Position end)

---

Function Documentation

std::set< TilePosition > MapHelper::floodFill	(	TilePosition	start,
		std::tr1::function< bool(TilePosition)>	testFunction,
		std::set< TilePosition >	targets = std::set<TilePosition>(),
		std::set< TilePosition >	ignoreTiles = std::set<TilePosition>()
	)

Definition at line 68 of file MapHelper.cpp.

References BWAPI::TilePosition::isValid(), BWAPI::TilePosition::x(), and BWAPI::TilePosition::y().

Referenced by BuildingPlacerClass::isLocationNonBlocking().

{
        bool noTargets = targets.empty();

        std::set<TilePosition> remainingTiles;
        remainingTiles.insert(start);

        while(!remainingTiles.empty())
        {
                if(!noTargets && targets.empty())
                        return targets;

                TilePosition tile = *remainingTiles.begin();

                ignoreTiles.insert(tile);
                remainingTiles.erase(tile);

                if(!tile.isValid())
                        continue;

                if(!testFunction(tile))
                        continue;

                if(noTargets)
                        targets.insert(tile);
                else
                        targets.erase(tile);

                if(ignoreTiles.count(TilePosition(tile.x() + 1, tile.y())) == 0)
                        remainingTiles.insert(TilePosition(tile.x() + 1, tile.y()));
                if(ignoreTiles.count(TilePosition(tile.x() - 1, tile.y())) == 0)
                        remainingTiles.insert(TilePosition(tile.x() - 1, tile.y()));
                if(ignoreTiles.count(TilePosition(tile.x(), tile.y() + 1)) == 0)
                        remainingTiles.insert(TilePosition(tile.x(), tile.y() + 1));
                if(ignoreTiles.count(TilePosition(tile.x(), tile.y() - 1)) == 0)
                        remainingTiles.insert(TilePosition(tile.x(), tile.y() - 1));
        }

        return targets;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MapHelper::getGroundDistance	(	Position	start,
		Position	end
	)

Definition at line 225 of file MapHelper.cpp.

References BWAPI::Broodwar, BWAPI::Position::getApproxDistance(), and Singleton< T >::Instance().

Referenced by ScoutManagerClass::onBegin(), and BuildingPlacerClass::rememberBestExpandLocation().

{
        if(!BWAPI::Broodwar->hasPath(start, end))
                return std::numeric_limits<int>::max();

        int groundDistance = PathFinder::Instance().CreateCheapWalkPath(start, end).getLength();
        int linearDistance = start.getApproxDistance(end);

        if(groundDistance < linearDistance)
                return linearDistance;

        return groundDistance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool MapHelper::isAllVisible	(	TilePosition	location,
		BWAPI::UnitType	type
	)

Definition at line 179 of file MapHelper.cpp.

References BWAPI::Broodwar, BWAPI::UnitType::tileHeight(), BWAPI::UnitType::tileWidth(), BWAPI::TilePosition::x(), and BWAPI::TilePosition::y().

Referenced by UnitClass::build().

{
        for(int x = location.x(); x < location.x() + type.tileWidth(); ++x)
        {
                for(int y = location.y(); y < location.y() + type.tileHeight(); ++y)
                {
                        if(!BWAPI::Broodwar->isVisible(x, y))
                                return false;
                }
        }

        return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool MapHelper::isAnyVisible	(	TilePosition	location,
		BWAPI::UnitType	type
	)

Definition at line 165 of file MapHelper.cpp.

References BWAPI::Broodwar, BWAPI::UnitType::tileHeight(), BWAPI::UnitType::tileWidth(), BWAPI::TilePosition::x(), and BWAPI::TilePosition::y().

Referenced by UnitClass::accessibility(), ScoutDataClass::checkPositions(), and WorkerScoutTask::preUpdate().

{
        for(int x = location.x(); x < location.x() + type.tileWidth(); ++x)
        {
                for(int y = location.y(); y < location.y() + type.tileHeight(); ++y)
                {
                        if(BWAPI::Broodwar->isVisible(x, y))
                                return true;
                }
        }

        return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool MapHelper::isTileWalkable

(

TilePosition

location

)

Definition at line 193 of file MapHelper.cpp.

References BWAPI::TilePosition::x(), and BWAPI::TilePosition::y().

Referenced by BuildTilePath::isStillValid(), BuildingPlacerClass::isTileWalkable(), and FleeTileTest::operator()().

{
        return isTileWalkable(location.x(), location.y());
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool MapHelper::isTileWalkable	(	int	x,
		int	y
	)

Definition at line 198 of file MapHelper.cpp.

References BWAPI::Broodwar.

{
        for(int nx = x * 4; nx < x * 4 + 4; ++nx)
        {
                for(int ny = y * 4; ny < y * 4 + 4; ++ny)
                {
                        if(!BWAPI::Broodwar->isWalkable(nx, ny))
                                return false;
                }
        }

        return true;
}

bool MapHelper::mapIs

(

std::string

name

)

Definition at line 212 of file MapHelper.cpp.

References BWAPI::Broodwar, BWAPI::Game::mapFileName(), and BWAPI::Game::mapName().

Referenced by WallTrackerClass::onBegin(), and Condition::passesValue().

{
        std::string mapName = BWAPI::Broodwar->mapName();
        std::transform(mapName.begin(), mapName.end(), mapName.begin(), tolower);

        std::string mapFileName = BWAPI::Broodwar->mapFileName();
        std::transform(mapFileName.begin(), mapFileName.end(), mapFileName.begin(), tolower);

        std::transform(name.begin(), name.end(), name.begin(), tolower);

        return std::tr1::regex_search(mapName.begin(), mapName.end(), std::tr1::regex(name)) || std::tr1::regex_search(mapFileName.begin(), mapFileName.end(), std::tr1::regex(name));
}

Here is the call graph for this function:

Here is the caller graph for this function:

TilePosition MapHelper::spiralSearch	(	TilePosition	startLocation,
		std::tr1::function< bool(TilePosition)>	testFunction,
		int	maxRadius = 0
	)

Definition at line 10 of file MapHelper.cpp.

References BWAPI::Broodwar, BWAPI::TilePositions::None, BWAPI::TilePosition::x(), and BWAPI::TilePosition::y().

Referenced by TerrainAnaysisClass::createBases(), TerrainAnaysisClass::finaliseConnectivity(), and BuildingPlacerClass::getBuildLocation().

{
        int x = startLocation.x();
        int y = startLocation.y();

        int length = 1;
        int j      = 0;
        bool first = true;
        int dx     = 0;
        int dy     = 1;

        if(maxRadius == 0)
                maxRadius = std::max(BWAPI::Broodwar->mapWidth(), BWAPI::Broodwar->mapHeight());

        while(length < maxRadius)
        {
                if(x >= 0 && x < BWAPI::Broodwar->mapWidth() && y >= 0 && y < BWAPI::Broodwar->mapHeight())
                {
                        TilePosition location(x, y);
                        if(testFunction(location))
                                return location;
                }

                x = x + dx;
                y = y + dy;

                //count how many steps we take in this direction
                ++j;
                if(j == length) //if we've reached the end, its time to turn
                {
                        //reset step counter
                        j = 0;

                        //Spiral out. Keep going.
                        if(!first)
                                ++length; //increment step counter if needed

                        //first=true for every other turn so we spiral out at the right rate
                        first = !first;

                        //turn counter clockwise 90 degrees:
                        if (dx == 0)
                        {
                                dx = dy;
                                dy = 0;
                        }
                        else
                        {
                                dy = -dx;
                                dx = 0;
                        }
                }
                //Spiral out. Keep going.
        }

        return BWAPI::TilePositions::None;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::map< WalkPosition, int > MapHelper::walkSearch	(	WalkPosition	start,
		std::tr1::function< bool(WalkPosition)>	testFunction,
		std::set< WalkPosition >	targets = std::set<WalkPosition>(),
		std::set< WalkPosition >	ignoreTiles = std::set<WalkPosition>()
	)

Definition at line 109 of file MapHelper.cpp.

References BWAPI::Broodwar, Heap< Key, Val >::empty(), BWAPI::Game::mapHeight(), BWAPI::Game::mapWidth(), Heap< Key, Val >::pop(), Heap< Key, Val >::push(), Heap< Key, Val >::set(), Heap< Key, Val >::top(), WalkPosition::x, and WalkPosition::y.

{
        std::map<WalkPosition, int> returnDistances;

        int mapWidth = BWAPI::Broodwar->mapWidth() * 4;
        int mapHeight = BWAPI::Broodwar->mapHeight() * 4;

        Heap<WalkPosition, int> openTiles(true);
        std::map<WalkPosition, int> gmap;
        std::set<WalkPosition> closedTiles;

        openTiles.push(std::make_pair(start, 0));
        gmap[start] = 0;

        int maxhvalue = std::max(mapHeight, mapWidth);

        while(!openTiles.empty())
        {
                WalkPosition p = openTiles.top().first;

                int fvalue = openTiles.top().second;
                int gvalue = gmap[p];

                openTiles.pop();
                closedTiles.insert(p);
                returnDistances[p] = gvalue;

                for(int i = 0; i < 4; ++i)
                {
                        int x = i == 0 ? 1 : i == 1 ? -1 : 0;
                        int y = i == 2 ? 1 : i == 3 ? -1 : 0;
                        WalkPosition tile(p.x + x, p.y + y);

                        if(tile.x < 0 || tile.y < 0 || tile.x >= mapWidth || tile.y >= mapHeight)
                                continue;

                        if(closedTiles.find(tile) != closedTiles.end())
                                continue;

                        if(!testFunction(tile))
                                continue;

                        int g = gvalue + 1;

                        int f = g;
                        if(gmap.find(tile) == gmap.end() || gmap[tile] > g)
                        {
                                gmap[tile] = g;
                                openTiles.set(tile, f);
                        }
                }
        }

        return returnDistances;
}

Here is the call graph for this function: