The SpenderManager is the way ProtoBot is able to reserve the resouces ProtoBot wants to spend and approve the requests of units ProtoBot is able to make.
This prevents ProtoBot from spending resoucres that ahve already been allocated to another request and allows ProtoBot to make decisions based on what it has already made. More...

#include <SpenderManager.h>

Public Member Functions
bool	canAfford (int mineralPrice, int gasPrice, int currentMinerals, int currentGas)
	Given the mineral and gas cost of a unit, considering the amount of minerals and gas we mightve spent this frame, are we able to afford this unit?
int	availableMinerals (std::vector< ResourceRequest > &)
	Loops through all of ProtoBot's current ResourceRequest's and checks the amount of minerals we have already reserved for each unit compared the amount of minerals StarCraft says ProtoBot currently has. If a ResourceRequest has a State other than PendingApproval, we have already reserved the minerals for that request.
int	availableGas (std::vector< ResourceRequest > &)
	Loops through all of ProtoBot's current ResourceRequest's and checks the amount of gas we have already reserved for each unit compared the amount of gas StarCraft says ProtoBot currently has. If a ResourceRequest has a State other than PendingApproval, we have already reserved the gas for that request.
int	plannedSupply (std::vector< ResourceRequest > &, BWAPI::Unitset)
	Due to buildings having two states created and completed, this requires ProtoBot to check if we have enough supply being made already to prevent ProtoBot from being supply blocked. First ProtoBot adds up all the supply buildings and units that are approved in the ResourceRequest queue. Second a check to all the unit ProtoBot currently is accounted for. In StarCraft a building does not provide supply until it is in a completed state, to prevent ProtoBot from creating more supply when units are in a created but not completed state this second check prevents the case from happening.
int	availableSupply ()
void	printQueue ()
void	onStart ()
void	OnFrame (std::vector< ResourceRequest > &)
	The queue for ProtoBot's ResourceRequest's operates in a first in first out operation, this means that ProtoBot is not able to reorganize the queue in any advance ways but does provide a structed list of units to created in their requested order. The SpenderManager simply loops through the ResourceRequest's of ProtoBot and checks what the agent is able afford. Due to prioirty not being implemented a simple first pass is ran specifically for Pylons and Worker due to the units being integral to success. After the initial first pass the queue runs normally through the pending resource requests until we can no longer afford any more units.

Detailed Description

The SpenderManager is the way ProtoBot is able to reserve the resouces ProtoBot wants to spend and approve the requests of units ProtoBot is able to make.
This prevents ProtoBot from spending resoucres that ahve already been allocated to another request and allows ProtoBot to make decisions based on what it has already made.

Definition at line 14 of file SpenderManager.h.

Constructor & Destructor Documentation

◆ SpenderManager()

SpenderManager::SpenderManager ( )

Definition at line 5 of file SpenderManager.cpp.

{
 
}

Member Function Documentation

◆ availableGas()

int SpenderManager::availableGas ( std::vector< ResourceRequest > & requests )

Loops through all of ProtoBot's current ResourceRequest's and checks the amount of gas we have already reserved for each unit compared the amount of gas StarCraft says ProtoBot currently has.
If a ResourceRequest has a State other than PendingApproval, we have already reserved the gas for that request.

Parameters

ProtoBot ResourceRequests

Returns: amount of gas not reserved

Definition at line 47 of file SpenderManager.cpp.

{
    int currentGasCount = BWAPI::Broodwar->self()->gas();
 
    for (const ResourceRequest &request : requests)
    {
        //Sanity Check
        if (request.state == ResourceRequest::State::Accepted_Completed ||
            request.state == ResourceRequest::State::PendingApproval) continue;
 
        switch (request.type)
        {
        case ResourceRequest::Type::Unit:
        case ResourceRequest::Type::Building:
            currentGasCount -= request.unit.gasPrice();
            break;
 
        case ResourceRequest::Type::Upgrade:
            currentGasCount -= request.upgrade.gasPrice();
            break;
 
        case ResourceRequest::Type::Tech:
            currentGasCount -= request.tech.gasPrice();
            break;
        }
    }
 
    return currentGasCount;
}

◆ availableMinerals()

int SpenderManager::availableMinerals ( std::vector< ResourceRequest > & requests )

Loops through all of ProtoBot's current ResourceRequest's and checks the amount of minerals we have already reserved for each unit compared the amount of minerals StarCraft says ProtoBot currently has.
If a ResourceRequest has a State other than PendingApproval, we have already reserved the minerals for that request.

Parameters

ProtoBot ResourceRequests

