BuildManager Class Reference

The BuildManagers responsibility is to be able to service the ResourceRequests passed to it and verify a unit is able to create the upgrade or combat unit. In the case of buildings more work is required to be able to find suitable locations to make sure that building can be constructed.
The class is also responsible for defining and executing the openings for each race that StarCraft has, allowing ProtoBot to have openers similar to chess at the beginning stages of a StarCraft game. More...

#include <BuildManager.h>

Public Member Functions
	BuildManager (ProtoBotCommander *commanderReference)
void	onStart ()
void	onFrame (std::vector< ResourceRequest > &resourceRequests)
void	onUnitCreate (BWAPI::Unit)
void	onUnitDestroy (BWAPI::Unit)
void	onUnitMorph (BWAPI::Unit)
void	onUnitComplete (BWAPI::Unit)
void	onUnitDiscover (BWAPI::Unit)
BWAPI::Unitset	getBuildings ()
void	initBuildOrdersOnStart ()
void	selectBuildOrderAgainstRace (BWAPI::Race enemyRace)
void	selectRandomBuildOrder ()
void	runBuildOrderOnFrame ()
bool	isBuildOrderActive () const
bool	checkWorkerIsConstructing (BWAPI::Unit)
bool	isBuildOrderCompleted ()
bool	checkUnitIsBeingWarpedIn (BWAPI::UnitType building, const BWEM::Base *nexus=nullptr)
BWAPI::Unit	getUnitToBuild (BWAPI::Position)
std::vector< NexusEconomy >	getNexusEconomies ()

Public Attributes
ProtoBotCommander *	commanderReference
BuildingPlacer	buildingPlacer
std::vector< Builder >	builders
bool	buildOrderCompleted = false
BWAPI::Unitset	buildings

Private Member Functions
std::string	buildOrderNameToString (int name) const
bool	enqueueBuildOrderBuilding (BWAPI::UnitType type, int count)
bool	enqueueBuildOrderUnit (BWAPI::UnitType type, int count)

Private Attributes
std::vector< BuildOrder >	buildOrders
int	activeBuildOrderIndex = -1
size_t	activeBuildOrderStep = 0
bool	buildOrderActive = false

Detailed Description

The BuildManagers responsibility is to be able to service the ResourceRequests passed to it and verify a unit is able to create the upgrade or combat unit. In the case of buildings more work is required to be able to find suitable locations to make sure that building can be constructed.
The class is also responsible for defining and executing the openings for each race that StarCraft has, allowing ProtoBot to have openers similar to chess at the beginning stages of a StarCraft game.

Definition at line 33 of file BuildManager.h.

Constructor & Destructor Documentation

BuildManager()

BuildManager::BuildManager

(

ProtoBotCommander *

commanderReference

)

Definition at line 7 of file BuildManager.cpp.

                                                                : commanderReference(commanderReference), buildingPlacer(this)
{
 
}

Member Function Documentation

buildOrderNameToString()

std::string BuildManager::buildOrderNameToString ( int name ) const

private

Definition at line 401 of file BuildManager.cpp.

{
    switch (name)
    {
        case 1: return "2 Gateway Dark Templar vs Terran";
        case 2: return "2 Gateway Dark Templar vs Protoss";
        case 3: return "2 Gateway Observer vs Zerg";
    }
}

checkUnitIsBeingWarpedIn()

bool BuildManager::checkUnitIsBeingWarpedIn	(	BWAPI::UnitType	building,
		const BWEM::Base *	nexus = nullptr )

Definition at line 349 of file BuildManager.cpp.

{
    if (nexus == nullptr)
    {
        for (const BWAPI::Unit building : buildings)
        {
            if (unit == building->getType() && !building->isCompleted())
            {
                return true;
            }
        }
    }
    else
    {
        for (const BWAPI::Unit building : buildings)
        {
            if (building->getType() != BWAPI::UnitTypes::Protoss_Assimilator) continue;
 
            if (unit == building->getType() && !building->isCompleted())
            {
                for (BWEM::Geyser* geyer : nexus->Geysers())
                {
                    if (building->getPosition() == geyer->Pos()) return true;
                }
 
                //if (nexusPosition != BWAPI::Positions::Invalid) std::cout << "Nexus at " << nexusPosition << " already has assimilator requested: " << "(Approx. distance " << nexusPosition.getApproxDistance(building->getPosition()) << ")\n";
            }
        }
    }
 
    return false;
}

