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

Combat module of ProtoBot. More...

#include <CombatManager.h>

Public Member Functions

 CombatManager (ProtoBotCommander *commanderReference)
void onStart ()
void onFrame ()
void onUnitDestroy (BWAPI::Unit unit)
bool assignUnit (BWAPI::Unit unit)
 Checks through available squads. If squad exists that has space remaining, assigns unit to that squad. If no squad exists OR all squads are full,.
void attack (BWAPI::Position position)
 All squads move towards position to attack.
void defend (BWAPI::Position position)
 Idle squads are given a position to defend. If any squads are currently attacking, this will override the state.
void reinforce (BWAPI::Position position)
 Moves to assist squads that are being attacked nearby. If any squads are currently attacking, this will override the state.
Squad * addSquad (BWAPI::Unit leaderUnit)
void removeSquad (Squad *squad)
BWAPI::Unit getAvailableUnit ()
BWAPI::Unit getAvailableUnit (function< bool(BWAPI::Unit)> filter)
bool detachUnit (BWAPI::Unit unit)
 Detaches scout unit from squad when ScoutingManager grabs unit.

Public Attributes

ProtoBotCommander * commanderReference
BWAPI::Unitset allUnits
vector< Squad * > Squads = vector<Squad*>()
BWAPI::Position globalAttackPosition = BWAPI::Positions::Invalid
bool combat_debug_on = false

Static Public Attributes

static unordered_map< BWAPI::Unit, Squad *, unitCMHash > unitSquadMap
static map< SquadState *, BWAPI::Color > stateColorMap
static vector< Squad * > AttackingSquads
static vector< Squad * > DefendingSquads
static vector< Squad * > ReinforcingSquads
static vector< Squad * > IdleSquads

Private Member Functions

bool isAssigned (BWAPI::Unit unit)
void drawDebugInfo ()

Private Attributes

queue< BWAPI::Unit > detachedObservers
 Queue of observers from destroyed squads.

Detailed Description

Combat module of ProtoBot.

CombatManager handles the combat functionality of ProtoBot. It handles unit assignment, squad creation and destruction, as well as strategic actions sent by StrategyManager (attack, defend, reinforce)

Definition at line 26 of file CombatManager.h.

Constructor & Destructor Documentation

◆ CombatManager()

CombatManager::CombatManager ( ProtoBotCommander * commanderReference)

Definition at line 17 of file CombatManager.cpp.

17 : commanderReference(commanderReference)
18{
19
20}

Member Function Documentation

◆ addSquad()

Squad * CombatManager::addSquad ( BWAPI::Unit leaderUnit)

Definition at line 128 of file CombatManager.cpp.

128 {
129
130 // Workaround for bwapi random color issue
131 const int r = 50 + std::rand() % 200;
132 const int g = 50 + std::rand() % 200;
133 const int b = 50 + std::rand() % 200;
134
135 const BWAPI::Color randomColor(r, g, b);
136
137 const int id = Squads.size() + 1;
138
139 Squad* newSquad = new Squad(leaderUnit, id, randomColor);
140 BWAPI::Unit detector = commanderReference->scoutingManager.getAvaliableDetectors();
141
142 Squads.push_back(newSquad);
143
144 newSquad->setState(IdleState::getInstance());
145 if (commanderReference->strategyManager.isAttackPhase) {
146 for (const auto& attackingSquad : AttackingSquads) {
147 if (attackingSquad->info.currentAttackPosition != BWAPI::Positions::Invalid) {
148 newSquad->info.commandPos = globalAttackPosition;
149 newSquad->setState(AttackingState::getInstance());
150 break;
151 }
152 }
153 }
154
155#ifdef DEBUG_CM
156 BWAPI::Broodwar->printf("Created new Squad %d with leader Unit %d", id, leaderUnit->getID());
157#endif
158
159 return newSquad;
160}
SquadInfo::commandPos
BWAPI::Position commandPos
Initial position sent by StrategyManager. Used to compared against the current attacking,...
Definition Squad.h:25

◆ assignUnit()