Returns: amount of minerals not reserved

Definition at line 17 of file SpenderManager.cpp.

{
    int currentMineralCount = BWAPI::Broodwar->self()->minerals();
 
    for (const ResourceRequest &request : requests)
    {
        //Sanity Check
        if (request.state == ResourceRequest::State::Accepted_Completed ||
            request.state == ResourceRequest::State::PendingApproval) continue;
 
        switch (request.type)
        {
            case ResourceRequest::Type::Unit:
            case ResourceRequest::Type::Building:
                currentMineralCount -= request.unit.mineralPrice();
                break;
 
            case ResourceRequest::Type::Upgrade:
                currentMineralCount -= request.upgrade.mineralPrice();
                break;
 
            case ResourceRequest::Type::Tech:
                currentMineralCount -= request.tech.mineralPrice();
                break;
        }
    }
 
    return currentMineralCount;
}

◆ availableSupply()

int SpenderManager::availableSupply ( )

Definition at line 78 of file SpenderManager.cpp.

{
    //int unusedSupply = (BWAPI::Broodwar->self()->supplyTotal() - BWAPI::Broodwar->self()->supplyUsed()) / 2;
 
    return (BWAPI::Broodwar->self()->supplyTotal() - BWAPI::Broodwar->self()->supplyUsed()) / 2;;
}

◆ canAfford()

bool SpenderManager::canAfford	(	int	mineralPrice,
		int	gasPrice,
		int	currentMinerals,
		int	currentGas )

Given the mineral and gas cost of a unit, considering the amount of minerals and gas we mightve spent this frame, are we able to afford this unit?

Parameters

mineralPrice
gasPrice
currentMinerals (minerals we have not spent considering the minerals we reserved)
currentGas (gas we have not spent considering the gas we reserved)

Returns

Definition at line 126 of file SpenderManager.cpp.

{
    if (((currentMinerals - mineralPrice) >= 0) && ((currentGas - gasPrice) >= 0))
    {
        return true;
    }
 
    return false;
}

◆ OnFrame()

void SpenderManager::OnFrame ( std::vector< ResourceRequest > & requests )

The queue for ProtoBot's ResourceRequest's operates in a first in first out operation, this means that ProtoBot is not able to reorganize the queue in any advance ways but does provide a structed list of units to created in their requested order.

The SpenderManager simply loops through the ResourceRequest's of ProtoBot and checks what the agent is able afford. Due to prioirty not being implemented a simple first pass is ran specifically for Pylons and Worker due to the units being integral to success.

After the initial first pass the queue runs normally through the pending resource requests until we can no longer afford any more units.

Parameters

ProtoBot ResourceRequest

Definition at line 143 of file SpenderManager.cpp.

{
    //Calculate avalible minerals to spend. This considers the minerals we plan to spend as well.
    int currentMineralCount = availableMinerals(requests);
    int currentGasCount = availableGas(requests);
 
    //Need to modify spender manager to be able to consider supply usage.
    int currentSupply = availableSupply();
    int mineralPrice = 0;
    int gasPrice = 0;
    bool canAffordRequest = false;
 
    //Pylon first pass. These units should have priority.
    for (ResourceRequest& request : requests)
    {
        if (request.state == ResourceRequest::State::PendingApproval 
            && ((request.type == ResourceRequest::Type::Building && request.unit == BWAPI::UnitTypes::Protoss_Pylon) || request.type == ResourceRequest::Type::Unit && request.unit == BWAPI::UnitTypes::Protoss_Probe))
        {
            mineralPrice = request.unit.mineralPrice();
            gasPrice = request.unit.gasPrice();
 
            canAffordRequest = canAfford(mineralPrice, gasPrice, currentMineralCount, currentGasCount);
 
            if (canAffordRequest)
            {
                request.state = ResourceRequest::State::Approved_InProgress;
                request.frameRequestApproved = BWAPI::Broodwar->getFrameCount();
                currentMineralCount -= mineralPrice;
                currentGasCount -= gasPrice;
                //std::cout << "Able to afford " << request.unit.getName() << " (Request Number " << request.requestNumber << ") : Setting to approved(Frame : " << request.frameRequestApproved << ")\n";
            }
        }
    }
 
    //spend money until we cant anymore.
    for (ResourceRequest& request : requests)
    {
        if (request.state != ResourceRequest::State::PendingApproval) continue;
 
        switch (request.type)
        {
            case ResourceRequest::Type::Unit:
            case ResourceRequest::Type::Building:
                mineralPrice = request.unit.mineralPrice();
                gasPrice = request.unit.gasPrice();
                canAffordRequest = canAfford(mineralPrice, gasPrice, currentMineralCount, currentGasCount);
 
                //if (canAffordRequest) std::cout << "Able to afford " << request.unit.getName() << " (Request Number " << request.requestNumber << ")";
                break;
            case ResourceRequest::Type::Upgrade:
                mineralPrice = request.upgrade.mineralPrice();
                gasPrice = request.upgrade.gasPrice();
                canAffordRequest = canAfford(mineralPrice, gasPrice, currentMineralCount, currentGasCount);
 
                //if (canAffordRequest) std::cout << "Able to afford " << request.upgrade.getName() << " (Request Number " << request.requestNumber << ")";
                break;
            case ResourceRequest::Type::Tech:
                mineralPrice = request.tech.mineralPrice();
                gasPrice = request.tech.gasPrice();
                canAffordRequest = canAfford(mineralPrice, gasPrice, currentMineralCount, currentGasCount);
 
                //if (canAffordRequest) std::cout << "Able to afford " << request.tech.getName() << " (Request Number " << request.requestNumber << ")";
                break;
        }
 
 
        if (canAffordRequest)
        {
            request.state = ResourceRequest::State::Approved_InProgress;
            request.frameRequestApproved = BWAPI::Broodwar->getFrameCount();
            currentMineralCount -= mineralPrice;
            currentGasCount -= gasPrice;
 
            //std::cout << " : Setting to approved (Frame: " << request.frameRequestApproved << ")\n";
        }
        else
        {
            break;
        }
    }
}

