ProtoBot
Loading...
Searching...
No Matches
StrategyManager Class Reference

The StrategyManager is way ProtoBot is able to make macro level decisions about what to do. Utilizing information stored in the InformationManager and data strcutres of its own. The StrategyManager is able to dictate production and manipulation of units. More...

#include <StrategyManager.h>

Public Member Functions

 StrategyManager (ProtoBotCommander *commanderToAsk)
void onStart ()
std::vector< Action > onFrame (std::vector< ResourceRequest > &resourceRequests)
void onUnitDestroy (BWAPI::Unit)
void onUnitCreate (BWAPI::Unit)
void onUnitComplete (BWAPI::Unit)
void updateUnitProductionGoals ()
void updateUpgradeGoals ()
void planUnitProduction (PossibleRequests &)
void planUpgradeProduction (PossibleRequests &)
void planBuildingProduction (std::vector< ResourceRequest > &resourceRequests, PossibleRequests &)
void finalizeProductionPlan (std::vector< ResourceRequest > &resourceRequests, PossibleRequests &)
const BWEM::Base & getBaseReference (BWAPI::Unit nexus)
void drawGameUnitProduction (UnitProductionGameCounter &unitProduction, int x, int y, bool background=true)
bool shouldGasSteal ()
bool checkAlreadyRequested (BWAPI::UnitType type)

Public Attributes

std::unordered_set< const BWEM::Area * > ProtoBot_Areas
std::unordered_set< const BWEM::ChokePoint * > ProtoBotArea_SquadPlacements
std::unordered_map< const BWEM::ChokePoint *, bool > PositionsFilled
BWAPI::Position startingChoke
BWAPI::Position lastAttackPos
bool isAttackPhase = false
bool drawStrategyDebug = false
std::unordered_set< BWAPI::Position, PositionHash > phantomPositions
ProtoBotCommander * commanderReference
UnitProductionGameCounter unitProductionCounter
BWAPI::Race opponentRace = BWAPI::Races::Unknown

Private Member Functions

bool canAfford (BWAPI::UnitType, std::pair< int, int > resources)
int activeMiners ()
int activeDrillers ()
void checkForOpponentRace ()
bool haveRequiredTech (BWAPI::UnitType)
void updateUpgradesBeingCreated ()
void drawUnitProductionGoals ()
void drawUpgradeProductionGoals ()

Private Attributes

std::vector< int > expansionTimes = { 5, 10, 15, 20, 30 ,40, 50}
size_t minutesPassedIndex = 0
IncompleteBuildingCounter incompleteBuildings
SpenderManager spenderManager
int mineralExcessToExpand = 1000
int frameSinceLastScout = 0
const BWEM::Area * mainArea
ProtoBotProductionCount ProtoBot_createdUnitCount
UpgradesInProduction upgradesInProduction
BWAPI::Unitset resourceDepots
BWAPI::Unitset unitProduction
BWAPI::Unitset upgradeProduction
BWAPI::Unitset cybernetics
BWAPI::Unitset forges
BWAPI::Unitset citadels
BWAPI::Unitset workers
std::set< UnitProductionGoals > unitProductionGoals
std::set< UpgradeProductionGoals > upgradeProductionGoals
bool opponentRaceNotKnown = true
int supplyThreshold = SUPPLY_THRESHOLD_EARLYGAME
const double workerIncomePerFrameMinerals = 0.044
const double workerIncomePerFrameGas = 0.069
double ourIncomePerFrameMinerals = 0.0
double outIncomePerFrameGas = 0.0

Detailed Description

The StrategyManager is way ProtoBot is able to make macro level decisions about what to do. Utilizing information stored in the InformationManager and data strcutres of its own. The StrategyManager is able to dictate production and manipulation of units.

Definition at line 229 of file StrategyManager.h.

Constructor & Destructor Documentation

◆ StrategyManager()

StrategyManager::StrategyManager ( ProtoBotCommander * commanderToAsk)

Definition at line 6 of file StrategyManager.cpp.

6 : commanderReference(commanderReference)
7{
8
9}

Member Function Documentation

◆ activeDrillers()

int StrategyManager::activeDrillers ( )
private

Definition at line 894 of file StrategyManager.cpp.

895{
896 int activeDrillerlWorkerCount = 0;
897
898 for (const BWAPI::Unit worker : workers)
899 {
900 if (worker == nullptr || !worker->exists()) continue;
901
902 const BWAPI::Order order = worker->getOrder();
903
904 if (order == BWAPI::Orders::MoveToGas ||
905 order == BWAPI::Orders::WaitForGas ||
906 order == BWAPI::Orders::HarvestGas ||
907 order == BWAPI::Orders::ReturnGas)
908 {
909 activeDrillerlWorkerCount++;
910 }
911 }
912
913 return activeDrillerlWorkerCount;
914}

◆ activeMiners()

int StrategyManager::activeMiners ( )
private

Definition at line 872 of file StrategyManager.cpp.

873{
874 int activeMineralWorkerCount = 0;
875
876 for (const BWAPI::Unit worker : workers)
877 {
878 if (worker == nullptr || !worker->exists()) continue;
879
880 const BWAPI::Order order = worker->getOrder();
881
882 if (order == BWAPI::Orders::MoveToMinerals ||
883 order == BWAPI::Orders::WaitForMinerals ||
884 order == BWAPI::Orders::MiningMinerals ||
885 order == BWAPI::Orders::ReturnMinerals)
886 {
887 activeMineralWorkerCount++;
888 }
889 }
890
891 return activeMineralWorkerCount;
892}

◆ canAfford()

bool StrategyManager::canAfford ( BWAPI::UnitType building,
std::pair< int, int > resources )
private

Definition at line 1475 of file StrategyManager.cpp.

1476{
1477 if (resources.first - building.mineralPrice() >= 0 && resources.second - building.gasPrice() >= 0) return true;
1478
1479 return false;
1480}

◆ checkAlreadyRequested()

bool StrategyManager::checkAlreadyRequested ( BWAPI::UnitType type)

Definition at line 1470 of file StrategyManager.cpp.

1471{
1472 return !(commanderReference->requestedBuilding(type) || commanderReference->checkUnitIsBeingWarpedIn(type) || commanderReference->checkUnitIsPlanned(type));
1473}

◆ checkForOpponentRace()

void StrategyManager::checkForOpponentRace ( )
private

Definition at line 843 of file StrategyManager.cpp.

844{
845 for (const auto& pair : InformationManager::Instance().getKnownEnemyBuildings()) {
846 if (pair.first->getPlayer() == BWAPI::Broodwar->enemy() &&
847 pair.first->exists() &&
848 pair.first->isVisible() &&
849 pair.second.destroyed == false)
850 {
851 opponentRaceNotKnown = false;
852 opponentRace = pair.first->getType().getRace();
853 //std::cout << "Enemy building found, Opponent Race is " << opponentRace << "\n";
854 break;
855 }
856 }
857
858 if (opponentRaceNotKnown == false) return;
859
860 for (const auto& enemyUnit : InformationManager::Instance().getKnownEnemies()) {
861 if (enemyUnit->getPlayer() == BWAPI::Broodwar->enemy() &&
862 enemyUnit->exists() &&
863 enemyUnit->isVisible())
864 {
865 opponentRaceNotKnown = false;
866 opponentRace = enemyUnit->getType().getRace();
867 //std::cout << "Enemy combat unit found, Opponent Race is " << opponentRace << "\n";
868 }
869 }
870}

◆ drawGameUnitProduction()

void StrategyManager::drawGameUnitProduction ( UnitProductionGameCounter & unitProduction,
int x,
int y,
bool background = true )

Definition at line 746 of file StrategyManager.cpp.

747{
748 if (background) BWAPI::Broodwar->drawBoxScreen(x - 5, y - 5, x + 200, y + 65, BWAPI::Colors::Black, true);
749
750 BWAPI::Broodwar->drawTextScreen(x, y, "%cTotal Combat Units Created (Game)", BWAPI::Text::White);
751 BWAPI::Broodwar->drawTextScreen(x, y + 1, "%c________________________________", BWAPI::Text::White);
752 BWAPI::Broodwar->drawTextScreen(x, y + 10, "%cWorkers = %d", BWAPI::Text::White, unitProduction.worker);
753 BWAPI::Broodwar->drawTextScreen(x, y + 20, "%cZealots = %d", BWAPI::Text::White, unitProduction.zealots);
754 BWAPI::Broodwar->drawTextScreen(x, y + 30, "%cDragoons = %d", BWAPI::Text::White, unitProduction.dragoons);
755 BWAPI::Broodwar->drawTextScreen(x, y + 40, "%cObservers = %d", BWAPI::Text::White, unitProduction.observers);
756 BWAPI::Broodwar->drawTextScreen(x, y + 50, "%cDark Templars = %d", BWAPI::Text::White, unitProduction.dark_templars);
757}

◆ drawUnitProductionGoals()

void StrategyManager::drawUnitProductionGoals ( )
private

Definition at line 796 of file StrategyManager.cpp.

797{
798 int x = 5;
799 int y = 170;
800 BWAPI::Broodwar->drawTextScreen(x, y, "Production Goals:");
801 int index = 0;
802
803 for (const UnitProductionGoals goal : unitProductionGoals)
804 {
805 std::string temp;
806
807 switch (goal)
808 {
809 case SATURATE_WORKERS:
810 temp = "SATURATE_WORKERS";
811 break;
812 case EARLY_ZEALOTS:
813 temp = "EARLY_ZEALOTS";
814 break;
815 case DARK_TEMPLAR_ATTEMPT:
816 temp = "DARK_TEMPLAR_ATTEMPT";
817 break;
818 case OBSERVER_SCOUTS:
819 temp = "OBSERVER_SCOUTS";
820 break;
821 case INFINITE_DRAGOONS:
822 temp = "INFINITE_DRAGOONS";
823 break;
824 case SOMETHING_WENT_WRONG_GO_INFINITE_ZEALOTS:
825 temp = "SOMETHING_WENT_WRONG_GO_INFINITE_ZEALOTS";
826 break;
827 case INVISIBLE_UNIT_DETECTED_SQUADS_NEED_OBSERVERS:
828 temp = "INVISIBLE_UNIT_DETECTED_SQUADS_NEED_OBSERVERS";
829 break;
830 case FLYING_UNIT_DETECTED_NEED_CANNONS:
831 temp = "FLYING_UNIT_DETECHED_NEED_CANNONS";
832 break;
833 default:
834 temp = "UNKNOWN_GOAL";
835 break;
836 }
837
838 BWAPI::Broodwar->drawTextScreen(x, y + ((index + 1) * 10), "%s", temp.c_str());
839 index++;
840 }
841}

