The BuildingPlacer is the way ProtoBot is able to utilize the BWEB blocks generated to place down buildings. This allows for a single class to be able to find places to build and returns information about the placement info if anything goes wrong.

When the BuildingPlacer is first created the Blocks that generated are stored into lists that ProtoBot is able to use based on the building type of a ResourceRequest. This allows the BuildingPlacer to find a suitable generated locations without having to loop through ever single block on the map.
More blocks are added based on the areas the ProtoBot controls. To prevent the risk of ProtoBot building in enemy territory, ProtoBot will only build in the areas that ProtoBot currently 'controls'. When a nexus is created this expands ProtoBot's influence and makes more blocks avalible if any are generated in that location. More...

#include <BuildingPlacer.h>

Public Member Functions
	BuildingPlacer (BuildManager *buildReference)
PlacementInfo	getPositionToBuild (BWAPI::UnitType, const BWEM::Base *)
bool	alreadyUsingTiles (BWAPI::TilePosition, int, int, bool assimilator)
	Checks if a location to place a building already has another unit ontop of it (will only consider buildings not combat units).
bool	checkPower (BWAPI::TilePosition, BWAPI::UnitType)
BWAPI::TilePosition	checkBuildingBlocks ()
	Finda an available Block that has no power in the power tile location.
BWAPI::TilePosition	checkPowerReserveBlocks ()
	Checks Blocks of size 2x2 (tiles) that can be used in order to place down pylons for supply.
BWAPI::TilePosition	findAvailableExpansion ()
	Checks BWEM expansion locations for possible place to construct resource depot.
BWAPI::TilePosition	findAvailableGyser (const BWEM::Base *)
	Checks a base to place down an assimlator ontop of a vespene gyser.
BWAPI::TilePosition	findAvaliblePlacement (BWAPI::UnitType)
	Standard call for buildings to find a location to be placed other than refineries, resource depots, and supply units.
int	numberOfFullPoweredLargePlacements ()
void	drawPoweredTiles ()
void	onStart ()
	Update Block information to reflect generated BWEB Blocks and reset values to reflect a beggining game state.
void	onUnitCreate (BWAPI::Unit)
	Updates BWEM to reflect the current state of StarCraft game.
void	onUnitComplete (BWAPI::Unit)
	Updates BWEM to reflect the current state of StarCraft game.
void	onUnitDestroy (BWAPI::Unit)
	Updates BWEM to reflect the current state of StarCraft game.
void	onUnitMorph (BWAPI::Unit)
	Updates BWEM to reflect the current state of StarCraft game.
void	onUnitDiscover (BWAPI::Unit)
	Updates BWEM to reflect the current state of StarCraft game.

Public Attributes
int	Powered_LargePlacements = 0
int	Powered_MediumPlacements = 0
int	Used_LargeBuildingPlacements
int	Used_MediumBuildingPlacements
BuildManager *	buildReference

Private Attributes
std::map< BWAPI::TilePosition, BlockData >	Block_Information
std::unordered_set< const BWEM::Area * >	AreasOccupied
std::vector< BWEB::Block >	ProtoBot_Blocks
std::unordered_map< const BWEM::Area *, std::vector< BWEB::Block > >	Area_Blocks
int	mapWidth = 0
int	mapHeight = 0
int	nexusCount = 0
bool	debug = false

Detailed Description

The BuildingPlacer is the way ProtoBot is able to utilize the BWEB blocks generated to place down buildings. This allows for a single class to be able to find places to build and returns information about the placement info if anything goes wrong.

When the BuildingPlacer is first created the Blocks that generated are stored into lists that ProtoBot is able to use based on the building type of a ResourceRequest. This allows the BuildingPlacer to find a suitable generated locations without having to loop through ever single block on the map.
More blocks are added based on the areas the ProtoBot controls. To prevent the risk of ProtoBot building in enemy territory, ProtoBot will only build in the areas that ProtoBot currently 'controls'. When a nexus is created this expands ProtoBot's influence and makes more blocks avalible if any are generated in that location.

Definition at line 69 of file BuildingPlacer.h.

Constructor & Destructor Documentation

◆ BuildingPlacer()

BuildingPlacer::BuildingPlacer ( BuildManager * buildReference )

Definition at line 5 of file BuildingPlacer.cpp.

                                                           : buildReference(buildReference)
{
 
}

Member Function Documentation

◆ alreadyUsingTiles()

bool BuildingPlacer::alreadyUsingTiles	(	BWAPI::TilePosition	position,
		int	width,
		int	height,
		bool	assimilator = false )