bool CombatManager::assignUnit ( BWAPI::Unit unit)

Checks through available squads. If squad exists that has space remaining, assigns unit to that squad. If no squad exists OR all squads are full,.

Parameters
unit
Returns

Definition at line 201 of file CombatManager.cpp.

202{
203 if (!unit->exists()) {
204 return false;
205 }
206
207 if (commanderReference->scoutingManager.isScout(unit)) {
208 return false; // refuse: unit is a scout
209 }
210
211 // Assigning to an existing squad if available
212 for (auto& squad : Squads) {
213 if (squad->info.units.size() < MAX_SQUAD_SIZE) {
214 squad->addUnit(unit);
215 allUnits.insert(unit);
216 unitSquadMap[unit] = squad;
217 return true;
218 }
219 }
220
221 // If all squads are full or there are no squads, creates a new squad
222 // Assigns first unit as the leader
223 Squad* newSquad = addSquad(unit);
224 if (newSquad == nullptr) {
225 return false;
226 }
227
228 newSquad->addUnit(unit);
229 allUnits.insert(unit);
230 unitSquadMap[unit] = newSquad;
231 return true;
232}

◆ attack()

void CombatManager::attack ( BWAPI::Position position)

All squads move towards position to attack.

Loops through all existing squads and updates their command positions. \nAlso, sets their state to AttackingState where they will move towards the position while attacking nearby enemies.

Parameters
position

Definition at line 93 of file CombatManager.cpp.

93 {
94 for (const auto& squad : Squads) {
95 squad->info.commandPos = position;
96 squad->setState(AttackingState::getInstance());
97 }
98}

◆ defend()

void CombatManager::defend ( BWAPI::Position position)

Idle squads are given a position to defend. If any squads are currently attacking, this will override the state.

Loops through IdleSquads vector. If any squads in IdleSquads, sets their state machine to the state DefendingState
If any attacking squads, overrides their state machine to DefendingState.

Parameters
position

Definition at line 100 of file CombatManager.cpp.

100 {
101 for (auto& squad : IdleSquads) {
102 squad->info.currentDefensivePosition = position;
103 squad->setState(DefendingState::getInstance());
104 }
105 for (auto& squad : AttackingSquads) {
106 squad->info.currentDefensivePosition = position;
107 squad->setState(DefendingState::getInstance());
108 }
109}

◆ detachUnit()

bool CombatManager::detachUnit ( BWAPI::Unit unit)

Detaches scout unit from squad when ScoutingManager grabs unit.

ScoutingManager grabs combat scouts from CombatManager. This function is a fallback to ensure that scouts do not remain inside the squad.

Parameters
unit
Returns
Boolean
True = unit was deatched
False = unit not found

Definition at line 265 of file CombatManager.cpp.

265 {
266 if (!unit) {
267 return false;
268 }
269
270 auto itMap = unitSquadMap.find(unit);
271 if (itMap == unitSquadMap.end()) {
272 allUnits.erase(unit);
273 return false;
274 }
275
276 Squad* squad = itMap->second;
277
278 squad->removeUnit(unit);
279
280 if (squad->info.units.empty()) {
281 removeSquad(squad);
282 }
283 else {
284 // Optional: ensure leader is valid after removal
285 if (!squad->leader || !squad->leader->exists()) {
286 squad->leader = squad->info.units.front();
287 }
288 }
289
290 unitSquadMap.erase(unit);
291 allUnits.erase(unit);
292 return true;
293}

◆ getAvailableUnit()

BWAPI::Unit CombatManager::getAvailableUnit ( )

Definition at line 243 of file CombatManager.cpp.

243 {
244 return getAvailableUnit([](BWAPI::Unit) { return true; });
245}

◆ isAssigned()

bool CombatManager::isAssigned ( BWAPI::Unit unit)
private

Definition at line 234 of file CombatManager.cpp.

234 {
235 if (unitSquadMap.find(unit) != unitSquadMap.end()) {
236 return true;
237 }
238 else {
239 return false;
240 }
241}