◆ drawUpgradeProductionGoals()

void StrategyManager::drawUpgradeProductionGoals ( )
private

Definition at line 759 of file StrategyManager.cpp.

760{
761 int x = 5;
762 int y = 230;
763 BWAPI::Broodwar->drawTextScreen(x, y, "Upgarde Production Goals:");
764 int index = 0;
765 for (const UpgradeProductionGoals goal : upgradeProductionGoals)
766 {
767 std::string temp;
768
769 switch (goal)
770 {
771 case RESEARCH_SINGULARITY_CHARGE:
772 temp = "RESEARCH_SINGULARITY_CHARGE";
773 break;
774 case RESEARCH_GROUND_WEAPONS:
775 temp = "RESEARCH_GROUND_WEAPONS";
776 break;
777 case RESEARCH_GROUND_ARMOR:
778 temp = "RESEARCH_GROUND_ARMOR";
779 break;
780 case RESEARCH_PLASMA_SHIELDS:
781 temp = "RESEARCH_PLASMA_SHIELDS";
782 break;
783 case SOMETHING_WENT_WRONG_RESEARCH_LEG_ENHANCEMENTS:
784 temp = "SOMETHING_WENT_WRONG_RESEARCH_LEG_ENHANCEMENTS";
785 break;
786 default:
787 temp = "UNKNOWN_GOAL";
788 break;
789 }
790
791 BWAPI::Broodwar->drawTextScreen(x, y + ((index + 1) * 10), "%s", temp.c_str());
792 index++;
793 }
794}

◆ finalizeProductionPlan()

void StrategyManager::finalizeProductionPlan ( std::vector< ResourceRequest > & resourceRequests,
PossibleRequests & possibleRequestList )

Definition at line 1451 of file StrategyManager.cpp.

1452{
1453 for (const PossibleUnitRequest& unitRequest : possibleRequestList.units)
1454 {
1455 commanderReference->requestUnit(unitRequest.unit, unitRequest.trainer, false);
1456 }
1457
1458 for (const PossibleBuildingRequest& unitRequest : possibleRequestList.supplyBuildings)
1459 {
1460 commanderReference->requestBuilding(unitRequest.building, false, false, false, unitRequest.nexusPosition, unitRequest.base);
1461 }
1462
1463 for (const PossibleUpgradeRequest& unitRequest : possibleRequestList.upgrades)
1464 {
1465 commanderReference->requestUpgrade(unitRequest.trainer, unitRequest.upgrade, false);
1466 }
1467}

◆ getBaseReference()

const BWEM::Base & StrategyManager::getBaseReference ( BWAPI::Unit nexus)

Definition at line 1438 of file StrategyManager.cpp.

1439{
1440 for (const BWEM::Area& area : theMap.Areas())
1441 {
1442 for (const BWEM::Base& base : area.Bases())
1443 {
1444 if (base.Location() == nexus->getTilePosition()) return base;
1445 }
1446 }
1447
1448 std::cout << "WARNING BASE NOT FOUND\n";
1449}

◆ haveRequiredTech()

bool StrategyManager::haveRequiredTech ( BWAPI::UnitType unit)
private

Definition at line 1488 of file StrategyManager.cpp.

1489{
1490 const FriendlyBuildingCounter ProtoBot_Buildings = InformationManager::Instance().getFriendlyBuildingCounter();
1491 const std::map<BWAPI::UnitType, int> requiredBuildings = unit.requiredUnits();
1492
1493 bool haveRequiredTech = true;
1494
1495 for (const std::pair<const BWAPI::UnitType, int> requiredBuilding : requiredBuildings)
1496 {
1497 switch (requiredBuilding.first)
1498 {
1499 case BWAPI::UnitTypes::Protoss_Gateway:
1500 if (ProtoBot_Buildings.gateway < requiredBuilding.second) haveRequiredTech = false;
1501 break;
1502 case BWAPI::UnitTypes::Protoss_Forge:
1503 if (ProtoBot_Buildings.forge < requiredBuilding.second) haveRequiredTech = false;
1504 break;
1505 case BWAPI::UnitTypes::Protoss_Cybernetics_Core:
1506 if (ProtoBot_Buildings.cyberneticsCore < requiredBuilding.second) haveRequiredTech = false;
1507 break;
1508 case BWAPI::UnitTypes::Protoss_Robotics_Facility:
1509 if (ProtoBot_Buildings.roboticsFacility < requiredBuilding.second) haveRequiredTech = false;
1510 break;
1511 case BWAPI::UnitTypes::Protoss_Citadel_of_Adun:
1512 if (ProtoBot_Buildings.citadelOfAdun < requiredBuilding.second) haveRequiredTech = false;
1513 break;
1514 case BWAPI::UnitTypes::Protoss_Templar_Archives:
1515 if (ProtoBot_Buildings.templarArchives < requiredBuilding.second) haveRequiredTech = false;
1516 break;
1517 case BWAPI::UnitTypes::Protoss_Stargate:
1518 if (ProtoBot_Buildings.stargate < requiredBuilding.second) haveRequiredTech = false;
1519 break;
1520 case BWAPI::UnitTypes::Protoss_Observatory:
1521 if (ProtoBot_Buildings.observatory < requiredBuilding.second) haveRequiredTech = false;
1522 break;
1523 case BWAPI::UnitTypes::Protoss_Robotics_Support_Bay:
1524 if (ProtoBot_Buildings.roboticsSupportBay < requiredBuilding.second) haveRequiredTech = false;
1525 break;
1526 case BWAPI::UnitTypes::Protoss_Fleet_Beacon:
1527 if (ProtoBot_Buildings.fleetBeacon < requiredBuilding.second) haveRequiredTech = false;
1528 break;
1529 case BWAPI::UnitTypes::Protoss_Arbiter_Tribunal:
1530 if (ProtoBot_Buildings.arbiterTribunal < requiredBuilding.second) haveRequiredTech = false;
1531 break;
1532 default:
1533 break;
1534 }
1535 }
1536
1537 return haveRequiredTech;
1538}

◆ onFrame()

std::vector< Action > StrategyManager::onFrame ( std::vector< ResourceRequest > & resourceRequests)

Definition at line 90 of file StrategyManager.cpp.