Checks if a location to place a building already has another unit ontop of it (will only consider buildings not combat units).

Parameters

Top Left Tile Position to place building
Width
Height
isAssimilator

Returns: TilePosition to build

Definition at line 11 of file BuildingPlacer.cpp.

{
    const BWAPI::UnitType typeFound = BWEB::Map::isUsed(position, width, height);
 
    if (!assimilator)
    {
        if (BWAPI::UnitTypes::None != typeFound) return true;
    }
    else
    {
        if (typeFound.isRefinery())
        {
            return true;
        }
    }
 
    return false;
}

◆ checkBuildingBlocks()

BWAPI::TilePosition BuildingPlacer::checkBuildingBlocks ( )

Finda an available Block that has no power in the power tile location.

Returns: TilePosition to build

Definition at line 54 of file BuildingPlacer.cpp.

{
    //Power up blocks that are not power reserve blocks.
    double distanceToPowerBlock = INT_MAX;
    BWAPI::TilePosition powerTilePosition = BWAPI::TilePositions::Invalid;
    double finalDistance;
 
    for (BWEB::Block block : ProtoBot_Blocks)
    {
        BlockData data = Block_Information[block.getTilePosition()];
 
        if (data.Blocksize != BlockData::SUPPLY && data.Power_State != BlockData::FULLY_POWERED)
        {
            //Loop through all power tiles. Blocks can have more than 1 power tile.
            for (const BWAPI::TilePosition powerPlacements : data.PowerTiles)
            {
                if (BWEB::Map::isUsed(powerPlacements) != BWAPI::UnitTypes::None) continue;
 
                int distance = 0;
                int distanceToEnemy = 0;
                theMap.GetPath(BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation()), BWAPI::Position(powerPlacements), &distance);
                if (buildReference->commanderReference->enemy().main.has_value())
                    theMap.GetPath(BWAPI::Position(buildReference->commanderReference->enemy().main.value()), BWAPI::Position(block.getTilePosition()), &distanceToEnemy);
 
                if (distance == -1) continue;
 
                if (distanceToEnemy != 0 && buildReference->commanderReference->enemy().main.value())
                {
                    finalDistance = static_cast<double>(distance) / distanceToEnemy;
                }
                else
                {
                    finalDistance = static_cast<double>(distance);
                }
 
                if (finalDistance < distanceToPowerBlock)
                {
                    distanceToPowerBlock = finalDistance;
                    powerTilePosition = powerPlacements;
                }
            }
        }
    }
 
    return powerTilePosition;
}

◆ checkPower()

bool BuildingPlacer::checkPower	(	BWAPI::TilePosition	location,
		BWAPI::UnitType	buildingType )

Definition at line 31 of file BuildingPlacer.cpp.

{
    //const int x_location = location.x;
    //const int y_location = location.y;
 
    //float tilesPowered = 0.0;
 
    //for (int row = y_location; row < x_location + buildingType.tileHeight(); row++)
    //{
    //    for (int column = x_location; column < x_location + buildingType.tileWidth(); column++)
    //    {
    //        if (poweredTiles[row][column] >= 1) tilesPowered++;
    //    }
    //}
 
    //const float totalTiles = float(buildingType.tileWidth() * buildingType.tileHeight());
    //if (tilesPowered / totalTiles > .5) return true;
 
    return false;
}

◆ checkPowerReserveBlocks()

BWAPI::TilePosition BuildingPlacer::checkPowerReserveBlocks ( )

Checks Blocks of size 2x2 (tiles) that can be used in order to place down pylons for supply.

Returns: TilePosition to build

Definition at line 101 of file BuildingPlacer.cpp.