◆ onFrame()

void CombatManager::onFrame ( )

Definition at line 33 of file CombatManager.cpp.

33 {
34 if ((BWAPI::Broodwar->getFrameCount() % FRAMES_BETWEEN_CACHING) == 0) {
35 AStar::fillAreaPathCache();
36 }
37
38 /*for (const auto& squad : Squads) {
39 BOIDS::squadFlock(squad);
40 }*/
41
42 for (const auto& squad : Squads) {
43
44 // If this squad has an available slot for observer, check if it can get one
45 if (squad->observer == nullptr) {
46 if (!detachedObservers.empty()) {
47 squad->addObserver(detachedObservers.front());
48 unitSquadMap[detachedObservers.front()] = squad;
49 detachedObservers.pop();
50 }
51 else {
52 BWAPI::Unit observer = commanderReference->scoutingManager.getAvaliableDetectors();
53 if (observer != nullptr) {
54 squad->observer = observer;
55 }
56 }
57 }
58
59 squad->onFrame();
60
61 if (combat_debug_on) {
62 squad->drawSquadBox();
63 }
64 }
65
66#ifdef DRAW_PRECACHE //In A-StarPathfinding.h
67 MapTools map_tool = MapTools();
68 if (!precachedPositions.empty()) {
69 BWAPI::Position prevPos = precachedPositions.at(0);
70 for (const auto& pos : precachedPositions) {
71 map_tool.drawTile(BWAPI::TilePosition(pos).x, BWAPI::TilePosition(pos).y, BWAPI::Colors::Red);
72 prevPos = pos;
73 }
74 }
75#endif
76}
AStar::fillAreaPathCache
static void fillAreaPathCache()
Loops through all area pairs from UncachedAreaPairs() and stores a path in-between them.
Definition A-StarPathfinding.cpp:568
CombatManager::detachedObservers
queue< BWAPI::Unit > detachedObservers
Queue of observers from destroyed squads.
Definition CombatManager.h:93

◆ onStart()

void CombatManager::onStart ( )

Definition at line 22 of file CombatManager.cpp.

22 {
23 AStar::clearPathCache();
24 AStar::fillUncachedAreaPairs();
25 Squads.clear();
26 unitSquadMap.clear();
27 AttackingSquads.clear();
28 DefendingSquads.clear();
29 ReinforcingSquads.clear();
30 IdleSquads.clear();
31}
AStar::fillUncachedAreaPairs
static void fillUncachedAreaPairs()
Fills UncachedAreaPairs with pairs of areas that are neighbours. All of these pairs will be used to p...
Definition A-StarPathfinding.cpp:541

◆ onUnitDestroy()

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

Definition at line 78 of file CombatManager.cpp.

78 {
79 if (isAssigned(unit)) {
80 Squad* squad = unitSquadMap[unit];
81 squad->removeUnit(unit);
82 unitSquadMap.erase(unit);
83 allUnits.erase(unit);
84
85 if (squad->info.units.empty()) {
86 removeSquad(squad);
87 }
88
89 unitSquadMap.erase(unit);
90 }
91}

◆ reinforce()

void CombatManager::reinforce ( BWAPI::Position position)

Moves to assist squads that are being attacked nearby. If any squads are currently attacking, this will override the state.

Affects squads in the DefendingState. If the squad is too far, less than MAX_REINFORCE_DIST (listed in SquadStateTypes.h), the squad will stay in DefendingState Also sends reinforce position to the current reinforcing squads to update their reinforce positions

Parameters
position

Definition at line 112 of file CombatManager.cpp.

112 {
113 for (const auto& squad : DefendingSquads) {
114 if (squad->info.currentDefensivePosition.getApproxDistance(position) > MAX_REINFORCE_DIST) {
115 continue;
116 }
117 else {
118 squad->info.commandPos = position;
119 squad->setState(ReinforcingState::getInstance());
120 }
121 }
122
123 for (auto& squad : ReinforcingSquads) {
124 squad->info.commandPos = position;
125 }
126}

◆ removeSquad()