91{
92 if (opponentRaceNotKnown == true) checkForOpponentRace();
93
94 std::vector<Action> actionsToReturn;
95 PossibleRequests unitsWeCanCreate;
96
97 //Building logic
98 const bool buildOrderCompleted = commanderReference->buildOrderCompleted();
99
100 //Might need to move this.
101 spenderManager.OnFrame(resourceRequests);
102
103 updateUnitProductionGoals();
104 updateUpgradeGoals();
105
106 planUnitProduction(unitsWeCanCreate);
107 planUpgradeProduction(unitsWeCanCreate);
108
109 //Only plan buildings once we are out of a Build Order.
110 planBuildingProduction(resourceRequests, unitsWeCanCreate);
111
112 finalizeProductionPlan(resourceRequests, unitsWeCanCreate);
113
114 if (drawStrategyDebug)
115 {
116 drawUnitProductionGoals();
117 drawUpgradeProductionGoals();
118 }
119
120
121 //Debug: Drawing choke points to get an idea on where the BWEM can have us position squads
122 /*for (const BWEM::ChokePoint* choke : ProtoBotArea_SquadPlacements)
123 {
124 if (PositionsFilled[choke])
125 {
126 BWAPI::Broodwar->drawCircleMap(BWAPI::Position(choke->Center()), 10, BWAPI::Broodwar->self()->getColor(), true);
127 }
128 else
129 {
130 BWAPI::Broodwar->drawCircleMap(BWAPI::Position(choke->Center()), 10, BWAPI::Colors::Red, true);
131 }
132
133 }*/
134
135 //In-Game Time book keeping
136 const int frame = BWAPI::Broodwar->getFrameCount();
137 const int totalSeconds = frame / FRAMES_PER_SECOND;
138 const int seconds = totalSeconds % 60;
139 const int minutes = totalSeconds / 60;
140
141 //Estimate income
142 ourIncomePerFrameMinerals = workerIncomePerFrameMinerals * activeMiners();
143 outIncomePerFrameGas = workerIncomePerFrameGas * activeDrillers();
144
145 //ProtoBot Squads
146 std::vector<Squad*> Protobot_IdleSquads = commanderReference->combatManager.IdleSquads;
147 std::vector<Squad*> Protobot_Squads = commanderReference->combatManager.Squads;
148
149 //Supply threshold is how close we want to get to the supply cap before building a pylon to cover supply costs.
150 int supplyThreshold = SUPPLY_THRESHOLD_EARLYGAME;
151
152 if ((seconds / 60) >= MIDGAME_TIME && (seconds / 60) < LATEGAME_TIME)
153 {
154 supplyThreshold = SUPPLY_THRESHOLD_MIDGAME;
155 }
156 else if ((seconds / 60) >= LATEGAME_TIME)
157 {
158 supplyThreshold = SUPPLY_THRESHOLD_LATEGAME;
159 }
160
161 int numberFullSquads = 0;
162
163 for (const Squad* squad : Protobot_Squads)
164 {
165 if (squad->info.units.size() == MAX_SQUAD_SIZE) numberFullSquads++;
166 }
167
168 //Get Enemy Building information.
169 const std::map<BWAPI::Unit, EnemyBuildingInfo>& enemyBuildingInfo = InformationManager::Instance().getKnownEnemyBuildings();
170
171 std::vector<BWAPI::Position> enemyBaselocations;
172 for (const auto [unit, building] : enemyBuildingInfo)
173 {
174 if (building.type.isResourceDepot())
175 {
176 //BWAPI::Broodwar->drawCircleMap(building.lastKnownPosition, 5, BWAPI::Colors::Red, true);
177 enemyBaselocations.push_back(building.lastKnownPosition);
178 }
179 }
180
181#pragma region Scout
182
183 if (buildOrderCompleted || (BWAPI::Broodwar->self()->supplyUsed() / 2) > 15)
184 {
185 //change this to frames since last info gained
186 if (frame - frameSinceLastScout >= 24 * 20) {
187 frameSinceLastScout = frame;
188
189 Action scout;
190 scout.type = Action::ACTION_SCOUT;
191 actionsToReturn.push_back(scout);
192 }
193 }
194
195#pragma endregion
196
197#pragma region EnemyCheck
198 BWAPI::Unitset unitsOnVisison = BWAPI::Broodwar->enemy()->getUnits();
199 BWAPI::Unit unitToAttack = nullptr;
200 BWAPI::Position StartingLocation = BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation());
201 bool enemyNearFriendlyArea = false;
202 int closest = INT_MAX;
203 for (const BWAPI::Unit unit : unitsOnVisison)
204 {
205 if (!unit->exists() || unit == nullptr) {
206 continue;
207 }
208
209 if (unit->isCloaked()) {
210 continue;
211 }
212
213 const bool isPhantom = phantomPositions.find(unit->getPosition()) != phantomPositions.end();
214 if (isPhantom) {
215 continue;
216 }
217
218 const int dist = unit->getPosition().getApproxDistance(StartingLocation);
219 if (dist < closest) {
220 closest = dist;
221 unitToAttack = unit;
222 }
223 }
224
225 if (unitToAttack != nullptr) {
226 const BWEM::Area* enemyAreaLocation = theMap.GetNearestArea(unitToAttack->getTilePosition());
227 for (const BWEM::Area* area : ProtoBot_Areas)
228 {
229 if (enemyAreaLocation == area) {
230 enemyNearFriendlyArea = true;
231 break;
232 }
233 }
234 }
235#pragma endregion
236
237#pragma region Attack
238 // If we have more than two full squads attack.
239 const int totalSupply = BWAPI::Broodwar->self()->supplyTotal() / 2;
240 const int supplyUsed = BWAPI::Broodwar->self()->supplyUsed() / 2;
241 const int numUnits = commanderReference->combatManager.allUnits.size();
242 constexpr int targetCount = NUM_SQUADS_TO_ATTACK * MAX_SQUAD_SIZE;
243
244 //Add timer on supply cap to make us attack so we dont waste time.
245 if (supplyUsed >= MINIMUM_SUPPLY_TO_ALL_IN || numUnits > targetCount || (totalSupply == MAX_SUPPLY && supplyUsed + 1 == MAX_SUPPLY))
246 {
247 if (numUnits > (int) floor(targetCount / 3)) {
248 isAttackPhase = true;
249 BWAPI::Position attackPos = BWAPI::Positions::Invalid;
250
251 if (unitToAttack){
252 const bool isPhantom = phantomPositions.find(unitToAttack->getPosition()) != phantomPositions.end();
253 // Every 60 frames, checks if the position from unitToAttack is actually existing (fixing phantom position bug)
254 if (BWAPI::Broodwar->getFrameCount() % 60 == 0
255 && !isPhantom
256 && BWAPI::Broodwar->isVisible(BWAPI::TilePosition(unitToAttack->getPosition()))
257 && BWAPI::Broodwar->getUnitsOnTile(BWAPI::TilePosition(unitToAttack->getPosition()), BWAPI::Filter::IsEnemy).empty()){
258
259 phantomPositions.insert(unitToAttack->getPosition());
260 }
261 else{
262 attackPos = unitToAttack->getPosition();
263 }
264 }
265
266 // If no enemy in vision found, attack closest unit or building from trackedEnemies
267 if (attackPos == BWAPI::Positions::Invalid){
268 int closestDist = INT_MAX;
269 for (const auto& [_, enemyInfo] : InformationManager::Instance().getTrackedEnemies()) {
270 if (enemyInfo.destroyed) {
271 continue;
272 }
273
274 if (enemyInfo.type.hasPermanentCloak()) {
275 continue;
276 }
277
278 // Every 60 frames, checks if the position from unitToAttack is actually existing (fixing phantom position bug)
279 const bool isPhantom = phantomPositions.find(enemyInfo.lastSeenPos) != phantomPositions.end();
280
281 if (isPhantom) {
282 continue;
283 }
284
285 if (BWAPI::Broodwar->getFrameCount() % 60 == 0
286 && !isPhantom
287 && BWAPI::Broodwar->isVisible(BWAPI::TilePosition(enemyInfo.lastSeenPos))
288 && BWAPI::Broodwar->getUnitsOnTile(BWAPI::TilePosition(enemyInfo.lastSeenPos), BWAPI::Filter::IsEnemy).empty()) {
289
290 phantomPositions.insert(enemyInfo.lastSeenPos);
291 continue;
292 }
293
294 const int dist = StartingLocation.getApproxDistance(enemyInfo.lastSeenPos);
295 if (dist < closestDist) {
296 closestDist = dist;
297 attackPos = enemyInfo.lastSeenPos;
298 }
299 }
300 }
301
302 // If all other attack position methods failed, attack an enemy base
303 if (attackPos == BWAPI::Positions::Invalid && enemyBaselocations.size() > 0) {
304 attackPos = enemyBaselocations.at(enemyBaselocations.size() - 1);
305 }
306
307 // Send action only if theres a new, valid attack position
308 if (attackPos != BWAPI::Positions::Invalid && attackPos != lastAttackPos) {
309 Action attack;
310 attack.type = Action::ACTION_ATTACK;
311 attack.attackPosition = attackPos;
312 actionsToReturn.push_back(attack);
313
314 lastAttackPos = attackPos;
315 }
316 }
317 else {
318 lastAttackPos = BWAPI::Positions::Invalid;
319 isAttackPhase = false;
320 }
321 }
322#pragma endregion
323
324#pragma region Defend
325 if (!isAttackPhase) {
326 if (unitToAttack != nullptr && unitToAttack->exists() && enemyNearFriendlyArea) {
327 int closestDist = 0;
328
329 Action attack;
330 attack.type = Action::ACTION_REINFORCE;
331 attack.reinforcePosition = unitToAttack->getPosition();
332 actionsToReturn.push_back(attack);
333 }
334
335 if (Protobot_IdleSquads.size() != 0)
336 {
337 int distanceToClosestChoke = INT_MAX;
338 BWAPI::WalkPosition areaToDefend = BWAPI::WalkPositions::Invalid;
339 const BWEM::ChokePoint* chokeToDefend;
340
341 for (const BWEM::ChokePoint* placement : ProtoBotArea_SquadPlacements)
342 {
343 if (PositionsFilled[placement] == false)
344 {
345 int distanceToChoke = 0;
346 const BWEM::CPPath pathToExpansion = theMap.GetPath(BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation()), BWAPI::Position(placement->Center()), &distanceToChoke);
347
348 if (distanceToChoke == -1) continue;
349
350 if (distanceToChoke < distanceToClosestChoke)
351 {
352 distanceToClosestChoke = distanceToChoke;
353 areaToDefend = placement->Center();
354 chokeToDefend = placement;
355 }
356 }
357 }
358
359 if (areaToDefend != BWAPI::WalkPositions::Invalid)
360 {
361 Action defend;
362 defend.type = Action::ACTION_DEFEND;
363 defend.defendPosition = BWAPI::Position(areaToDefend);
364 actionsToReturn.push_back(defend);
365 PositionsFilled[chokeToDefend] = true;
366 }
367 }
368 }
369#pragma endregion
370
371 return actionsToReturn;
372}

◆ onStart()

void StrategyManager::onStart ( )

Definition at line 11 of file StrategyManager.cpp.

12{
13 //std::cout << "Strategy Manager Initialized" << '\n';
14
15 //Reset Static Variables
16 minutesPassedIndex = 0;
17 frameSinceLastScout = 0;
18 mineralExcessToExpand = 1000;
19 ProtoBot_Areas.clear();
20 ProtoBotArea_SquadPlacements.clear();
21 PositionsFilled.clear();
22
23 //For squad placments we will cover areas we own and have the wait at choke points of psuedo areas we "own".
24 const BWAPI::TilePosition ProtoBot_MainBase = BWAPI::Broodwar->self()->getStartLocation();
25 mainArea = theMap.GetNearestArea(ProtoBot_MainBase);
26 ProtoBot_Areas.insert(mainArea);
27
28 for (const BWEM::Area* neighbor : mainArea->AccessibleNeighbours())
29 {
30 if (neighbor == nullptr) continue;
31
32 ProtoBot_Areas.insert(neighbor);
33
34 for (const BWEM::Area* neighbors_neighbor : neighbor->AccessibleNeighbours())
35 {
36 ProtoBot_Areas.insert(neighbors_neighbor);
37 }
38 }
39
40 for (const BWEM::Area* area : ProtoBot_Areas)
41 {
42 if (area == nullptr) continue;
43
44 for (const BWEM::ChokePoint* choke : area->ChokePoints())
45 {
46 if (choke == nullptr) continue;
47
48 const std::pair<const BWEM::Area*, const BWEM::Area*> areas = choke->GetAreas();
49
50 //Ignore choke that is on ramp to prevent builders from being able to construct.
51 if (areas.first == mainArea || areas.second == mainArea || choke->Blocked() || choke->BlockingNeutral()) continue;
52
53 ProtoBotArea_SquadPlacements.insert(choke);
54 PositionsFilled.insert({ choke, false });
55 }
56 }
57
58 spenderManager.onStart();
59
60 //Reset counters
61 const ProtoBotProductionCount newProtoBot_createdUnitCount;
62 ProtoBot_createdUnitCount = newProtoBot_createdUnitCount;
63 const UpgradesInProduction newupgradesInProduction;
64 upgradesInProduction = newupgradesInProduction;
65 const UnitProductionGameCounter newunitProductionCounter;
66 unitProductionCounter = newunitProductionCounter;
67
68 unitProduction.clear();
69 resourceDepots.clear();
70 upgradeProduction.clear();
71 cybernetics.clear();
72 forges.clear();
73 citadels.clear();
74 workers.clear();
75
76 std::set<UnitProductionGoals> unitProductionGoals;
77 std::set<UpgradeProductionGoals> upgradeProductionGoals;
78
79
80 //Reset race just in case
81 opponentRace = BWAPI::Races::Unknown;
82
83 //Check for opponent race and unit counts;
84 opponentRace = BWAPI::Broodwar->enemy()->getRace();
85 std::cout << "Unit Race is " << opponentRace << "\n";
86
87 if (opponentRace != BWAPI::Races::Unknown) opponentRaceNotKnown = false;
88}

