示例#1
0
BWAPI::TilePosition BuildingPlacer::getBuildLocationNear(const Building & b, int buildDist, bool horizontalOnly) const
{
    SparCraft::Timer t;
    t.start();

    // get the precomputed vector of tile positions which are sorted closes to this location
    const std::vector<BWAPI::TilePosition> & closestToBuilding = MapTools::Instance().getClosestTilesTo(BWAPI::Position(b.desiredPosition));

    double ms1 = t.getElapsedTimeInMilliSec();

    // special easy case of having no pylons
    int numPylons = BWAPI::Broodwar->self()->completedUnitCount(BWAPI::UnitTypes::Protoss_Pylon);
    if (b.type.requiresPsi() && numPylons == 0)
    {
        return BWAPI::TilePositions::None;
    }

    // iterate through the list until we've found a suitable location
    for (size_t i(0); i < closestToBuilding.size(); ++i)
    {
        if (canBuildHereWithSpace(closestToBuilding[i], b, buildDist, horizontalOnly))
        {
            double ms = t.getElapsedTimeInMilliSec();
            //BWAPI::Broodwar->printf("Building Placer Took %d iterations, lasting %lf ms @ %lf iterations/ms, %lf setup ms", i, ms, (i / ms), ms1);

            return closestToBuilding[i];
        }
    }

    double ms = t.getElapsedTimeInMilliSec();
    //BWAPI::Broodwar->printf("Building Placer Took %lf ms", ms);

	return  BWAPI::TilePositions::None;
}
示例#2
0
BWAPI::TilePosition BuildingPlacer::getBuildLocationNear(const Building & b, int buildDist, bool horizontalOnly) const
{
    SparCraft::Timer t;
	t.start();

	BWTA::BaseLocation *home = findHome();
	BWAPI::TilePosition chokeTile = findChoke(home);

	int homex = home->getTilePosition().x;
	int homey = home->getTilePosition().y;
	int midx = (chokeTile.x + homex) / 2;
	int midy = (chokeTile.y + homey) / 2;
	static int px = midx;
	static int py = midy;

	// 1 if choke farther right, -1 if farther left
	int ix = chokeTile.x > midx ? 1 : -1;
	// 1 if choke farther south, -1 if farther north
	int iy = chokeTile.y < midy ? -1 : 1;

    // get the precomputed vector of tile positions which are sorted closes to this location
    const std::vector<BWAPI::TilePosition> & closestToBuilding = MapTools::Instance().getClosestTilesTo(BWAPI::Position(b.desiredPosition));

    double ms1 = t.getElapsedTimeInMilliSec();

    // special easy case of having no pylons
    int numPylons = BWAPI::Broodwar->self()->completedUnitCount(BWAPI::UnitTypes::Protoss_Pylon);
	int numGate = BWAPI::Broodwar->self()->completedUnitCount(BWAPI::UnitTypes::Protoss_Gateway);
	int numCan = BWAPI::Broodwar->self()->completedUnitCount(BWAPI::UnitTypes::Protoss_Photon_Cannon);

    if (b.type.requiresPsi() && numPylons == 0)
    {
        return BWAPI::TilePositions::None;
    }

	if (BWAPI::Broodwar->mapName().compare(1,9,"Andromeda")) {
		if (b.type == BWAPI::UnitTypes::Protoss_Pylon && numPylons == 0) {
			BWAPI::TilePosition pos = drawPylon(midx, midy, ix, iy, b);
			if (pos != BWAPI::TilePositions::None) {
				px = pos.x;
				py = pos.y;
				return pos;
			}

		}

		else if (b.type == BWAPI::UnitTypes::Protoss_Forge) {
			BWAPI::TilePosition pos = drawForge(midx, midy, ix, iy, b);
			if (pos != BWAPI::TilePositions::None) {
				return pos;
			}
		}

		else if (b.type == BWAPI::UnitTypes::Protoss_Photon_Cannon) {
			BWAPI::TilePosition pos = drawProtonCannon(homex, homey, ix, iy, b);
			if (pos != BWAPI::TilePositions::None) {
				return pos;
			}
		}

		//else if (b.type == BWAPI::UnitTypes::Protoss_Gateway && numGate == 0) {
		//	return drawGateway(homex, homey, ix, iy, b);
		//}

	}

	// iterate through the list until we've found a suitable location
	for (size_t i(0); i < closestToBuilding.size(); ++i)
	{
		if (b.type == BWAPI::UnitTypes::Protoss_Gateway && numGate == 0) {
			buildDist = 0;
		}
		if (canBuildHereWithSpace(closestToBuilding[i], b, buildDist, horizontalOnly))
		{
			double ms = t.getElapsedTimeInMilliSec();
			//BWAPI::Broodwar->printf("Building Placer Took %d iterations, lasting %lf ms @ %lf iterations/ms, %lf setup ms", i, ms, (i / ms), ms1);

			return closestToBuilding[i];
		}
	}

	double ms = t.getElapsedTimeInMilliSec();
	//BWAPI::Broodwar->printf("Building Placer Took %lf ms", ms);
	

	return  BWAPI::TilePositions::None;
}
BWAPI::TilePosition BuildingPlacer::getBuildLocationNear(const Building & b, int buildDist, bool inRegionPriority, bool horizontalOnly) const
{
	//returns a valid build location near the specified tile position.
	//searches outward in a spiral.
	int x      = b.desiredPosition.x;
	int y      = b.desiredPosition.y;
	int length = 1;
	int j      = 0;
	bool first = true;
	int dx     = 0;
	int dy     = 1;

    SparCraft::Timer t;
    t.start();
    int iter = 0;
    int buildingPlacerTimeLimit = 2000;

	while (length < BWAPI::Broodwar->mapWidth()) //We'll ride the spiral to the end
	{
        if (t.getElapsedTimeInMilliSec() > buildingPlacerTimeLimit)
        {
            if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
            {
                BWAPI::Broodwar->printf("Building Placer Timed Out %d ms", buildingPlacerTimeLimit);
            }

            return BWAPI::TilePositions::None;
        }

		//if we can build here, return this tile position
		if (x >= 0 && x < BWAPI::Broodwar->mapWidth() && y >= 0 && y < BWAPI::Broodwar->mapHeight())
		{
            iter++;
            
			// can we build this building at this location
			bool canBuild					= this->canBuildHereWithSpace(BWAPI::TilePosition(x, y), b, buildDist, horizontalOnly);

			// my starting region
			BWTA::Region * myRegion			= BWTA::getRegion(BWTA::getStartLocation(BWAPI::Broodwar->self())->getTilePosition()); 

			// the region the build tile is in
			BWTA::Region * tileRegion		= BWTA::getRegion(BWAPI::TilePosition(x,y));

			// is the proposed tile in our region?
			bool tileInRegion				= (tileRegion == myRegion);

			// if this location has priority to be built within our own region
			if (inRegionPriority)
			{
				// if the tile is in region and we can build it there
				if (tileInRegion && canBuild)
				{
                    if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
                    {
                        //BWAPI::Broodwar->printf("Building Placer Took %lf ms", t.getElapsedTimeInMilliSec());
                    }

					// return that position
					return BWAPI::TilePosition(x, y);
				}
			}
			// otherwise priority is not set for this building
			else
			{
				if (canBuild)
				{
                    if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
                    {
                        //BWAPI::Broodwar->printf("Building Placer Took %lf ms", t.getElapsedTimeInMilliSec());
                    }

			        return BWAPI::TilePosition(x, y);
				}
			}
		}

		//otherwise, move to another position
		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;
}
//ctx add
BWAPI::TilePosition BuildingPlacer::getBuildLocationFarFromChokePoint(const Building & b, int buildDist, bool horizontalOnly, bool flag) const
{
	SparCraft::Timer t;
	t.start();

	BWAPI::TilePosition startTitlePos = BWAPI::Broodwar->self()->getStartLocation();
	BWTA::Chokepoint *chokePoint = BWTA::getNearestChokepoint(startTitlePos);
	BWAPI::Position chokeCenterPosition = chokePoint->getCenter();
	BWTA::Region *baseRegion = BWTA::getRegion(BWAPI::Broodwar->self()->getStartLocation());
	BWTA::Polygon basePolygon = baseRegion->getPolygon();
	BWAPI::Position farPosition =  BWAPI::Position(0, 0);
	BWAPI::TilePosition resultPosition = BWAPI::TilePosition(0, 0);
	double dis = 0.0;

	

	for (int i = 0; i < (int)basePolygon.size(); i++) {
		BWAPI::Position point = basePolygon[i];
		double ms1 = t.getElapsedTimeInMilliSec();
		if (point.getDistance(chokeCenterPosition) > dis) {
			dis = point.getDistance(chokeCenterPosition);
			farPosition = point;
		}
	}

	const std::vector<BWAPI::TilePosition> & closestToBuilding = MapTools::Instance().getClosestTilesTo(BWAPI::Position(b.desiredPosition));

	//get best solution
	dis = farPosition.getDistance(BWAPI::Position(startTitlePos));
	
	if (flag == true) {
		for (size_t i = 0; i < closestToBuilding.size(); ++i)
		{
			double ms1 = t.getElapsedTimeInMilliSec();
			if (canBuildHereWithSpace(closestToBuilding[i], b, buildDist, horizontalOnly) && dis > farPosition.getDistance(BWAPI::Position(closestToBuilding[i])))
			{
				resultPosition = closestToBuilding[i];
				break;
				//return closestToBuilding[i];
			}
		}
	}
	else {
		for (size_t i = 0; i < closestToBuilding.size(); ++i)
		{
			double ms1 = t.getElapsedTimeInMilliSec();
			if (canBuildHereWithSpace(closestToBuilding[i], b, buildDist, horizontalOnly) && dis < farPosition.getDistance(BWAPI::Position(closestToBuilding[i])))
			{
				resultPosition = closestToBuilding[i];
				break;
				//return closestToBuilding[i];
			}
		}
	}
	
	if (!basePolygon.isInside(BWAPI::Position(resultPosition))) {
		resultPosition = getBuildLocationNear(b, buildDist, horizontalOnly);
	}

	return resultPosition;
}
示例#5
0
BWAPI::TilePosition BuildingPlacer::getBuildLocationNear(const Building & b, int buildDist, int timeLimitMS, bool inRegionPriority, bool horizontalOnly) const
{
	struct SearchState{
		int _length;
		int _j;
		bool _first;
		int _dx;
		int _dy;
		int _x;
		int _y;
		bool _timeOut;
		BWAPI::TilePosition _candidatePos;
		SearchState(int length, int j, bool first, int dx, int dy, int x, int y, bool timeOut = false, BWAPI::TilePosition candidatePos = BWAPI::TilePositions::None) :
			_length(length), _j(j), _first(first), _dx(dx), _dy(dy), _x(x), _y(y), _timeOut(timeOut), _candidatePos(candidatePos)
		{}
		SearchState() :_timeOut(false), _candidatePos(BWAPI::TilePositions::None)
		{}
	};
	struct SearchParams{
		Building _b;
		int _buildDist;
		bool _inRegionPriority;
		bool _horizontalOnly;
		SearchParams(const Building & b, int buildDist, bool inRegionPriority, bool horizontalOnly):
			_b(b), _buildDist(buildDist), _inRegionPriority(inRegionPriority), _horizontalOnly(horizontalOnly)
		{}
		SearchParams()
		{}
		bool operator==(const SearchParams& other)
		{
			return _b.type == other._b.type &&
				_b.desiredPosition == other._b.desiredPosition&&
				_b.builderUnit == other._b.builderUnit&&
				_buildDist == other._buildDist&&
				_inRegionPriority == other._inRegionPriority&&
				_horizontalOnly == other._horizontalOnly;
		}
	};
	if (timeLimitMS <= 0)
	{
		throw std::runtime_error("Building Placer not given any time: "+timeLimitMS);
	}
	static SearchState lastState;
	static SearchParams lastParams;
	SearchState state(1, 0, true, 0, 1, b.desiredPosition.x, b.desiredPosition.y);
	SearchParams params(b, buildDist, inRegionPriority, horizontalOnly);
	if (lastState._timeOut && lastParams == params)
	{
		state = lastState;

		//BWAPI::Broodwar->printf("Building Placer for building %s resuming... %d",b.type.getName().c_str(),state._length);
		//Logger::LogAppendToFile(UAB_LOGFILE, "Building Placer for building %s resuming... %d\n", b.type.getName().c_str(), state._length);
	}

    SparCraft::Timer t;
    t.start();
	// my starting region
	//BWTA::Region * myRegion = BWTA::getRegion(BWTA::getStartLocation(BWAPI::Broodwar->self())->getTilePosition());
	BWTA::Region * myRegion = BWTA::getRegion(b.desiredPosition);
	
	//get max spiral size
	int maxDist = 0;
	for (auto point : myRegion->getPolygon())
	{
		int radius = std::ceil((BWAPI::TilePosition(point) - b.desiredPosition).getLength());
		if (radius > maxDist)
		{
			maxDist = radius;
		}
	}
	while (state._length < maxDist || (state._length <BWAPI::Broodwar->mapWidth() && state._candidatePos == BWAPI::TilePositions::None)) //We'll ride the spiral to the end
	{
		if (t.getElapsedTimeInMilliSec() > timeLimitMS)
        {
            if (Options::Debug::DRAW_UALBERTABOT_DEBUG && !state._timeOut)
            {
				//BWAPI::Broodwar->printf("Building Placer Timed Out at %d ms on building %s", timeLimitMS, b.type.getName().c_str());
				//Logger::LogAppendToFile(UAB_LOGFILE, "Building Placer Timed Out at %d ms on building %s\n", timeLimitMS, b.type.getName().c_str());
            }
			lastState = state;
			lastState._timeOut = true; 
			lastParams = params;
			throw std::runtime_error("Building Placer Timed Out. State saved for resuming later.");
        }

		//if we can build here, return this tile position
		if (state._x >= 0 && state._x < BWAPI::Broodwar->mapWidth() && state._y >= 0 && state._y < BWAPI::Broodwar->mapHeight())
		{
            
			// can we build this building at this location
			bool canBuild = this->canBuildHereWithSpace(BWAPI::TilePosition(state._x, state._y), b, buildDist, horizontalOnly);

			if (canBuild)
			{
				// if this location has priority to be built within our own region
				if (inRegionPriority)
				{
					// the region the build tile is in
					BWTA::Region * tileRegion = BWTA::getRegion(BWAPI::TilePosition(state._x, state._y));

					// is the proposed tile in our region?
					bool tileInRegion = (tileRegion == myRegion);

					// if the tile is in region and we can build it there
					if (tileInRegion)
					{
						if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
						{
							//BWAPI::Broodwar->printf("Building Placer Took %lf ms", t.getElapsedTimeInMilliSec());
							//BWAPI::Broodwar->printf("Building position found in region");
							//Logger::LogAppendToFile(UAB_LOGFILE, "Building position found in region\n");
						}

						// return that position
						lastState._timeOut = false;

						return BWAPI::TilePosition(state._x, state._y);
					}
					else if (state._candidatePos==BWAPI::TilePositions::None)//save an out of region position as candidate
					{
						if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
						{
							//BWAPI::Broodwar->printf("Saving position found not in region");
							//Logger::LogAppendToFile(UAB_LOGFILE, "Saving position found not in region\n");
						}
						state._candidatePos = BWAPI::TilePosition(state._x, state._y);
					}
				}
				// otherwise priority is not set for this building
				else
				{
					if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
					{
						//BWAPI::Broodwar->printf("Building Placer Took %lf ms", t.getElapsedTimeInMilliSec());
						//BWAPI::Broodwar->printf("Building position found not in region");
						//Logger::LogAppendToFile(UAB_LOGFILE, "Building position found not in region\n");
					}
					lastState._timeOut = false;
					return BWAPI::TilePosition(state._x, state._y);
				}
			}
		}

		//otherwise, move to another position
		state._x = state._x + state._dx;
		state._y = state._y + state._dy;

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

			//Spiral out. Keep going.
			if (!state._first)
			{
				state._length++; //increment step counter if needed
			}

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

			//turn counter clockwise 90 degrees:
			if (state._dx == 0)
			{
				state._dx = state._dy;
				state._dy = 0;
			}
			else
			{
				state._dy = -state._dx;
				state._dx = 0;
			}
		}
		//Spiral out. Keep going.
	}
	lastState._timeOut = false;
	if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
	{
		//BWAPI::Broodwar->printf("Rode spiral out. Building %s position: %d %d", b.type.getName().c_str(), state._candidatePos.x, state._candidatePos.y);
		//Logger::LogAppendToFile(UAB_LOGFILE, "Rode spiral out. Building %s position: %d %d\n", b.type.getName().c_str(),  state._candidatePos.x, state._candidatePos.y);
	}
	return  state._candidatePos;
}
void ProductionManager::manageBuildOrderQueue(int timeLimitMS)
{
	// if there is nothing in the queue, oh well
	if (queue.isEmpty()) 
	{
		return;
	}
	SparCraft::Timer t;
	t.start();
	// the current item to be used
	BuildOrderItem & currentItem = queue.getHighestPriorityItem();

	// while there is still something left in the queue
	while (!queue.isEmpty()) 
	{
		// this is the unit which can produce the currentItem
        BWAPI::UnitInterface* producer = getProducer(currentItem.metaType);

		// check to see if we can make it right now
		bool canMake = canMakeNow(producer, currentItem.metaType);

		// if we try to build too many refineries manually remove it
		if (currentItem.metaType.isRefinery() && (BWAPI::Broodwar->self()->allUnitCount(BWAPI::Broodwar->self()->getRace().getRefinery() >= 3)))
		{
			queue.removeCurrentHighestPriorityItem();
			break;
		}

		// if the next item in the list is a building and we can't yet make it
        if (currentItem.metaType.isBuilding() && !(producer && canMake) && !currentItem.metaType.unitType.isAddon())
		{
			// construct a temporary building object
			Building b(currentItem.metaType.unitType, BWAPI::Broodwar->self()->getStartLocation());

			// set the producer as the closest worker, but do not set its job yet
			producer = WorkerManager::Instance().getBuilder(b, false);

			// predict the worker movement to that building location
			predictWorkerMovement(b, timeLimitMS - t.getElapsedTimeInMilliSec());
		}

		// if we can make the current item
		if (producer && canMake) 
		{
			// create it
			createMetaType(producer, currentItem.metaType);
			assignedWorkerForThisBuilding = false;
			haveLocationForThisBuilding = false;

			// and remove it from the queue
			queue.removeCurrentHighestPriorityItem();

			// don't actually loop around in here
			break;
		}
		// otherwise, if we can skip the current item
		else if (queue.canSkipItem())
		{
			// skip it
			queue.skipItem();

			// and get the next one
			currentItem = queue.getNextHighestPriorityItem();				
		}
		else 
		{
			// so break out
			break;
		}
	}
}