{
    double distanceToPowerBlock = INT_MAX;
    BWAPI::TilePosition supplyReservePosition = BWAPI::TilePositions::Invalid;
 
    std::vector<BWEB::Block> blocksToCheck;
    double finalDistance;
 
    blocksToCheck = ProtoBot_Blocks;
    if (nexusCount >= 3)
    {
        blocksToCheck = BWEB::Blocks::getBlocks();
    }
    else
    {
        blocksToCheck = ProtoBot_Blocks;
    }
 
    for (BWEB::Block block : blocksToCheck)
    {
        BlockData data = Block_Information[block.getTilePosition()];
 
        if (data.Blocksize == BlockData::SUPPLY && BWEB::Map::isUsed(block.getTilePosition()) == BWAPI::UnitTypes::None)
        {
            int distance = 0;
            int distanceToEnemy = 0;
            theMap.GetPath(BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation()), BWAPI::Position(block.getTilePosition()), &distance);
 
            if(buildReference->commanderReference->enemy().main.has_value())
                theMap.GetPath(BWAPI::Position(buildReference->commanderReference->enemy().main.value()), BWAPI::Position(block.getTilePosition()), &distanceToEnemy);
 
            if (distance == -1) continue;
 
            if (distanceToEnemy != 0 && buildReference->commanderReference->enemy().main.has_value())
            {
                finalDistance = static_cast<double>(distance) / distanceToEnemy;
            }
            else
            {
                finalDistance = static_cast<double>(distance);
            }
 
            if (finalDistance < distanceToPowerBlock)
            {
                distanceToPowerBlock = finalDistance;
                supplyReservePosition = block.getTilePosition();
            }
        }
    }
 
    return supplyReservePosition;
}

◆ drawPoweredTiles()

void BuildingPlacer::drawPoweredTiles ( )

Definition at line 298 of file BuildingPlacer.cpp.

{
    if (debug == false) return;
 
    /*for (int row = 0; row < poweredTiles.size(); row++)
    {
        for (int column = 0; column < poweredTiles[row].size(); column++)
        {
            if (poweredTiles[row][column] >= 1) BWAPI::Broodwar->drawCircleMap((column * 32) + 16, (row * 32) + 16, 5, BWAPI::Colors::Blue, true);
        }
    }*/
 
    std::vector<BWEB::Block> blocksToCheck = {};
    blocksToCheck = ProtoBot_Blocks;
 
    /*if (nexusCount >= 3)
    {
        blocksToCheck = BWEB::Blocks::getBlocks();
    }
    else
    {
        blocksToCheck = ProtoBot_Blocks;
    }*/
 
    for (BWEB::Block block : blocksToCheck)
    {
        block.draw();
 
        BlockData data = Block_Information[block.getTilePosition()];
 
        if (data.Blocksize != BlockData::SUPPLY)
        {
            for (const BWAPI::TilePosition PowerTilePosition : data.PowerTiles)
            {
                BWAPI::Broodwar->drawTextMap(BWAPI::Position((PowerTilePosition.x * 32) + 10, (PowerTilePosition.y * 32) + 16), "Power\nPlacement");
            }
        }
        else
        {
            BWAPI::Broodwar->drawTextMap(BWAPI::Position((block.getTilePosition().x * 32) + 16, (block.getTilePosition().y * 32) + 16), "Supply\nReserve");
        }
 
        if (data.Power_State == BlockData::FULLY_POWERED)
        {
            BWAPI::Broodwar->drawBoxMap(BWAPI::Position(block.getTilePosition()), BWAPI::Position((block.getTilePosition().x + block.width()) * 32 + 1, (block.getTilePosition().y + block.height()) * 32 + 1), BWAPI::Colors::Blue, false);
        }
    }
}

◆ findAvailableExpansion()

BWAPI::TilePosition BuildingPlacer::findAvailableExpansion ( )

Checks BWEM expansion locations for possible place to construct resource depot.

Returns: TilePosition to build

Definition at line 154 of file BuildingPlacer.cpp.

{
    const BWAPI::TilePosition ProtoBot_MainBase = BWAPI::Broodwar->self()->getStartLocation();
    const BWEM::Area* mainArea = theMap.GetArea(ProtoBot_MainBase);
 
    double distance = INT_MAX;
    double finalDistance;
    BWAPI::TilePosition closestDistance = BWAPI::TilePositions::Invalid;
    const BWAPI::UnitType type = BWAPI::UnitTypes::Protoss_Nexus;
 
    //This does not cover the case of a building being place on a tile but it should be good enough for now.
    for (const BWEM::Area& area : theMap.Areas())
    {
        for (const BWEM::Base& base : area.Bases())
        {
            if (base.Location() == BWAPI::Broodwar->self()->getStartLocation() || alreadyUsingTiles(base.Location(), type.tileWidth(), type.tileHeight())) continue;
 
            int distanceToNewBase = 0;
            int distanceToEnemy = 0;
            const BWEM::CPPath pathToExpansion = theMap.GetPath(BWAPI::Position(ProtoBot_MainBase), BWAPI::Position(base.Location()), &distanceToNewBase);
 
            if (buildReference->commanderReference->enemy().main.has_value())
                const BWEM::CPPath pathToEnemy = theMap.GetPath(BWAPI::Position(buildReference->commanderReference->enemy().main.value()), BWAPI::Position(base.Location()), &distanceToEnemy);
 
            if (distanceToNewBase == -1) continue;
 
            if (distanceToEnemy != 0 && buildReference->commanderReference->enemy().main.value())
            {
                finalDistance = static_cast<double>(distanceToNewBase) / distanceToEnemy;
            }
            else
            {
                finalDistance = static_cast<double>(distanceToNewBase);
            }
 
            if (finalDistance < distance)
            {
                distance = finalDistance;
                closestDistance = base.Location();
            }
        }
    }
 
    return closestDistance;
}