◆ onUnitComplete()

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

Definition at line 687 of file StrategyManager.cpp.

688{
689 if (unit->getPlayer() != BWAPI::Broodwar->self()) return;
690
691 switch (unit->getType())
692 {
693 case BWAPI::UnitTypes::Protoss_Arbiter_Tribunal:
694 incompleteBuildings.arbiterTribunal--;
695 break;
696 case BWAPI::UnitTypes::Protoss_Assimilator:
697 incompleteBuildings.assimilator--;
698 break;
699 case BWAPI::UnitTypes::Protoss_Citadel_of_Adun:
700 incompleteBuildings.citadelOfAdun--;
701 break;
702 case BWAPI::UnitTypes::Protoss_Cybernetics_Core:
703 incompleteBuildings.cyberneticsCore--;
704 break;
705 case BWAPI::UnitTypes::Protoss_Fleet_Beacon:
706 incompleteBuildings.fleetBeacon--;
707 break;
708 case BWAPI::UnitTypes::Protoss_Forge:
709 incompleteBuildings.forge--;
710 break;
711 case BWAPI::UnitTypes::Protoss_Gateway:
712 incompleteBuildings.gateway--;
713 break;
714 case BWAPI::UnitTypes::Protoss_Nexus:
715 incompleteBuildings.nexus--;
716 break;
717 case BWAPI::UnitTypes::Protoss_Observatory:
718 incompleteBuildings.observatory--;
719 break;
720 case BWAPI::UnitTypes::Protoss_Photon_Cannon:
721 incompleteBuildings.photonCannon--;
722 break;
723 case BWAPI::UnitTypes::Protoss_Pylon:
724 incompleteBuildings.pylon--;
725 break;
726 case BWAPI::UnitTypes::Protoss_Robotics_Facility:
727 incompleteBuildings.roboticsFacility--;
728 break;
729 case BWAPI::UnitTypes::Protoss_Robotics_Support_Bay:
730 incompleteBuildings.roboticsSupportBay--;
731 break;
732 case BWAPI::UnitTypes::Protoss_Shield_Battery:
733 incompleteBuildings.shieldBattery--;
734 break;
735 case BWAPI::UnitTypes::Protoss_Stargate:
736 incompleteBuildings.stargate--;
737 break;
738 case BWAPI::UnitTypes::Protoss_Templar_Archives:
739 incompleteBuildings.templarArchives--;
740 break;
741 default:
742 break;
743 }
744}

◆ onUnitCreate()

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

Definition at line 542 of file StrategyManager.cpp.

543{
544 if (unit->getPlayer() != BWAPI::Broodwar->self()) return;
545
546 switch (unit->getType())
547 {
548 case BWAPI::UnitTypes::Protoss_Probe:
549 ProtoBot_createdUnitCount.created_workers++;
550 unitProductionCounter.worker++;
551 break;
552 case BWAPI::UnitTypes::Protoss_Zealot:
553 ProtoBot_createdUnitCount.created_zealots++;
554 unitProductionCounter.zealots++;
555 break;
556 case BWAPI::UnitTypes::Protoss_Dragoon:
557 ProtoBot_createdUnitCount.created_dragoons++;
558 unitProductionCounter.dragoons++;
559 break;
560 case BWAPI::UnitTypes::Protoss_Dark_Templar:
561 ProtoBot_createdUnitCount.created_dark_templars++;
562 unitProductionCounter.dark_templars++;
563 break;
564 case BWAPI::UnitTypes::Protoss_Observer:
565 ProtoBot_createdUnitCount.created_observers++;
566 unitProductionCounter.observers++;
567 break;
568 case BWAPI::UnitTypes::Protoss_Arbiter_Tribunal:
569 incompleteBuildings.arbiterTribunal++;
570 break;
571 case BWAPI::UnitTypes::Protoss_Assimilator:
572 incompleteBuildings.assimilator++;
573 break;
574 case BWAPI::UnitTypes::Protoss_Citadel_of_Adun:
575 incompleteBuildings.citadelOfAdun++;
576 ProtoBot_createdUnitCount.created_citadel++;
577 break;
578 case BWAPI::UnitTypes::Protoss_Cybernetics_Core:
579 incompleteBuildings.cyberneticsCore++;
580 ProtoBot_createdUnitCount.created_cybernetics++;
581 break;
582 case BWAPI::UnitTypes::Protoss_Fleet_Beacon:
583 incompleteBuildings.fleetBeacon++;
584 break;
585 case BWAPI::UnitTypes::Protoss_Forge:
586 incompleteBuildings.forge++;
587 ProtoBot_createdUnitCount.created_forge++;
588 break;
589 case BWAPI::UnitTypes::Protoss_Gateway:
590 incompleteBuildings.gateway++;
591 ProtoBot_createdUnitCount.created_gateway++;
592 break;
593 case BWAPI::UnitTypes::Protoss_Nexus:
594 incompleteBuildings.nexus++;
595 ProtoBot_createdUnitCount.created_nexus++;
596 break;
597 case BWAPI::UnitTypes::Protoss_Observatory:
598 incompleteBuildings.observatory++;
599 ProtoBot_createdUnitCount.created_observatory++;
600 break;
601 case BWAPI::UnitTypes::Protoss_Photon_Cannon:
602 incompleteBuildings.photonCannon++;
603 ProtoBot_createdUnitCount.created_photonCannons++;
604 break;
605 case BWAPI::UnitTypes::Protoss_Pylon:
606 incompleteBuildings.pylon++;
607 ProtoBot_createdUnitCount.created_pylons++;
608 break;
609 case BWAPI::UnitTypes::Protoss_Robotics_Facility:
610 incompleteBuildings.roboticsFacility++;
611 ProtoBot_createdUnitCount.created_roboticsFacility++;
612 break;
613 case BWAPI::UnitTypes::Protoss_Robotics_Support_Bay:
614 incompleteBuildings.roboticsSupportBay++;
615 break;
616 case BWAPI::UnitTypes::Protoss_Shield_Battery:
617 incompleteBuildings.shieldBattery++;
618 break;
619 case BWAPI::UnitTypes::Protoss_Stargate:
620 incompleteBuildings.stargate++;
621 break;
622 case BWAPI::UnitTypes::Protoss_Templar_Archives:
623 incompleteBuildings.templarArchives++;
624 ProtoBot_createdUnitCount.created_templarArchives++;
625 break;
626 default:
627 break;
628 }
629
630 if (unit->getType().isResourceDepot())
631 {
632 //Add new area to areas we occupy.
633 const BWAPI::Position ProtoBot_Base = unit->getPosition();
634 const BWEM::Area* newArea = theMap.GetNearestArea(BWAPI::TilePosition(ProtoBot_Base));
635 ProtoBot_Areas.insert(newArea);
636
637 for (const BWEM::Area* neighbor : newArea->AccessibleNeighbours())
638 {
639 ProtoBot_Areas.insert(neighbor);
640
641 for (const BWEM::Area* neighbors_neighbor : neighbor->AccessibleNeighbours())
642 {
643 ProtoBot_Areas.insert(neighbors_neighbor);
644 }
645 }
646
647 //Add new choke point locations (Temp solution for now).
648 for (const BWEM::Area* area : ProtoBot_Areas)
649 {
650 for (const BWEM::ChokePoint* choke : area->ChokePoints())
651 {
652 const std::pair<const BWEM::Area*, const BWEM::Area*> areas = choke->GetAreas();
653
654 //Ignore choke that is on ramp to prevent builders from being able to construct.
655 if (areas.first == mainArea || areas.second == mainArea || choke->Blocked() || choke->BlockingNeutral()) continue;
656
657 ProtoBotArea_SquadPlacements.insert(choke);
658 PositionsFilled.insert({ choke, false });
659 }
660 }
661
662 resourceDepots.insert(unit);
663 }
664
665 if (unit->getType().isWorker()) workers.insert(unit);
666
667 if (unit->getType() == BWAPI::UnitTypes::Protoss_Gateway ||
668 unit->getType() == BWAPI::UnitTypes::Protoss_Robotics_Facility)
669 {
670 unitProduction.insert(unit);
671 }
672
673 if (unit->getType() == BWAPI::UnitTypes::Protoss_Forge ||
674 unit->getType() == BWAPI::UnitTypes::Protoss_Cybernetics_Core ||
675 unit->getType() == BWAPI::UnitTypes::Protoss_Citadel_of_Adun)
676 {
677 upgradeProduction.insert(unit);
678 }
679
680 if (unit->getType() == BWAPI::UnitTypes::Protoss_Forge) forges.insert(unit);
681
682 if (unit->getType() == BWAPI::UnitTypes::Protoss_Cybernetics_Core) cybernetics.insert(unit);
683
684 if (unit->getType() == BWAPI::UnitTypes::Protoss_Citadel_of_Adun) citadels.insert(unit);
685}