checkWorkerIsConstructing()

bool BuildManager::checkWorkerIsConstructing

(

BWAPI::Unit

unit

)

Definition at line 329 of file BuildManager.cpp.

{
    for (Builder& builder : builders)
    {
        if (builder.getUnitReference()->getID() == unit->getID()) return true;
    }
 
    return false;
}

enqueueBuildOrderBuilding()

bool BuildManager::enqueueBuildOrderBuilding ( BWAPI::UnitType type, int count )

private

Definition at line 440 of file BuildManager.cpp.

{
    for (int i = 0; i < count; i++)
    {
        /*ResourceRequest req;
        req.type = ResourceRequest::Type::Building;
        req.unit = type;
        req.fromBuildOrder = true;
        resourceRequests.push_back(req);*/
 
        commanderReference->requestBuilding(type, true);
    }
    return true;
}

enqueueBuildOrderUnit()

bool BuildManager::enqueueBuildOrderUnit ( BWAPI::UnitType type, int count )

private

Definition at line 455 of file BuildManager.cpp.

{
    if (!commanderReference)
        return false;
 
    const BWAPI::UnitType trainerType = type.whatBuilds().first;
    if (trainerType == BWAPI::UnitTypes::None)
        return false;
 
    int requestsIssued = 0;
    for (BWAPI::Unit building : buildings)
    {
        if (!building || building->getType() != trainerType)
            continue;
        if (!building->isCompleted() || !building->isPowered() || building->isTraining())
            continue;
        if (!building->canTrain(type) || commanderReference->alreadySentRequest(building->getID()))
            continue;
 
        commanderReference->requestUnit(type, building, true);
        requestsIssued++;
 
        if (requestsIssued >= count)
            return true;
    }
 
    return false;
}

getBuildings()

BWAPI::Unitset BuildManager::getBuildings

(

)

Definition at line 339 of file BuildManager.cpp.

{
    return buildings;
}

getNexusEconomies()

std::vector< NexusEconomy > BuildManager::getNexusEconomies

(

)

Definition at line 387 of file BuildManager.cpp.

{
    return commanderReference->getNexusEconomies();
}

getUnitToBuild()

BWAPI::Unit BuildManager::getUnitToBuild

(

BWAPI::Position

position

)

Definition at line 382 of file BuildManager.cpp.

{
    return commanderReference->getUnitToBuild(position);
}

initBuildOrdersOnStart()

void BuildManager::initBuildOrdersOnStart

(

)

Definition at line 411 of file BuildManager.cpp.

{
    buildOrders = BuildOrders::createAll();
}

isBuildOrderActive()

bool BuildManager::isBuildOrderActive

(

)

const

Definition at line 396 of file BuildManager.cpp.

{
    return buildOrderActive && !buildOrderCompleted && activeBuildOrderIndex >= 0 && activeBuildOrderIndex < (int)buildOrders.size();
}

isBuildOrderCompleted()

bool BuildManager::isBuildOrderCompleted

(

)

Definition at line 344 of file BuildManager.cpp.

{
    return buildOrderCompleted;
}

onFrame()

void BuildManager::onFrame

(

std::vector< ResourceRequest > &

resourceRequests

)

Definition at line 46 of file BuildManager.cpp.