◆ findAvailableGyser()

BWAPI::TilePosition BuildingPlacer::findAvailableGyser ( const BWEM::Base * base )

Checks a base to place down an assimlator ontop of a vespene gyser.

Parameters

Base (expansion location)

Returns: TilePosition to build

Definition at line 200 of file BuildingPlacer.cpp.

{
    //std::cout << "Checking for open gysers\n";
    BWAPI::TilePosition availableGyser = BWAPI::TilePositions::Invalid;
 
    if (base != nullptr)
    {
        std::vector<BWEM::Geyser*> gysers = base->Geysers();
 
        for (const BWEM::Geyser* gyser : gysers)
        {
            const BWAPI::Unit unit = gyser->Unit();
 
            if (unit && unit->getType() == BWAPI::UnitTypes::Resource_Vespene_Geyser &&
                !alreadyUsingTiles(gyser->TopLeft(), unit->getType().tileWidth(), unit->getType().tileHeight(), true))
            {
                return gyser->TopLeft();
            }
        }
    }
    else
    {
        for (const BWEM::Area& area : theMap.Areas())
        {
            for (const BWEM::Base& base : area.Bases())
            {
                if (base.Geysers().size() == 0) continue;
 
                //Can change this to use the nexus reference
 
 
                BWAPI::Unitset units = BWAPI::Broodwar->getUnitsInRectangle(BWAPI::Position(base.Location()),
                    BWAPI::Position(32 * (base.Location().x + (BWAPI::UnitTypes::Protoss_Nexus.tileWidth())), 32 * (base.Location().y + (BWAPI::UnitTypes::Protoss_Nexus.tileHeight()))));
 
                bool nexusOnLocation = false;
 
                for (const BWAPI::Unit unit : units)
                {
                    if (unit->getType() == BWAPI::UnitTypes::Protoss_Nexus && unit->getPlayer() == BWAPI::Broodwar->self())
                    {
                        nexusOnLocation = true;
                        break;
                    }
                }
 
                //We do not own the base.
                if (nexusOnLocation == false) continue;
 
                std::vector<BWEM::Geyser*> gysers = base.Geysers();
 
                for (const BWEM::Geyser* gyser : gysers)
                {
                    const BWAPI::Unit unit = gyser->Unit();
 
                    if (unit && unit->getType() == BWAPI::UnitTypes::Resource_Vespene_Geyser &&
                        !alreadyUsingTiles(gyser->TopLeft(), unit->getType().tileWidth(), unit->getType().tileHeight(), true))
                    {
                        return gyser->TopLeft();
                    }
                }
            }
        }
    }
 
    return availableGyser;
}

◆ findAvaliblePlacement()

BWAPI::TilePosition BuildingPlacer::findAvaliblePlacement ( BWAPI::UnitType type )

Standard call for buildings to find a location to be placed other than refineries, resource depots, and supply units.

Parameters

UnitType (building type to be constructed)

Returns: TilePosition to build

Definition at line 268 of file BuildingPlacer.cpp.

{
    int distance = INT_MAX;
    BWAPI::TilePosition closestDistance = BWAPI::TilePositions::Invalid;
 
    for (BWEB::Block block : ProtoBot_Blocks)
    {
        BlockData& data = Block_Information[block.getTilePosition()];
 
        if (data.Power_State != BlockData::FULLY_POWERED) continue;
 
        std::set<BWAPI::TilePosition> placements = block.getPlacements(type);
 
        for (const BWAPI::TilePosition placement : placements)
        {
            const int distanceToPlacement = BWAPI::Broodwar->self()->getStartLocation().getApproxDistance(placement);
 
            if (BWAPI::Broodwar->canBuildHere(placement, type)
                && distanceToPlacement < distance
                && !alreadyUsingTiles(placement, type.tileWidth(), type.tileHeight()))
            {
                distance = distanceToPlacement;
                closestDistance = placement;
            }
        }
    }
 
    return closestDistance;
}