◆ onUnitDestroy()

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

Definition at line 374 of file StrategyManager.cpp.

375{
376 if (unit->getPlayer() != BWAPI::Broodwar->self()) return;
377
378 //std::cout << unit->getType() << " was destroyed and was " << (unit->isCompleted() ? "completed\n" : "not completed\n");
379
380 //Update Units counts
381 switch (unit->getType())
382 {
383 case BWAPI::UnitTypes::Protoss_Probe:
384 ProtoBot_createdUnitCount.created_workers--;
385 break;
386 case BWAPI::UnitTypes::Protoss_Zealot:
387 ProtoBot_createdUnitCount.created_zealots--;
388 break;
389 case BWAPI::UnitTypes::Protoss_Dragoon:
390 ProtoBot_createdUnitCount.created_dragoons--;
391 break;
392 case BWAPI::UnitTypes::Protoss_Dark_Templar:
393 ProtoBot_createdUnitCount.created_dark_templars--;
394 break;
395 case BWAPI::UnitTypes::Protoss_Observer:
396 ProtoBot_createdUnitCount.created_observers--;
397 break;
398 case BWAPI::UnitTypes::Protoss_Arbiter_Tribunal:
399 incompleteBuildings.arbiterTribunal--;
400 break;
401 case BWAPI::UnitTypes::Protoss_Assimilator:
402 incompleteBuildings.assimilator--;
403 break;
404 case BWAPI::UnitTypes::Protoss_Citadel_of_Adun:
405 incompleteBuildings.citadelOfAdun--;
406 ProtoBot_createdUnitCount.created_citadel--;
407 break;
408 case BWAPI::UnitTypes::Protoss_Cybernetics_Core:
409 incompleteBuildings.cyberneticsCore--;
410 ProtoBot_createdUnitCount.created_cybernetics--;
411 break;
412 case BWAPI::UnitTypes::Protoss_Fleet_Beacon:
413 incompleteBuildings.fleetBeacon--;
414 break;
415 case BWAPI::UnitTypes::Protoss_Forge:
416 incompleteBuildings.forge--;
417 ProtoBot_createdUnitCount.created_forge--;
418 break;
419 case BWAPI::UnitTypes::Protoss_Gateway:
420 incompleteBuildings.gateway--;
421 ProtoBot_createdUnitCount.created_gateway--;
422 break;
423 case BWAPI::UnitTypes::Protoss_Nexus:
424 incompleteBuildings.nexus--;
425 ProtoBot_createdUnitCount.created_nexus--;
426 break;
427 case BWAPI::UnitTypes::Protoss_Observatory:
428 incompleteBuildings.observatory--;
429 ProtoBot_createdUnitCount.created_observatory--;
430 break;
431 case BWAPI::UnitTypes::Protoss_Photon_Cannon:
432 incompleteBuildings.photonCannon--;
433 ProtoBot_createdUnitCount.created_photonCannons--;
434 break;
435 case BWAPI::UnitTypes::Protoss_Pylon:
436 incompleteBuildings.pylon--;
437 ProtoBot_createdUnitCount.created_pylons--;
438 break;
439 case BWAPI::UnitTypes::Protoss_Robotics_Facility:
440 incompleteBuildings.roboticsFacility--;
441 ProtoBot_createdUnitCount.created_roboticsFacility--;
442 break;
443 case BWAPI::UnitTypes::Protoss_Robotics_Support_Bay:
444 incompleteBuildings.roboticsSupportBay--;
445 break;
446 case BWAPI::UnitTypes::Protoss_Shield_Battery:
447 incompleteBuildings.shieldBattery--;
448 break;
449 case BWAPI::UnitTypes::Protoss_Stargate:
450 incompleteBuildings.stargate--;
451 break;
452 case BWAPI::UnitTypes::Protoss_Templar_Archives:
453 incompleteBuildings.templarArchives--;
454 ProtoBot_createdUnitCount.created_templarArchives--;
455 break;
456 default:
457 break;
458 }
459
460 if (unit->getType().isResourceDepot())
461 {
462 std::unordered_set<const BWEM::Area*> areasToRemove;
463 std::unordered_set<const BWEM::Area*> areasStillOwned;
464
465 const BWAPI::Position ProtoBot_DestroyedBase = unit->getPosition();
466 const BWEM::Area* oldArea = theMap.GetNearestArea(BWAPI::TilePosition(ProtoBot_DestroyedBase));
467
468 //Find potential areas we need to remove
469 areasToRemove.insert(oldArea);
470 for (const BWEM::Area* neighbor : oldArea->AccessibleNeighbours())
471 {
472 areasToRemove.insert(neighbor);
473
474 for (const BWEM::Area* neighbors_neighbor : neighbor->AccessibleNeighbours())
475 {
476 areasToRemove.insert(neighbors_neighbor);
477 }
478 }
479
480 //Get the areas we still own.
481 ProtoBot_Areas.erase(oldArea);
482 for (const BWEM::Area* area : ProtoBot_Areas)
483 {
484 areasStillOwned.insert(area);
485
486 for (const BWEM::Area* neighbor : area->AccessibleNeighbours())
487 {
488 areasStillOwned.insert(neighbor);
489
490 for (const BWEM::Area* neighbors_neighbor : neighbor->AccessibleNeighbours())
491 {
492 areasStillOwned.insert(neighbors_neighbor);
493 }
494 }
495 }
496
497 //Do a remove elements that we still dont own and are in the areasToRemove set.
498 for (const BWEM::Area* area : areasToRemove)
499 {
500 if (areasStillOwned.find(area) == areasStillOwned.end()) ProtoBot_Areas.erase(area);
501 }
502
503 //Update choke points.
504 for (const BWEM::Area* area : ProtoBot_Areas)
505 {
506 for (const BWEM::ChokePoint* choke : area->ChokePoints())
507 {
508 const std::pair<const BWEM::Area*, const BWEM::Area*> areas = choke->GetAreas();
509
510 //Ignore choke that is on ramp to prevent builders from being able to construct.
511 if (areas.first == mainArea || areas.second == mainArea || choke->Blocked() || choke->BlockingNeutral()) continue;
512
513 ProtoBotArea_SquadPlacements.insert(choke);
514 }
515 }
516
517 resourceDepots.erase(unit);
518 }
519
520 if (unit->getType().isWorker()) workers.erase(unit);
521
522 if (unit->getType() == BWAPI::UnitTypes::Protoss_Gateway ||
523 unit->getType() == BWAPI::UnitTypes::Protoss_Robotics_Facility)
524 {
525 unitProduction.erase(unit);
526 }
527
528 if (unit->getType() == BWAPI::UnitTypes::Protoss_Forge ||
529 unit->getType() == BWAPI::UnitTypes::Protoss_Cybernetics_Core ||
530 unit->getType() == BWAPI::UnitTypes::Protoss_Citadel_of_Adun)
531 {
532 upgradeProduction.erase(unit);
533 }
534
535 if (unit->getType() == BWAPI::UnitTypes::Protoss_Forge) forges.erase(unit);
536
537 if (unit->getType() == BWAPI::UnitTypes::Protoss_Cybernetics_Core) cybernetics.erase(unit);
538
539 if (unit->getType() == BWAPI::UnitTypes::Protoss_Citadel_of_Adun) citadels.erase(unit);
540}

◆ planBuildingProduction()

void StrategyManager::planBuildingProduction ( std::vector< ResourceRequest > & resourceRequests,
PossibleRequests & possibleRequestList )

Definition at line 1312 of file StrategyManager.cpp.