{
    runBuildOrderOnFrame();
 
    buildingPlacer.drawPoweredTiles();
 
    //Have to have loop that can check if a building can create a unit and is powered.
    //Might also need to have some data that shows what each building is doing but might be too complictaed for this approach.
    for (ResourceRequest& request : resourceRequests)
    {
        if (request.state != ResourceRequest::State::Approved_InProgress)
        {
            continue;
        }
 
        switch (request.type)
        {
            case ResourceRequest::Type::Unit:
            {
                if (request.requestedBuilding->canTrain(request.unit) &&
                    !request.requestedBuilding->isTraining() &&
                    request.requestedBuilding->isCompleted() &&
                    request.requestedBuilding->isPowered())
                {
                    if (request.requestedBuilding->train(request.unit))
                    {
                        request.state = ResourceRequest::State::Accepted_Completed;
                        request.frameRequestServiced = BWAPI::Broodwar->getFrameCount();
                    }
                    else
                    {
                        std::cout << "Failed to train unit for whatever reason\n";
                    }
                }
 
                break;
            }
            case ResourceRequest::Type::Building:
            {
                //Should change this to consider distance measure but is fine for now.
                if (request.isCheese)
                {
                    request.state = ResourceRequest::State::Approved_BeingBuilt;
                }
                else
                {
                    if (request.placementPos == BWAPI::Positions::Invalid) request.placementInfo = buildingPlacer.getPositionToBuild(request.unit, request.base);
 
                    if (request.placementInfo.position == BWAPI::Positions::Invalid && request.gotPositionToBuild == false)
                    {
                        const PlacementInfo::PlacementFlag flag_info = request.placementInfo.flag;
 
                        switch (flag_info)
                        {
                        case PlacementInfo::NO_POWER:
                            //should create a new pylon request by inserting a pylon in the front of the queue.
                            //std::cout << "FAILED: NO POWER\n";
                            break;
                        case PlacementInfo::NO_BLOCKS:
                            //Wait for a bit and kill the request if no blocks are added
                            //std::cout << "FAILED: NO BLOCKS\n";
                            break;
                        case PlacementInfo::NO_GYSERS:
                            //Shouldnt happen but okay
                            //std::cout << "FAILED: NO GYSERS\n";
                            break;
                        case PlacementInfo::NO_PLACEMENTS:
                            //Wait for a bit and kill the request if no placements are added.
                            //std::cout << "FAILED: NO PLACEMENTS\n";
                            break;
                        case PlacementInfo::NO_EXPANSIONS:
                            //kill the expansion request.
                            //std::cout << "FAILED: NO EXPANSION\n";
                            break;
                        }
 
                        request.attempts++;
                    }
                    else
                    {
                        request.placementPos = request.placementInfo.position;
                        request.tileToPlace = request.placementInfo.topLeft;
 
                        const BWAPI::Unit workerAvalible = getUnitToBuild(request.placementPos);
 
                        if (workerAvalible == nullptr) continue;
 
                        Path pathToLocation;
                        if (request.unit.isResourceDepot())
                        {
                            //std::cout << "Trying to build Nexus\n";
                            pathToLocation = AStar::GeneratePath(workerAvalible->getPosition(), workerAvalible->getType(), request.placementPos);
                        }
                        else if (request.unit.isRefinery())
                        {
                            //std::cout << "Trying to build assimlator\n";
                            pathToLocation = AStar::GeneratePath(workerAvalible->getPosition(), workerAvalible->getType(), request.placementPos, true);
                        }
                        else
                        {
                            //std::cout << "Trying to build regular building\n";
                            pathToLocation = AStar::GeneratePath(workerAvalible->getPosition(), workerAvalible->getType(), request.placementPos);
                        }
 
                        Builder temp = Builder(workerAvalible, request.unit, request.placementPos, pathToLocation);
                        builders.push_back(temp);
 
                        request.state = ResourceRequest::State::Approved_BeingBuilt;
                        request.frameRequestServiced = BWAPI::Broodwar->getFrameCount();
 
                        BWEB::Map::addUsed(request.placementInfo.topLeft, request.unit);
                    }
                }
                break;
            }
            case ResourceRequest::Type::Upgrade:
            {
                if (request.requestedBuilding->canUpgrade(request.upgrade) &&
                    !request.requestedBuilding->isUpgrading() &&
                    request.requestedBuilding->isCompleted() &&
                    request.requestedBuilding->isPowered())
                {
                    if (request.requestedBuilding->upgrade(request.upgrade))
                    {
                        request.state = ResourceRequest::State::Accepted_Completed;
                        request.frameRequestServiced = BWAPI::Broodwar->getFrameCount();
                    }
                    else
                    {
                        std::cout << "Failed to upgrade for whatever reason\n";
                    }
                }
                break;
            }
            case ResourceRequest::Type::Tech:
            {
                if (request.requestedBuilding->canResearch(request.upgrade) &&
                    !request.requestedBuilding->isResearching() &&
                    request.requestedBuilding->isCompleted() &&
                    request.requestedBuilding->isPowered())
                {
                    if (request.requestedBuilding->upgrade(request.upgrade))
                    {
                        request.state = ResourceRequest::State::Accepted_Completed;
                        request.frameRequestServiced = BWAPI::Broodwar->getFrameCount();
                    }
                    else
                    {
                        std::cout << "Failed to research tech for whatever reason\n";
                    }
                }
                break;
            }
        }
    }
 
    for (Builder& builder : builders)
    {
        builder.onFrame();
    }
}

onStart()

void BuildManager::onStart

(

)

Definition at line 25 of file BuildManager.cpp.