◆ getPositionToBuild()

PlacementInfo BuildingPlacer::getPositionToBuild	(	BWAPI::UnitType	type,
		const BWEM::Base *	base )

Definition at line 363 of file BuildingPlacer.cpp.

{
    PlacementInfo information;
 
    switch(type)
    {
        case BWAPI::UnitTypes::Protoss_Nexus:
        {
            const BWAPI::TilePosition pos = findAvailableExpansion();
 
            if (pos == BWAPI::TilePositions::Invalid)
            {
                information.flag = PlacementInfo::NO_EXPANSIONS;
            }
            else
            {
                information.topLeft = pos;
                information.flag = PlacementInfo::SUCCESS;
                information.position = BWAPI::Position(pos);
            }
        }
        break;
        case BWAPI::UnitTypes::Protoss_Assimilator:
        {
            const BWAPI::TilePosition pos = findAvailableGyser(base);
 
            if (pos == BWAPI::TilePositions::Invalid)
            {
                information.flag = PlacementInfo::NO_GYSERS;
            }
            else
            {
                information.topLeft = pos;
                information.flag = PlacementInfo::SUCCESS;
                information.position = BWAPI::Position(pos);
            }
        }
        break;
        case BWAPI::UnitTypes::Protoss_Pylon:
        {
            BWAPI::TilePosition powerTilePosition = checkBuildingBlocks();
 
            if (powerTilePosition == BWAPI::TilePositions::Invalid)
            {
                powerTilePosition = checkPowerReserveBlocks();
 
                if (powerTilePosition == BWAPI::TilePositions::Invalid)
                {
                    information.flag = PlacementInfo::NO_BLOCKS;
                }
                else
                {
                    information.topLeft = powerTilePosition;
                    information.position = BWAPI::Position(powerTilePosition);
                    information.flag = PlacementInfo::SUCCESS;
                }
            }
            else
            {
                information.topLeft = powerTilePosition;
                information.position = BWAPI::Position(powerTilePosition);
                information.flag = PlacementInfo::SUCCESS;
            }
        }
        break;
        default:
        {
            const BWAPI::TilePosition pos = findAvaliblePlacement(type);
 
            if (pos == BWAPI::TilePositions::Invalid)
            {
                information.flag = PlacementInfo::NO_PLACEMENTS;
 
            }
            else
            {
                information.topLeft = pos;
                information.flag = PlacementInfo::SUCCESS;
                information.position = BWAPI::Position(pos);
            }
        }
        break;
    }
 
    return information;
}

◆ numberOfFullPoweredLargePlacements()

int BuildingPlacer::numberOfFullPoweredLargePlacements ( )

Definition at line 347 of file BuildingPlacer.cpp.

{
    int poweredLargePlacements = 0;
 
    for (BWEB::Block block : ProtoBot_Blocks)
    {
        BlockData& data = Block_Information[block.getTilePosition()];
 
        if (data.Power_State != BlockData::FULLY_POWERED) continue;
 
        poweredLargePlacements += data.Large_Placements;
    }
 
    return poweredLargePlacements;
}

◆ onStart()

void BuildingPlacer::onStart ( )

Update Block information to reflect generated BWEB Blocks and reset values to reflect a beggining game state.

Definition at line 451 of file BuildingPlacer.cpp.