1313{
1314 //ProtoBot Information
1315 const FriendlyBuildingCounter ProtoBot_buildings = InformationManager::Instance().getFriendlyBuildingCounter();
1316 const FriendlyUnitCounter ProtoBot_units = InformationManager::Instance().getFriendlyUnitCounter();
1317 const FriendlyUpgradeCounter ProtoBot_upgrade = InformationManager::Instance().getFriendlyUpgradeCounter();
1318 const FriendlyTechCounter ProtoBot_tech = InformationManager::Instance().getFriendlyTechCounter();
1319 BWAPI::Unitset incompleteBuildings = commanderReference->buildManager.getBuildings();
1320 const ProtoBotRequestCounter& request_count = commanderReference->requestCounter;
1321 std::vector<NexusEconomy> nexusEconomies = commanderReference->getNexusEconomies();
1322
1323 const int frame = BWAPI::Broodwar->getFrameCount();
1324 const int totalSeconds = frame / FRAMES_PER_SECOND;
1325 const int seconds = totalSeconds % 60;
1326 const int minutes = totalSeconds / 60;
1327
1328 //Building logic
1329 const bool buildOrderCompleted = commanderReference->buildOrderCompleted();
1330
1331 if (!(minutesPassedIndex == expansionTimes.size()) && expansionTimes.at(minutesPassedIndex) <= minutes && !buildOrderCompleted)
1332 {
1333 //std::cout << expansionTimes[minutesPassedIndex] << " minutes have passed (while in build order)\n";
1334 minutesPassedIndex++;
1335 }
1336
1337 //Better solution would be supply at a rate of roughly (#nexus / probe build time + #gateways / zealot build time + ...)
1338 //This is not really an acurrate way to get supply use projection but it "works"
1339 const int dynamicSupplyThreshold = supplyThreshold + (ProtoBot_buildings.gateway * 2) + (ProtoBot_buildings.nexus * 1);
1340
1341 //Pylon requests: Once build order is completed, run this check to make sure we have enough supply to do things.
1342 if (spenderManager.plannedSupply(resourceRequests, incompleteBuildings) <= dynamicSupplyThreshold && ((BWAPI::Broodwar->self()->supplyTotal() / 2) != MAX_SUPPLY)
1343 && commanderReference->requestCounter.pylons_requests + 1 <= MAX_PYLON_REQUESTS)
1344 {
1345 PossibleBuildingRequest pylon;
1346 pylon.building = BWAPI::UnitTypes::Protoss_Pylon;
1347
1348 possibleRequestList.supplyBuildings.push_back(pylon);
1349 }
1350
1351 //Assimilators for nexus's
1352 for (const NexusEconomy& nexusEconomy : nexusEconomies)
1353 {
1354 if (nexusEconomy.vespeneGyser != nullptr
1355 && nexusEconomy.assimilator == nullptr
1356 && nexusEconomy.nexus != nullptr
1357 && nexusEconomy.workers.size() >= nexusEconomy.minerals.size() + 2)
1358 {
1359 const BWEM::Base* base = &getBaseReference(nexusEconomy.nexus);
1360
1361 //Unit is already planned in this case
1362 if (commanderReference->checkUnitIsBeingWarpedIn(BWAPI::UnitTypes::Protoss_Assimilator, base)
1363 || commanderReference->requestedBuilding(BWAPI::UnitTypes::Protoss_Assimilator, base->Center())
1364 || commanderReference->checkUnitIsPlanned(BWAPI::UnitTypes::Protoss_Assimilator, base->Center()))
1365 {
1366 continue;
1367 }
1368
1369 PossibleBuildingRequest assimilator;
1370 assimilator.building = BWAPI::UnitTypes::Protoss_Assimilator;
1371
1372 assimilator.base = base;
1373
1374 //Change this to position to be extra careful
1375 assimilator.nexusPosition = assimilator.base->Center();
1376
1377 //Check to make sure correct base is being found and used.
1378 /*
1379 std::cout << "Nexus does not have assimlator...requesting\n";
1380 std::cout << "Nexus ID: " << nexusEconomy.nexus->getID() << "\n";
1381 std::cout << "Has Gyser: " << (nexusEconomy.vespeneGyser == nullptr ? "no\n" : "yes\n");
1382 std::cout << "Has Assimilator: " << (nexusEconomy.assimilator == nullptr ? "false\n" : "true\n");
1383 std::cout << "BWAPI::Position: " << assimilator.nexusPosition << "\n";
1384 std::cout << "BWEM Base location: " << assimilator.base->Center() << "\n";
1385 */
1386 possibleRequestList.supplyBuildings.push_back(assimilator);
1387 }
1388 }
1389
1390 if (buildOrderCompleted)
1391 {
1392 //Nexus
1393 if (checkAlreadyRequested(BWAPI::UnitTypes::Protoss_Nexus))
1394 {
1395 if (BWAPI::Broodwar->self()->minerals() > mineralExcessToExpand)
1396 {
1397 mineralExcessToExpand *= 2;
1398 PossibleBuildingRequest nexus;
1399 nexus.building = BWAPI::UnitTypes::Protoss_Nexus;
1400
1401 possibleRequestList.supplyBuildings.push_back(nexus);
1402 }
1403
1404 if (!(minutesPassedIndex == expansionTimes.size()) && expansionTimes.at(minutesPassedIndex) <= minutes)
1405 {
1406 //std::cout << "EXPAND ACTION: Requesting to expand (expansion time " << expansionTimes.at(minutesPassedIndex) << ")\n";
1407 minutesPassedIndex++;
1408 PossibleBuildingRequest nexus;
1409 nexus.building = BWAPI::UnitTypes::Protoss_Nexus;
1410
1411 possibleRequestList.supplyBuildings.push_back(nexus);
1412 }
1413 }
1414
1415 //Number of gateways we currently have created/are making.
1416 if (buildOrderCompleted)
1417 {
1418 int gateways = 0;
1419 const int poweredLargePlacements = commanderReference->buildManager.buildingPlacer.Powered_LargePlacements;
1420
1421 for (const BWAPI::Unit building : unitProduction)
1422 {
1423 if (building->getType() == BWAPI::UnitTypes::Protoss_Gateway) gateways++;
1424 }
1425
1426 if ((gateways + request_count.gateway_requests < (MAX_GATEWAYS_PER_COMPLETED_NEXUS * ProtoBot_buildings.nexus) && gateways + request_count.gateway_requests < poweredLargePlacements)
1427 && checkAlreadyRequested(BWAPI::UnitTypes::Protoss_Gateway))
1428 {
1429 PossibleBuildingRequest gateway;
1430 gateway.building = BWAPI::UnitTypes::Protoss_Gateway;
1431
1432 possibleRequestList.supplyBuildings.push_back(gateway);
1433 }
1434 }
1435 }
1436}

◆ planUnitProduction()

void StrategyManager::planUnitProduction ( PossibleRequests & possibleRequestList)

Definition at line 1009 of file StrategyManager.cpp.

1010{
1011 const ProtoBotRequestCounter& request_count = commanderReference->requestCounter;
1012 const int currentSupply = BWAPI::Broodwar->self()->supplyUsed() / 2;
1013
1014 //Prevents construction of units outside Build Order.
1015 const bool trainingBlock = false;
1016 const std::vector<NexusEconomy>& nexusEconomies = commanderReference->getNexusEconomies();
1017 const FriendlyUnitCounter ProtoBot_currentUnits = InformationManager::Instance().getFriendlyUnitCounter();
1018 std::vector<Squad*> ProtoBot_Squads = commanderReference->combatManager.Squads;
1019
1020 int workerRequestsThisFrame = 0;
1021 int zealotRequestsThisFrame = 0;
1022 int darkTemplarRequestsThisFrame = 0;
1023 int observerRequestsThisFrame = 0;
1024
1025 for (const UnitProductionGoals productionGoal : unitProductionGoals)
1026 {
1027 switch (productionGoal)
1028 {
1029 case SATURATE_WORKERS:
1030 for (const NexusEconomy& nexusEconomy : nexusEconomies)
1031 {
1032 if (commanderReference->alreadySentRequest(nexusEconomy.nexus->getID()) == false &&
1033 !nexusEconomy.nexus->isTraining() &&
1034 nexusEconomy.nexus->isCompleted() &&
1035 nexusEconomy.workers.size() < ((nexusEconomy.minerals.size() * OPTIMAL_WORKERS_PER_MINERAL) + (nexusEconomy.vespeneGyser != nullptr ? WORKERS_PER_ASSIMILATOR : 0)) &&
1036 (request_count.worker_requests + workerRequestsThisFrame + unitProductionCounter.worker + 1) <= MAX_WORKERS)
1037 {
1038 PossibleUnitRequest probe;
1039 probe.unit = BWAPI::UnitTypes::Protoss_Probe;
1040 probe.trainer = nexusEconomy.nexus;
1041
1042 //std::cout << nexusEconomy.workers.size() << " < " << ((nexusEconomy.minerals.size() * OPTIMAL_WORKERS_PER_MINERAL) + (nexusEconomy.vespeneGyser != nullptr ? WORKERS_PER_ASSIMILATOR : 0)) << "\n";
1043 //std::cout << "Production counter: " << unitProductionCounter.worker << "\n";
1044 //std::cout << "ProtoBot_createdUnitCount: " << ProtoBot_createdUnitCount.created_workers << "\n";
1045
1046 workerRequestsThisFrame++;
1047 possibleRequestList.units.push_back(probe);
1048 }
1049 }
1050 break;
1051 case EARLY_ZEALOTS:
1052 if (trainingBlock) break;
1053
1054 for (const BWAPI::Unit building : unitProduction)
1055 {
1056 if (building->getType() != BWAPI::UnitTypes::Protoss_Gateway) continue;
1057
1058 //unitProductionCounter.zealots
1059 if (commanderReference->alreadySentRequest(building->getID()) == false &&
1060 !building->isTraining() &&
1061 building->isCompleted() &&
1062 (request_count.zealots_requests + zealotRequestsThisFrame + unitProductionCounter.zealots + 1) <= MAX_EARLY_ZEALOTS)
1063 {
1064 PossibleUnitRequest zealot;
1065 zealot.unit = BWAPI::UnitTypes::Protoss_Zealot;
1066 zealot.trainer = building;
1067
1068 zealotRequestsThisFrame++;
1069 possibleRequestList.units.push_back(zealot);
1070 }
1071 }
1072 break;
1073 case DARK_TEMPLAR_ATTEMPT:
1074 if (trainingBlock || haveRequiredTech(BWAPI::UnitTypes::Protoss_Dark_Templar) == false) break;
1075
1076 for (const BWAPI::Unit building : unitProduction)
1077 {
1078 if (building->getType() != BWAPI::UnitTypes::Protoss_Gateway) continue;
1079
1080 if (commanderReference->alreadySentRequest(building->getID()) == false &&
1081 !building->isTraining() &&
1082 building->isCompleted() &&
1083 (request_count.dark_templars_requests + unitProductionCounter.dark_templars + 1) <= MAX_EARLY_ZEALOTS)
1084 {
1085 PossibleUnitRequest darkTemplar;
1086 darkTemplar.unit = BWAPI::UnitTypes::Protoss_Dark_Templar;
1087 darkTemplar.trainer = building;
1088
1089 darkTemplarRequestsThisFrame++;
1090 possibleRequestList.units.push_back(darkTemplar);
1091 }
1092 }
1093 break;
1094 case OBSERVER_SCOUTS:
1095 if (trainingBlock || haveRequiredTech(BWAPI::UnitTypes::Protoss_Observer) == false) break;
1096
1097 for (const BWAPI::Unit building : unitProduction)
1098 {
1099 if (building->getType() != BWAPI::UnitTypes::Protoss_Robotics_Facility) continue;
1100
1101 if (commanderReference->alreadySentRequest(building->getID()) == false &&
1102 !building->isTraining() &&
1103 building->isCompleted() &&
1104 (request_count.observers_requests + observerRequestsThisFrame + ProtoBot_createdUnitCount.created_observers + 1) <= MAX_OBSERVERS_FOR_SCOUTING)
1105 {
1106 PossibleUnitRequest observer;
1107 observer.unit = BWAPI::UnitTypes::Protoss_Observer;
1108 observer.trainer = building;
1109
1110 observerRequestsThisFrame++;
1111 possibleRequestList.units.push_back(observer);
1112 }
1113 }
1114 break;
1115 case INVISIBLE_UNIT_DETECTED_SQUADS_NEED_OBSERVERS:
1116 if (trainingBlock || haveRequiredTech(BWAPI::UnitTypes::Protoss_Observer) == false) break;
1117
1118 for (const BWAPI::Unit building : unitProduction)
1119 {
1120 if (building->getType() != BWAPI::UnitTypes::Protoss_Robotics_Facility) continue;
1121
1122 if (commanderReference->alreadySentRequest(building->getID()) == false &&
1123 !building->isTraining() &&
1124 building->isCompleted() &&
1125 ((request_count.observers_requests + observerRequestsThisFrame + ProtoBot_createdUnitCount.created_observers + 1) <= (ProtoBot_Squads.size() + MAX_OBSERVERS_FOR_SCOUTING) ||
1126 (request_count.observers_requests + observerRequestsThisFrame + ProtoBot_createdUnitCount.created_observers + 1) <= (MAX_OBSERVERS_FOR_INVIS_UNITS + MAX_OBSERVERS_FOR_SCOUTING)))
1127 {
1128 PossibleUnitRequest observer;
1129 observer.unit = BWAPI::UnitTypes::Protoss_Observer;
1130 observer.trainer = building;
1131
1132 observerRequestsThisFrame++;
1133 possibleRequestList.units.push_back(observer);
1134 }
1135 }
1136 break;
1137 case INFINITE_DRAGOONS:
1138 if (trainingBlock || haveRequiredTech(BWAPI::UnitTypes::Protoss_Dragoon) == false) break;
1139
1140 for (const BWAPI::Unit building : unitProduction)
1141 {
1142 if (building->getType() != BWAPI::UnitTypes::Protoss_Gateway) continue;
1143
1144 if (commanderReference->alreadySentRequest(building->getID()) == false &&
1145 !building->isTraining() &&
1146 building->isCompleted())
1147 {
1148 PossibleUnitRequest dragoon;
1149 dragoon.unit = BWAPI::UnitTypes::Protoss_Dragoon;
1150 dragoon.trainer = building;
1151
1152 possibleRequestList.units.push_back(dragoon);
1153 }
1154 }
1155 break;
1156 default:
1157 break;
1158 }
1159 }
1160}