void CombatManager::removeSquad ( Squad * squad)

Definition at line 162 of file CombatManager.cpp.

162 {
163 Squads.erase(remove(Squads.begin(), Squads.end(), squad), Squads.end());
164 IdleSquads.erase(remove(IdleSquads.begin(), IdleSquads.end(), squad), IdleSquads.end());
165 DefendingSquads.erase(remove(DefendingSquads.begin(), DefendingSquads.end(), squad), DefendingSquads.end());
166 ReinforcingSquads.erase(remove(ReinforcingSquads.begin(), ReinforcingSquads.end(), squad), ReinforcingSquads.end());
167 AttackingSquads.erase(remove(AttackingSquads.begin(), AttackingSquads.end(), squad), AttackingSquads.end());
168
169 // Check if observer is left
170 if (squad->observer != nullptr) {
171 unitSquadMap.erase(squad->observer);
172 detachedObservers.push(squad->observer);
173 }
174
175 // Handling filled chokepoint locations in strategy manager
176 for (const auto& cp : commanderReference->strategyManager.ProtoBotArea_SquadPlacements) {
177 if (cp != nullptr && squad->info.currentDefensivePosition == BWAPI::Position(cp->Center())) {
178 commanderReference->strategyManager.PositionsFilled[cp] = false;
179
180#ifdef DEBUG_CM
181 cout << "Removed squad from chokepoint position: " << BWAPI::Position(cp->Center()).x << "," << BWAPI::Position(cp->Center()).y << endl;
182#endif
183 }
184 }
185
186#ifdef DEBUG_CM
187 BWAPI::Broodwar->printf("Removed Squad %d", squad->info.squadId);
188#endif
189
190 delete squad;
191 squad = nullptr;
192}

Member Data Documentation

◆ allUnits

BWAPI::Unitset CombatManager::allUnits

Definition at line 30 of file CombatManager.h.

◆ AttackingSquads

vector< Squad * > CombatManager::AttackingSquads
static

Definition at line 35 of file CombatManager.h.

◆ combat_debug_on

bool CombatManager::combat_debug_on = false

Definition at line 39 of file CombatManager.h.

◆ commanderReference

ProtoBotCommander* CombatManager::commanderReference

Definition at line 28 of file CombatManager.h.

◆ DefendingSquads

vector< Squad * > CombatManager::DefendingSquads
static

Definition at line 36 of file CombatManager.h.

◆ detachedObservers

queue<BWAPI::Unit> CombatManager::detachedObservers
private

Queue of observers from destroyed squads.

Observers are not part of squad unit vectors. If a squad is destroyed and the observer is alive, this structure stores that observer.
If a squad needs an observer, it will check detachedObservers for any available observers before requesting one.

Definition at line 93 of file CombatManager.h.

◆ globalAttackPosition

BWAPI::Position CombatManager::globalAttackPosition = BWAPI::Positions::Invalid

Definition at line 32 of file CombatManager.h.

◆ IdleSquads

vector< Squad * > CombatManager::IdleSquads
static

Definition at line 38 of file CombatManager.h.

◆ ReinforcingSquads

vector< Squad * > CombatManager::ReinforcingSquads
static

Definition at line 37 of file CombatManager.h.

◆ Squads

vector<Squad*> CombatManager::Squads = vector<Squad*>()

Definition at line 31 of file CombatManager.h.

◆ stateColorMap

map< SquadState *, BWAPI::Color > CombatManager::stateColorMap
static
Initial value:
= {
{&AttackingState::getInstance(), BWAPI::Colors::Cyan},
{&DefendingState::getInstance(), BWAPI::Colors::Green},
{&ReinforcingState::getInstance(), BWAPI::Colors::Yellow},
{&IdleState::getInstance(), BWAPI::Colors::White}
}

Definition at line 5 of file CombatManager.h.

◆ unitSquadMap

unordered_map< BWAPI::Unit, Squad *, unitCMHash > CombatManager::unitSquadMap
static

Definition at line 33 of file CombatManager.h.

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