{
    mapWidth = BWAPI::Broodwar->mapWidth();
    mapHeight = BWAPI::Broodwar->mapHeight();
 
    //poweredTiles.assign(mapHeight, std::vector<int>(mapWidth, 0));
    Block_Information.clear();
    AreasOccupied.clear();
    ProtoBot_Blocks.clear();
    Area_Blocks.clear();
    Powered_LargePlacements = 0;
    Powered_MediumPlacements = 0;
 
    //Assign main area since we will always own this area at the start of the game
    const BWAPI::TilePosition ProtoBot_MainBase = BWAPI::Broodwar->self()->getStartLocation();
    const BWEM::Area* mainArea = theMap.GetArea(ProtoBot_MainBase);
    AreasOccupied.insert(mainArea);
 
    std::vector<BWEB::Block> blocks = BWEB::Blocks::getBlocks();
    int largePlacements = 0;
    int mediumPlacements = 0;
    int smallPlacements = 0;
    nexusCount = 0;
 
    for (BWEB::Block block : blocks)
    {
        //Store this information for later use and save it.
        BlockData block_info;
 
        largePlacements = block.getLargeTiles().size();
        mediumPlacements = block.getMediumTiles().size();
        smallPlacements = block.getSmallTiles().size();
 
        //std::cout << "Large Placements = " << largePlacements << "\n";
        //std::cout << "Medium Placements = " << mediumPlacements << "\n";
        //std::cout << "Supply Placements = " << smallPlacements << "\n";
 
        if (largePlacements >= 2)
        {
            block_info.Blocksize = BlockData::LARGE;
 
            //std::cout << "Adding Large Block\n";
            std::set<BWAPI::TilePosition> powerTiles = block.getSmallTiles();
            block_info.PowerTiles = powerTiles;
            //std::cout << "Block power tiles = " << block_info.PowerTiles.size() << "\n";
        }
        else if (mediumPlacements != 0 || largePlacements == 1)
        {
            block_info.Blocksize = BlockData::MEDIUM;
 
            //std::cout << "Adding Medium Block\n";
            std::set<BWAPI::TilePosition> powerTiles = block.getSmallTiles();
            block_info.PowerTiles = powerTiles;
            //std::cout << "Block power tiles = " << block_info.PowerTiles.size() << "\n";
        }
        else if (mediumPlacements == 0 && largePlacements == 0 && smallPlacements == 1)
        {
            //std::cout << "Adding Supply block\n";
            block_info.Blocksize = BlockData::SUPPLY;
        }
 
        block_info.Large_Placements = largePlacements;
        block_info.Medium_Placements = mediumPlacements;
        block_info.Power_Placements = smallPlacements;
        block_info.Block_AreaLocation = theMap.GetArea(block.getTilePosition());
 
        //std::cout << "Large Placements " << block_info.Large_Placements << "\n";
        //std::cout << "Medium Placements " << block_info.Medium_Placements << "\n";
        //std::cout << "Small/Power Placements " << block_info.Power_Placements << "\n";
 
        const BWEM::Area* blockArea = theMap.GetNearestArea(block.getTilePosition());
 
        if (blockArea != nullptr)
        {
            Area_Blocks[blockArea].push_back(block);
        }
        else
        {
            //This should happen but just in case.
            //std::cout << "Uh Oh couldnt find Area\n";
        }
 
        //Might have a bug with corners using this approach but hopefully it will be okay using reserving system
        Block_Information.emplace(block.getTilePosition(), block_info);
    }
 
    ProtoBot_Blocks.insert(ProtoBot_Blocks.end(), Area_Blocks[mainArea].begin(), Area_Blocks[mainArea].end());
}

◆ onUnitComplete()

void BuildingPlacer::onUnitComplete ( BWAPI::Unit unit )

Updates BWEM to reflect the current state of StarCraft game.

Parameters

Unit

Definition at line 547 of file BuildingPlacer.cpp.

{
    if (unit->getType() == BWAPI::UnitTypes::Protoss_Nexus && unit->getPlayer() == BWAPI::Broodwar->self())
    {
        nexusCount++;
 
        const BWEM::Area* expandedArea = theMap.GetArea(unit->getTilePosition());
 
        //If the area is the same no new blocks should be added
        if (AreasOccupied.find(expandedArea) != AreasOccupied.end()) return;
 
        AreasOccupied.insert(expandedArea);
 
        ProtoBot_Blocks.insert(ProtoBot_Blocks.end(), Area_Blocks[expandedArea].begin(), Area_Blocks[expandedArea].end());
    }
    else if (unit->getType() == BWAPI::UnitTypes::Protoss_Pylon && unit->getPlayer() == BWAPI::Broodwar->self())
    {
        /*const BWAPI::TilePosition location = unit->getTilePosition();
        const int mapX_location = location.x;
        const int mapY_location = location.y;
 
        //Make looping easier we will think of the area a pylon powers as a square. We will then factor in an offset to then get the proper "circle" shape.
        const int topLeft_x = mapX_location - 7;
        const int topLeft_y = mapY_location - 4;
 
        for (int poweredRow_index = topLeft_y; poweredRow_index < topLeft_y + PYLON_POWER_HEIGHT; poweredRow_index++)
        {
            for (int poweredColumn_index = topLeft_x; poweredColumn_index < (topLeft_x + PYLON_POWER_WIDTH); poweredColumn_index++)
            {
                if (poweredColumn_index >= mapWidth || poweredColumn_index < 0 || poweredRow_index < 0 || poweredRow_index >= mapHeight) continue;
 
                poweredTiles[poweredRow_index][poweredColumn_index] += 1;
            }
        }*/
 
        for (BWEB::Block block : ProtoBot_Blocks)
        {
            BlockData& data = Block_Information[block.getTilePosition()];
 
            for (const BWAPI::TilePosition powerTile : data.PowerTiles)
            {
                if (unit->getTilePosition() == powerTile)
                {
                    data.Used_Power_Placements++;
 
                    if (data.Used_Power_Placements == data.PowerTiles.size())
                    {
                        data.Power_State = BlockData::FULLY_POWERED;
                        Powered_LargePlacements += data.Large_Placements;
                        Powered_MediumPlacements += data.Medium_Placements;
                    }
                    else
                    {
                        data.Power_State = BlockData::HALF_POWERED;
                    }
 
                    break;
                }
            }
        }
    }
}