◆ planUpgradeProduction()

void StrategyManager::planUpgradeProduction ( PossibleRequests & possibleRequestList)

Definition at line 1245 of file StrategyManager.cpp.

1246{
1247 const ProtoBotRequestCounter& request_count = commanderReference->requestCounter;
1248 const FriendlyBuildingCounter completedBuildingsCount = InformationManager::Instance().getFriendlyBuildingCounter();
1249 const FriendlyUnitCounter completedUnitsCount = InformationManager::Instance().getFriendlyUnitCounter();
1250 const FriendlyUpgradeCounter completedUpgradesCount = InformationManager::Instance().getFriendlyUpgradeCounter();
1251 const int ProtoBot_Squads = commanderReference->combatManager.Squads.size();
1252
1253 for (const UpgradeProductionGoals productionGoal : upgradeProductionGoals)
1254 {
1255 switch (productionGoal)
1256 {
1257 case RESEARCH_SINGULARITY_CHARGE:
1258 for (const BWAPI::Unit unit : cybernetics)
1259 {
1260 if (commanderReference->alreadySentRequest(unit->getID()) == false &&
1261 !unit->isTraining() &&
1262 unit->isCompleted() &&
1263 completedUnitsCount.dragoon >= 1 &&
1264 (request_count.singularity_requests + upgradesInProduction.singularity_charge + completedUpgradesCount.singularityCharge + 1) == MAX_SINGULARITY_UPGRADES)
1265 {
1266 PossibleUpgradeRequest singularity;
1267 singularity.upgrade = BWAPI::UpgradeTypes::Singularity_Charge;
1268 singularity.trainer = unit;
1269
1270 possibleRequestList.upgrades.push_back(singularity);
1271 }
1272 }
1273 break;
1274 case RESEARCH_GROUND_WEAPONS:
1275 for (const BWAPI::Unit unit : forges)
1276 {
1277 if (commanderReference->alreadySentRequest(unit->getID()) == false &&
1278 !unit->isTraining() &&
1279 unit->isCompleted() &&
1280 ProtoBot_Squads >= 3 &&
1281 (request_count.groundWeapons_requests + upgradesInProduction.ground_weapons + completedUpgradesCount.groundWeapons + 1) <= 1)
1282 {
1283 PossibleUpgradeRequest groundWeapons;
1284 groundWeapons.upgrade = BWAPI::UpgradeTypes::Protoss_Ground_Weapons;
1285 groundWeapons.trainer = unit;
1286
1287 possibleRequestList.upgrades.push_back(groundWeapons);
1288 }
1289 }
1290 break;
1291 case RESEARCH_GROUND_ARMOR:
1292 for (const BWAPI::Unit unit : forges)
1293 {
1294 if (commanderReference->alreadySentRequest(unit->getID()) == false &&
1295 !unit->isTraining() &&
1296 unit->isCompleted() &&
1297 ProtoBot_Squads >= 3 &&
1298 (request_count.groundArmor_requests + upgradesInProduction.ground_armor + completedUpgradesCount.groundArmor + 1) <= 1)
1299 {
1300 PossibleUpgradeRequest groundArmor;
1301 groundArmor.upgrade = BWAPI::UpgradeTypes::Protoss_Ground_Armor;
1302 groundArmor.trainer = unit;
1303
1304 possibleRequestList.upgrades.push_back(groundArmor);
1305 }
1306 }
1307 break;
1308 }
1309 }
1310}

◆ shouldGasSteal()

bool StrategyManager::shouldGasSteal ( )

Definition at line 1483 of file StrategyManager.cpp.

1484{
1485 return true;
1486}

◆ updateUnitProductionGoals()

void StrategyManager::updateUnitProductionGoals ( )

Definition at line 916 of file StrategyManager.cpp.

917{
918 //Notes:
919 //Need a way to check tech tree to make sure we can build
920 const ProtoBotRequestCounter& request_count = commanderReference->requestCounter;
921 const FriendlyBuildingCounter completedBuildingsCount = InformationManager::Instance().getFriendlyBuildingCounter();
922 FriendlyUnitCounter ProtoBot_currentUnits = InformationManager::Instance().getFriendlyUnitCounter();
923 std::vector<Squad*> ProtoBot_Squads = commanderReference->combatManager.Squads;
924
925 //Probes
926 if (request_count.worker_requests + ProtoBot_createdUnitCount.created_workers < MAX_WORKERS)
927 {
928 unitProductionGoals.insert(SATURATE_WORKERS);
929 }
930 else
931 {
932 unitProductionGoals.erase(SATURATE_WORKERS);
933 }
934
935 //Zealots
936 //Always have 3 zealots at the beggining of the game unless the build order we have focuses dragoons then dont attempt to create any zealots.
937 if ((request_count.zealots_requests + unitProductionCounter.zealots < MAX_EARLY_ZEALOTS && request_count.dragoons_requests + unitProductionCounter.dragoons < 1))
938 {
939 unitProductionGoals.insert(EARLY_ZEALOTS);
940 }
941 else
942 {
943 unitProductionGoals.erase(EARLY_ZEALOTS);
944 }
945
946 //Dragoons
947 //Once this is inserted it will not be removed unless something bad happens.
948 //Will be added once we have made + planned 3 zealots or have atleast made 1 dragoon during build order.
949 if ((request_count.zealots_requests + unitProductionCounter.zealots == MAX_EARLY_ZEALOTS || request_count.dragoons_requests + unitProductionCounter.dragoons >= 1))
950 {
951 unitProductionGoals.insert(INFINITE_DRAGOONS);
952 }
953
954 //Minimum Observer Production
955 if (request_count.observers_requests + ProtoBot_createdUnitCount.created_observers < MAX_OBSERVERS_FOR_SCOUTING && ProtoBot_currentUnits.observer < MAX_OBSERVERS_FOR_SCOUTING)
956 {
957 //std::cout << "Observer Requests = " << request_count.observers_requests << "\n";
958 //std::cout << "Created Units = " << ProtoBot_createdUnitCount.created_observers << "\n";
959 //std::cout << "Current Observer Count = " << ProtoBot_currentUnits.observer << "\n";
960 unitProductionGoals.insert(OBSERVER_SCOUTS);
961 }
962 else
963 {
964 unitProductionGoals.erase(OBSERVER_SCOUTS);
965 }
966
967 //Constant Observer Production
968 if (InformationManager::Instance().enemyHasCloakTech())
969 {
970 //Current Observers we have.
971 int numObservers = (request_count.observers_requests + ProtoBot_currentUnits.observer) - MAX_OBSERVERS_FOR_SCOUTING;
972
973 //Check to make sure negative unit count doesnt happen from scouting observers.
974 //Can probably work with matthew to make sure we can check what squads have a observer.
975 int squadObserverCount = 0;
976 for (Squad* squad : ProtoBot_Squads)
977 {
978 if (squad->observer != nullptr) squadObserverCount++;
979 }
980
981 if ((request_count.observers_requests + squadObserverCount + ProtoBot_createdUnitCount.created_observers) - MAX_OBSERVERS_FOR_SCOUTING < ProtoBot_Squads.size()
982 && (ProtoBot_currentUnits.observer < (ProtoBot_Squads.size() + MAX_OBSERVERS_FOR_SCOUTING) || ProtoBot_currentUnits.observer < (MAX_OBSERVERS_FOR_SCOUTING + MAX_OBSERVERS_FOR_INVIS_UNITS)))
983 {
984 unitProductionGoals.insert(INVISIBLE_UNIT_DETECTED_SQUADS_NEED_OBSERVERS);
985 }
986 else
987 {
988 unitProductionGoals.insert(INVISIBLE_UNIT_DETECTED_SQUADS_NEED_OBSERVERS);
989 }
990 }
991
992 //Dark Templars
993 if (opponentRace == BWAPI::Races::Terran || opponentRace == BWAPI::Races::Protoss)
994 {
995 if (request_count.dark_templars_requests + unitProductionCounter.dark_templars < MAX_DARK_TEMPLARS)
996 {
997 unitProductionGoals.insert(DARK_TEMPLAR_ATTEMPT);
998 }
999 else
1000 {
1001 unitProductionGoals.erase(DARK_TEMPLAR_ATTEMPT);
1002 }
1003 }
1004
1005 //Photon Cannons (Yes I know they are not combat units but we will leave this here for now)
1006 //InformationManager::Instance().enemyHasAirTech();
1007}