{
    //std::cout << "Builder Manager Initialized" << "\n";
 
    // Reset per-game state
    buildOrders.clear();
    activeBuildOrderIndex = -1;
    activeBuildOrderStep = 0;
    //Make false at the start of a game.
    buildOrderActive = false;
    buildOrderCompleted = false;
 
    buildingPlacer.onStart();
    builders.clear();
    buildings.clear();
 
    initBuildOrdersOnStart();
    selectRandomBuildOrder();
}

onUnitComplete()

void BuildManager::onUnitComplete

(

BWAPI::Unit

unit

)

Definition at line 318 of file BuildManager.cpp.

{
    buildingPlacer.onUnitComplete(unit);
}

onUnitCreate()

void BuildManager::onUnitCreate

(

BWAPI::Unit

unit

)

Definition at line 208 of file BuildManager.cpp.

{
    buildingPlacer.onUnitCreate(unit);
 
    if (unit->getPlayer() != BWAPI::Broodwar->self()) return;
 
    //std::cout << unit->getType() << " placed down at tile position " << unit->getTilePosition() << "\n";
 
    //Remove worker once a building is being warped in.
    for (std::vector<Builder>::iterator it = builders.begin(); it != builders.end(); ++it)
    {
        if (BWAPI::Position(unit->getTilePosition()) == it->requestedPositionToBuild && unit->getType() == it->buildingToConstruct)
        {
            //std::cout << "Builder placed down " << unit->getType() << ", removing from builders\n";
            it = builders.erase(it);
            break;
        }
    }
 
    if (unit->getType().isBuilding() && !unit->isCompleted()) buildings.insert(unit);
}

onUnitDestroy()

void BuildManager::onUnitDestroy

(

BWAPI::Unit

unit

)

Definition at line 231 of file BuildManager.cpp.

{
    buildingPlacer.onUnitDestroy(unit);
 
    if (unit->getPlayer() != BWAPI::Broodwar->self())
        return;
 
    for (std::vector<Builder>::iterator it = builders.begin(); it != builders.end();)
    {
        if (it->getUnitReference()->getID() == unit->getID())
        {
            //std::cout << "Builder has died\n";
 
            const BWAPI::Unit unitAvalible = getUnitToBuild(it->requestedPositionToBuild);
 
            if (unitAvalible != nullptr)
            {
                Path pathToLocation;
                if (it->buildingToConstruct.isResourceDepot())
                {
                    //std::cout << "Trying to build Nexus\n";
                    pathToLocation = AStar::GeneratePath(unitAvalible->getPosition(), unitAvalible->getType(), it->requestedPositionToBuild);
                }
                else if (it->buildingToConstruct.isRefinery())
                {
                    //std::cout << "Trying to build assimlator\n";
                    pathToLocation = AStar::GeneratePath(unitAvalible->getPosition(), unitAvalible->getType(), it->requestedPositionToBuild, true);
                }
                else
                {
                    //std::cout << "Trying to build regular building\n";
                    pathToLocation = AStar::GeneratePath(unitAvalible->getPosition(), unitAvalible->getType(), it->requestedPositionToBuild);
                }
 
                it->setUnitReference(unitAvalible);
                it->updatePath(pathToLocation);
                //std::cout << "Replacement found and updated path\n";
            }
            else
            {
                //std::cout << "Replacement could not be found\n";
            }
 
            break;
        }
 
        it++;
    }
 
    BWAPI::UnitType unitType = unit->getType();
 
    if (!unitType.isBuilding()) return;
 
    //Check if a building has been killed
    for (const BWAPI::Unit building : buildings)
    {
        if (building == unit)
        {
            buildings.erase(unit);
            return;
        }
    }
}

onUnitDiscover()

void BuildManager::onUnitDiscover

(

BWAPI::Unit

unit

)

Definition at line 323 of file BuildManager.cpp.

{
    buildingPlacer.onUnitDiscover(unit);
}

onUnitMorph()

void BuildManager::onUnitMorph

(

BWAPI::Unit

unit

)

Definition at line 295 of file BuildManager.cpp.