◆ onUnitCreate()

void BuildingPlacer::onUnitCreate ( BWAPI::Unit unit )

Updates BWEM to reflect the current state of StarCraft game.

Parameters

Unit

Definition at line 540 of file BuildingPlacer.cpp.

{
    if (!unit->getType().isBuilding()) return;
 
    BWEB::Map::addUsed(unit->getTilePosition(), unit->getType());
}

◆ onUnitDestroy()

void BuildingPlacer::onUnitDestroy ( BWAPI::Unit unit )

Updates BWEM to reflect the current state of StarCraft game.

Parameters

Unit

Definition at line 610 of file BuildingPlacer.cpp.

{
    BWEB::Map::onUnitDestroy(unit);
 
    if (unit->getType() == BWAPI::UnitTypes::Protoss_Nexus && unit->getPlayer() == BWAPI::Broodwar->self())
    {
        if (nexusCount > 0) nexusCount--;
 
        const BWEM::Area* destroyedNexusArea = theMap.GetArea(unit->getTilePosition());
 
        //Sanity Check
        if (AreasOccupied.find(destroyedNexusArea) == AreasOccupied.end()) return;
 
        AreasOccupied.erase(destroyedNexusArea);
 
        //Make sure this is working correctly.
        for (std::vector<BWEB::Block>::iterator it = ProtoBot_Blocks.begin(); it != ProtoBot_Blocks.end();)
        {
            const BlockData& data = Block_Information[it->getTilePosition()];
 
            if (data.Block_AreaLocation == destroyedNexusArea)
            {
                it = ProtoBot_Blocks.erase(it);
            }
            else
            {
                it++;
            }
        }
    }
    else if (unit->getType() == BWAPI::UnitTypes::Protoss_Pylon && unit->getPlayer() == BWAPI::Broodwar->self())
    {
        //std::cout << "Pylon destroyed at location: " << unit->getTilePosition() << "\n";
 
        /*const BWAPI::TilePosition location = unit->getTilePosition();
        const int mapX_location = location.x;
        const int mapY_location = location.y;
 
        //Make looping easier we will think of the area a pylon powers as a square. We will then factor in an offset to then get the proper "circle" shape.
        const int topLeft_x = mapX_location - 7;
        const int topLeft_y = mapY_location - 4;
 
        for (int poweredRow_index = topLeft_y; poweredRow_index < topLeft_y + PYLON_POWER_HEIGHT; poweredRow_index++)
        {
            for (int poweredColumn_index = topLeft_x; poweredColumn_index < (topLeft_x + PYLON_POWER_WIDTH); poweredColumn_index++)
            {
                if (poweredColumn_index >= mapWidth || poweredColumn_index < 0 || poweredRow_index < 0 || poweredRow_index >= mapHeight) continue;
 
                poweredTiles[poweredRow_index][poweredColumn_index] -= 1;
 
                //Sanity check
                if (poweredTiles[poweredRow_index][poweredColumn_index] < 0)
                    poweredTiles[poweredRow_index][poweredColumn_index] = 0;
            }
        }*/
 
        for (BWEB::Block block : ProtoBot_Blocks)
        {
            BlockData& data = Block_Information[block.getTilePosition()];
 
            for (const BWAPI::TilePosition powerTile : data.PowerTiles)
            {
                if (unit->getTilePosition() == powerTile)
                {
                    data.Used_Power_Placements--;
 
                    if (data.Used_Power_Placements == data.PowerTiles.size())
                    {
                        data.Power_State = BlockData::FULLY_POWERED;
                    }
                    else if(data.Used_Power_Placements == data.PowerTiles.size() / 2)
                    {
                        data.Power_State = BlockData::HALF_POWERED;
                    }
                    else
                    {
                        data.Power_State = BlockData::NOT_POWERED;
                        if (Powered_LargePlacements - data.Large_Placements > 0)
                        {
                            Powered_LargePlacements -= data.Large_Placements;
                        }
                        else
                        {
                            Powered_LargePlacements = 0;
                        }
 
                        if (Powered_MediumPlacements - data.Medium_Placements > 0)
                        {
                            Powered_MediumPlacements -= data.Medium_Placements;
                        }
                        else
                        {
                            Powered_MediumPlacements = 0;
                        }
                        
                    }
 
                    break;
                }
            }
        }
    }
}