◆ updateUpgradeGoals()

void StrategyManager::updateUpgradeGoals ( )

Definition at line 1196 of file StrategyManager.cpp.

1197{
1198 const ProtoBotRequestCounter& request_count = commanderReference->requestCounter;
1199 const FriendlyBuildingCounter completedBuildingsCount = InformationManager::Instance().getFriendlyBuildingCounter();
1200 const FriendlyUnitCounter completedUnitsCount = InformationManager::Instance().getFriendlyUnitCounter();
1201 const FriendlyUpgradeCounter completedUpgradesCount = InformationManager::Instance().getFriendlyUpgradeCounter();
1202 const int ProtoBot_Squads = commanderReference->combatManager.Squads.size();
1203
1204 updateUpgradesBeingCreated();
1205
1206 //Singularity Charge
1207 if (request_count.singularity_requests + upgradesInProduction.singularity_charge + completedUpgradesCount.singularityCharge < MAX_SINGULARITY_UPGRADES)
1208 {
1209 upgradeProductionGoals.insert(RESEARCH_SINGULARITY_CHARGE);
1210 }
1211 else
1212 {
1213 upgradeProductionGoals.erase(RESEARCH_SINGULARITY_CHARGE);
1214 }
1215
1216 //Ground Armor
1217 if (request_count.groundArmor_requests + upgradesInProduction.ground_armor + completedUpgradesCount.groundArmor < 1
1218 && (ProtoBot_Squads >= 4))
1219 {
1220 upgradeProductionGoals.insert(RESEARCH_GROUND_ARMOR);
1221 }
1222 else
1223 {
1224 upgradeProductionGoals.erase(RESEARCH_GROUND_ARMOR);
1225 }
1226
1227 //Ground Weapons
1228 if (request_count.groundWeapons_requests + upgradesInProduction.ground_weapons + completedUpgradesCount.groundWeapons < 1
1229 && (ProtoBot_Squads >= 3 || completedUnitsCount.dragoon >= 20))
1230 {
1231 upgradeProductionGoals.insert(RESEARCH_GROUND_WEAPONS);
1232 }
1233 else
1234 {
1235 upgradeProductionGoals.erase(RESEARCH_GROUND_WEAPONS);
1236 }
1237
1238 //Plasma Shields
1239
1240
1241 //Leg Enhancements
1242
1243}

◆ updateUpgradesBeingCreated()

void StrategyManager::updateUpgradesBeingCreated ( )
private

Definition at line 1162 of file StrategyManager.cpp.

1163{
1164 //Reset values.
1165 upgradesInProduction.singularity_charge = 0;
1166 upgradesInProduction.ground_weapons = 0;
1167 upgradesInProduction.ground_armor = 0;
1168 upgradesInProduction.plasma_shields = 0;
1169 upgradesInProduction.leg_enhancements = 0;
1170
1171 for (BWAPI::Unit upgrade_building : upgradeProduction)
1172 {
1173 if (!upgrade_building->isUpgrading()) continue;
1174
1175 switch (upgrade_building->getUpgrade())
1176 {
1177 case BWAPI::UpgradeTypes::Singularity_Charge:
1178 upgradesInProduction.singularity_charge++;
1179 break;
1180 case BWAPI::UpgradeTypes::Protoss_Ground_Weapons:
1181 upgradesInProduction.ground_weapons++;
1182 break;
1183 case BWAPI::UpgradeTypes::Protoss_Ground_Armor:
1184 upgradesInProduction.ground_armor++;
1185 break;
1186 case BWAPI::UpgradeTypes::Protoss_Plasma_Shields:
1187 upgradesInProduction.plasma_shields++;
1188 break;
1189 case BWAPI::UpgradeTypes::Leg_Enhancements:
1190 upgradesInProduction.leg_enhancements++;
1191 break;
1192 }
1193 }
1194}

Member Data Documentation

◆ citadels

BWAPI::Unitset StrategyManager::citadels
private

Definition at line 267 of file StrategyManager.h.

◆ commanderReference

ProtoBotCommander* StrategyManager::commanderReference

Definition at line 296 of file StrategyManager.h.

◆ cybernetics

BWAPI::Unitset StrategyManager::cybernetics
private

Definition at line 265 of file StrategyManager.h.

◆ drawStrategyDebug

bool StrategyManager::drawStrategyDebug = false

Definition at line 293 of file StrategyManager.h.

◆ expansionTimes

std::vector<int> StrategyManager::expansionTimes = { 5, 10, 15, 20, 30 ,40, 50}
private

Definition at line 232 of file StrategyManager.h.

232{ 5, 10, 15, 20, 30 ,40, 50};

◆ forges

BWAPI::Unitset StrategyManager::forges
private

Definition at line 266 of file StrategyManager.h.

◆ frameSinceLastScout

int StrategyManager::frameSinceLastScout = 0
private

Definition at line 240 of file StrategyManager.h.

◆ incompleteBuildings

IncompleteBuildingCounter StrategyManager::incompleteBuildings
private

Definition at line 235 of file StrategyManager.h.

◆ isAttackPhase

bool StrategyManager::isAttackPhase = false

Definition at line 292 of file StrategyManager.h.

◆ lastAttackPos

BWAPI::Position StrategyManager::lastAttackPos

Definition at line 289 of file StrategyManager.h.

◆ mainArea

const BWEM::Area* StrategyManager::mainArea
private

Definition at line 241 of file StrategyManager.h.

◆ mineralExcessToExpand

int StrategyManager::mineralExcessToExpand = 1000
private

Definition at line 239 of file StrategyManager.h.

◆ minutesPassedIndex

size_t StrategyManager::minutesPassedIndex = 0
private

Definition at line 233 of file StrategyManager.h.

◆ opponentRace

BWAPI::Race StrategyManager::opponentRace = BWAPI::Races::Unknown

Definition at line 309 of file StrategyManager.h.

◆ opponentRaceNotKnown

bool StrategyManager::opponentRaceNotKnown = true
private

Definition at line 275 of file StrategyManager.h.

◆ ourIncomePerFrameMinerals

double StrategyManager::ourIncomePerFrameMinerals = 0.0
private

Definition at line 281 of file StrategyManager.h.

◆ outIncomePerFrameGas

double StrategyManager::outIncomePerFrameGas = 0.0
private

Definition at line 282 of file StrategyManager.h.

◆ phantomPositions

std::unordered_set<BWAPI::Position, PositionHash> StrategyManager::phantomPositions

Definition at line 295 of file StrategyManager.h.

◆ PositionsFilled

std::unordered_map<const BWEM::ChokePoint*, bool> StrategyManager::PositionsFilled

Definition at line 287 of file StrategyManager.h.

◆ ProtoBot_Areas

std::unordered_set<const BWEM::Area*> StrategyManager::ProtoBot_Areas

Definition at line 285 of file StrategyManager.h.

◆ ProtoBot_createdUnitCount

ProtoBotProductionCount StrategyManager::ProtoBot_createdUnitCount
private

Definition at line 256 of file StrategyManager.h.

◆ ProtoBotArea_SquadPlacements

std::unordered_set<const BWEM::ChokePoint*> StrategyManager::ProtoBotArea_SquadPlacements

Definition at line 286 of file StrategyManager.h.

◆ resourceDepots

BWAPI::Unitset StrategyManager::resourceDepots
private

Definition at line 260 of file StrategyManager.h.

◆ spenderManager

SpenderManager StrategyManager::spenderManager
private

Definition at line 236 of file StrategyManager.h.

◆ startingChoke

BWAPI::Position StrategyManager::startingChoke

Definition at line 288 of file StrategyManager.h.

◆ supplyThreshold

int StrategyManager::supplyThreshold = SUPPLY_THRESHOLD_EARLYGAME
private

Definition at line 277 of file StrategyManager.h.

◆ unitProduction

BWAPI::Unitset StrategyManager::unitProduction
private

Definition at line 261 of file StrategyManager.h.

◆ unitProductionCounter

UnitProductionGameCounter StrategyManager::unitProductionCounter

Definition at line 307 of file StrategyManager.h.

◆ unitProductionGoals

std::set<UnitProductionGoals> StrategyManager::unitProductionGoals
private

Definition at line 272 of file StrategyManager.h.

◆ upgradeProduction

BWAPI::Unitset StrategyManager::upgradeProduction
private

Definition at line 262 of file StrategyManager.h.

◆ upgradeProductionGoals

std::set<UpgradeProductionGoals> StrategyManager::upgradeProductionGoals
private

Definition at line 273 of file StrategyManager.h.

◆ upgradesInProduction

UpgradesInProduction StrategyManager::upgradesInProduction
private

Definition at line 257 of file StrategyManager.h.

◆ workerIncomePerFrameGas

const double StrategyManager::workerIncomePerFrameGas = 0.069
private

Definition at line 280 of file StrategyManager.h.

◆ workerIncomePerFrameMinerals

const double StrategyManager::workerIncomePerFrameMinerals = 0.044
private

Definition at line 279 of file StrategyManager.h.

◆ workers

BWAPI::Unitset StrategyManager::workers
private

Definition at line 270 of file StrategyManager.h.

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