◆ onStart()

void SpenderManager::onStart ( )

Definition at line 138 of file SpenderManager.cpp.

{
    
}

◆ plannedSupply()

int SpenderManager::plannedSupply	(	std::vector< ResourceRequest > &	requests,
		BWAPI::Unitset	buildings )

Due to buildings having two states created and completed, this requires ProtoBot to check if we have enough supply being made already to prevent ProtoBot from being supply blocked.
First ProtoBot adds up all the supply buildings and units that are approved in the ResourceRequest queue.
Second a check to all the unit ProtoBot currently is accounted for.
In StarCraft a building does not provide supply until it is in a completed state, to prevent ProtoBot from creating more supply when units are in a created but not completed state this second check prevents the case from happening.

Parameters

ProtoBot ResourceRequests
ProtoBot units

Returns: amount of supply not used

Definition at line 85 of file SpenderManager.cpp.

{
    const int totalSupply = BWAPI::Broodwar->self()->supplyTotal() / 2; //Current supply total StarCraft notes us having.
    const int usedSupply = BWAPI::Broodwar->self()->supplyUsed() / 2; //Used supply total StarCraft notes us having.
 
    int plannedUsedSuply = 0; //Supply we plan on using (Units are in the build queue but have not been accepted yet.
    int plannedSupply = 0; //Buildings we plan on constructing that provide supply. 
 
    for (const ResourceRequest &request : requests)
    {
        //Sanity Check
        if (request.state == ResourceRequest::State::Accepted_Completed) continue;
 
 
        switch (request.type)
        {
            case ResourceRequest::Type::Unit:
                plannedUsedSuply += (request.unit.supplyRequired() / 2);
                break;
            case ResourceRequest::Type::Building:
                plannedSupply += request.unit.supplyProvided() / 2;
                break;
        }
    }
 
    //Consider buildings that are not constructed yet for potential supply.
    for (const BWAPI::Unit building : buildings)
    {
        if (!building->isCompleted())
        {
            plannedSupply += building->getType().supplyProvided() / 2;
        }
    }
 
    /*std::cout << "Total supply (with planned building considerations) = " << (totalSupply + plannedSupply) << "\n";
    std::cout << "Used supply (with planned unit considerations) = " << usedSupply << "\n";
    std::cout << "StarCraft Supply Avalible = " << (totalSupply - usedSupply) << "\n";
    std::cout << "Spender Manager Supply Avalible " << ((totalSupply + plannedSupply) - (usedSupply + plannedUsedSuply)) << "\n";*/
    return ((totalSupply + plannedSupply) - (usedSupply + plannedUsedSuply));
}

◆ printQueue()

void SpenderManager::printQueue ( )

Definition at line 10 of file SpenderManager.cpp.

{
   
}

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

src/protobot/SpenderManager.h
src/protobot/SpenderManager.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ SpenderManager()

Member Function Documentation

◆ availableGas()

◆ availableMinerals()

◆ availableSupply()

◆ canAfford()

◆ OnFrame()

◆ onStart()

◆ plannedSupply()

◆ printQueue()