{
    buildingPlacer.onUnitMorph(unit);
 
    //std::cout << "Created " << unit->getType() << " (On Morph)\n";
 
    if (unit->getType() == BWAPI::UnitTypes::Protoss_Assimilator && unit->getPlayer() == BWAPI::Broodwar->self())
    {
        for (std::vector<Builder>::iterator it = builders.begin(); it != builders.end(); ++it)
        {
            if (unit->getType() == it->buildingToConstruct && BWAPI::Position(unit->getTilePosition()) == it->requestedPositionToBuild)
            {
                //std::cout << "Assimilator built at location: " << BWAPI::Position(unit->getTilePosition()) << "\n";
                //std::cout << "Builder assigned to place at location: " << it->requestedPositionToBuild << "\n";
                it = builders.erase(it);
                break;
            }
        }
 
        buildings.insert(unit);
    }
}

runBuildOrderOnFrame()

void BuildManager::runBuildOrderOnFrame

(

)

Definition at line 484 of file BuildManager.cpp.

{
    if (!isBuildOrderActive())
        return;
 
    BuildOrder& bo = buildOrders[activeBuildOrderIndex];
    const int supply = BWAPI::Broodwar->self()->supplyUsed() / 2;
 
    // Issue steps in order; at most 1 step per frame to avoid spikes
    if (activeBuildOrderStep >= bo.steps.size())
    {
        buildOrderCompleted = true;
        buildOrderActive = false;
        //std::cout << "Build Order Completed: " << buildOrderNameToString(bo.name) << "\n";
        return;
    }
 
    BuildOrderStep& step = bo.steps[activeBuildOrderStep];
 
    bool triggerMet = false;
    if (step.trigger.type == BuildTriggerType::Immediately) triggerMet = true;
    if (step.trigger.type == BuildTriggerType::AtSupply && supply >= step.trigger.value) triggerMet = true;
 
    if (!triggerMet)
        return;
 
    
bool issued = false;
 
switch (step.type)
{
    case BuildStepType::ScoutWorker:
        if (commanderReference) { commanderReference->getUnitToScout(); issued = true; }
        break;
    case BuildStepType::Train:
        issued = enqueueBuildOrderUnit(step.unit, step.count);
        break;
    case BuildStepType::Build:
    default:
        issued = enqueueBuildOrderBuilding(step.unit, step.count);
        break;
}
 
if (issued)
    activeBuildOrderStep++;
}

selectBuildOrderAgainstRace()

void BuildManager::selectBuildOrderAgainstRace

(

BWAPI::Race

enemyRace

)

Definition at line 416 of file BuildManager.cpp.

{
    std::vector<int> candidates;
    for (int i = 0; i < (int)buildOrders.size(); i++)
    {
        if (buildOrders[i].vsRace == enemyRace)
            candidates.push_back(i);
    }
 
    activeBuildOrderIndex = candidates[0];
    //activeBuildOrderIndex = 0;
    activeBuildOrderStep = 0;
    buildOrderActive = true;
    buildOrderCompleted = false;
 
    std::cout << "Selected Build Order: " << buildOrderNameToString(buildOrders[activeBuildOrderIndex].name) << "\n";
}

selectRandomBuildOrder()

void BuildManager::selectRandomBuildOrder

(

)

Definition at line 434 of file BuildManager.cpp.

{
    const BWAPI::Race enemyRace = (BWAPI::Broodwar->enemy()->getRace() != BWAPI::Races::Unknown ? BWAPI::Broodwar->enemy()->getRace() : BWAPI::Races::Unknown);
    selectBuildOrderAgainstRace(enemyRace);
}

Member Data Documentation

activeBuildOrderIndex

int BuildManager::activeBuildOrderIndex = -1

private

Definition at line 77 of file BuildManager.h.

activeBuildOrderStep

size_t BuildManager::activeBuildOrderStep = 0

private

Definition at line 78 of file BuildManager.h.

builders

std::vector<Builder> BuildManager::builders

Definition at line 39 of file BuildManager.h.

buildingPlacer

BuildingPlacer BuildManager::buildingPlacer

Definition at line 37 of file BuildManager.h.

buildings

BWAPI::Unitset BuildManager::buildings

Definition at line 43 of file BuildManager.h.

buildOrderActive

bool BuildManager::buildOrderActive = false

private

Definition at line 79 of file BuildManager.h.

buildOrderCompleted

bool BuildManager::buildOrderCompleted = false

Definition at line 41 of file BuildManager.h.

buildOrders

std::vector<BuildOrder> BuildManager::buildOrders

private

Definition at line 76 of file BuildManager.h.

commanderReference

ProtoBotCommander* BuildManager::commanderReference

Definition at line 36 of file BuildManager.h.

---

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

• src/protobot/BuildManager.h
• src/protobot/BuildManager.cpp