◆ onUnitDiscover()

void BuildingPlacer::onUnitDiscover ( BWAPI::Unit unit )

Updates BWEM to reflect the current state of StarCraft game.

Parameters

Unit

Definition at line 719 of file BuildingPlacer.cpp.

{
    BWEB::Map::onUnitDiscover(unit);
}

◆ onUnitMorph()

void BuildingPlacer::onUnitMorph ( BWAPI::Unit unit )

Updates BWEM to reflect the current state of StarCraft game.

Parameters

Unit

Definition at line 714 of file BuildingPlacer.cpp.

{
    BWEB::Map::onUnitMorph(unit);
}

Member Data Documentation

◆ Area_Blocks

std::unordered_map<const BWEM::Area*, std::vector<BWEB::Block> > BuildingPlacer::Area_Blocks

private

Definition at line 85 of file BuildingPlacer.h.

◆ AreasOccupied

std::unordered_set<const BWEM::Area *> BuildingPlacer::AreasOccupied

private

Definition at line 78 of file BuildingPlacer.h.

◆ Block_Information

std::map<BWAPI::TilePosition, BlockData> BuildingPlacer::Block_Information

private

Definition at line 75 of file BuildingPlacer.h.

◆ buildReference

BuildManager* BuildingPlacer::buildReference

Definition at line 100 of file BuildingPlacer.h.

◆ debug

bool BuildingPlacer::debug = false

private

Definition at line 93 of file BuildingPlacer.h.

◆ mapHeight

int BuildingPlacer::mapHeight = 0

private

Definition at line 88 of file BuildingPlacer.h.

◆ mapWidth

int BuildingPlacer::mapWidth = 0

private

Definition at line 87 of file BuildingPlacer.h.

◆ nexusCount

int BuildingPlacer::nexusCount = 0

private

Definition at line 91 of file BuildingPlacer.h.

◆ Powered_LargePlacements

int BuildingPlacer::Powered_LargePlacements = 0

Definition at line 96 of file BuildingPlacer.h.

◆ Powered_MediumPlacements

int BuildingPlacer::Powered_MediumPlacements = 0

Definition at line 97 of file BuildingPlacer.h.

◆ ProtoBot_Blocks

std::vector<BWEB::Block> BuildingPlacer::ProtoBot_Blocks

private

Definition at line 81 of file BuildingPlacer.h.

◆ Used_LargeBuildingPlacements

int BuildingPlacer::Used_LargeBuildingPlacements

Definition at line 98 of file BuildingPlacer.h.

◆ Used_MediumBuildingPlacements

int BuildingPlacer::Used_MediumBuildingPlacements

Definition at line 99 of file BuildingPlacer.h.

The documentation for this class was generated from the following files:

src/protobot/BuildingPlacer.h
src/protobot/BuildingPlacer.cpp

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BuildingPlacer()

Member Function Documentation

◆ alreadyUsingTiles()

◆ checkBuildingBlocks()

◆ checkPower()

◆ checkPowerReserveBlocks()

◆ drawPoweredTiles()

◆ findAvailableExpansion()

◆ findAvailableGyser()

◆ findAvaliblePlacement()

◆ getPositionToBuild()

◆ numberOfFullPoweredLargePlacements()

◆ onStart()

◆ onUnitComplete()

◆ onUnitCreate()

◆ onUnitDestroy()

◆ onUnitDiscover()

◆ onUnitMorph()

Member Data Documentation

◆ Area_Blocks

◆ AreasOccupied

◆ Block_Information

◆ buildReference

◆ debug

◆ mapHeight

◆ mapWidth

◆ nexusCount

◆ Powered_LargePlacements

◆ Powered_MediumPlacements

◆ ProtoBot_Blocks

◆ Used_LargeBuildingPlacements

◆ Used_MediumBuildingPlacements