Squad Class Reference

The Squad class represents a group of combat units owned by ProtoBot. More...

#include <Squad.h>

Public Member Functions
	Squad (BWAPI::Unit leader, int squadId, BWAPI::Color squadColor)
void	onFrame ()
void	setState (SquadState &newState)
void	removeUnit (BWAPI::Unit unit)
void	addUnit (BWAPI::Unit unit)
void	addObserver (BWAPI::Unit observer)
void	observerOnFrame ()
	Defines the behavior of the observer unit in the squad.
void	drawSquadBox ()
void	drawDebugInfo ()
bool	operator== (const Squad &other) noexcept(true)
bool	operator!= (const Squad &other) noexcept(true)

Public Attributes
BWAPI::Unit	leader = nullptr
BWAPI::Unit	observer = nullptr
SquadInfo	info

Detailed Description

The Squad class represents a group of combat units owned by ProtoBot.

Base squad structure that holds its leader, observer, as well as its methods.
Information is stored inside of a SquadInfo class.

Every squad has a leader and methods for adding and removing units.
Squad behavior is defined by its state and onFrame(), which calls the current state's Update() method.

Definition at line 56 of file Squad.h.

Constructor & Destructor Documentation

Squad()

Squad::Squad	(	BWAPI::Unit	leader,
		int	squadId,
		BWAPI::Color	squadColor )

Definition at line 4 of file Squad.cpp.

{
    this->leader = leader;
    this->info.squadId = squadId;
    this->info.squadColor = squadColor;
}

Member Function Documentation

addObserver()

void Squad::addObserver

(

BWAPI::Unit

observer

)

Definition at line 101 of file Squad.cpp.

                                                    {
    if (unreservedObserver == nullptr) {
        return;
    }
 
    observer = unreservedObserver;
}

addUnit()

void Squad::addUnit

(

BWAPI::Unit

unit

)

Definition at line 74 of file Squad.cpp.

                                  {
    if (unit == nullptr) {
        return;
    }
 
    if (std::find(info.units.begin(), info.units.end(), unit) != info.units.end()) {
        // Avoids adding duplicate units
        return;
    }
 
    info.units.push_back(unit);
 
    // Unit should do whatever the squad is currently doing
    if (info.currentState == &DefendingState::getInstance()) {
        unit->attack(info.currentDefensivePosition);
    }
    if (info.currentState == &ReinforcingState::getInstance()) {
        unit->attack(info.currentReinforcePosition);
    }
    if (info.currentState == &AttackingState::getInstance()) {
        unit->attack(info.currentAttackPosition);
    }
#ifdef DEBUG_SQUAD
    BWAPI::Broodwar->printf("Unit %d added to Squad %d", unit->getID(), squadId);
#endif
}

drawDebugInfo()

void Squad::drawDebugInfo

(

)

Definition at line 158 of file Squad.cpp.

                          {
    for (auto& unit : info.units) {
        if (!unit || !unit->exists()) {
            continue;
        }
 
        // Draw lines and shapes to debug commands
        const BWAPI::UnitCommand command = unit->getLastCommand();
 
        BWAPI::Broodwar->drawCircleMap(unit->getPosition(), 5, info.squadColor, true);
        if (unit == leader) {
            BWAPI::Broodwar->drawCircleMap(unit->getPosition(), 2, BWAPI::Colors::White, true);
            BWAPI::Broodwar->drawTextMap(BWAPI::Position(unit->getPosition().x - 12, unit->getPosition().y + 20), "LEADER", BWAPI::Colors::White);
 
            if (info.currentState == &AttackingState::getInstance()) {
                BWAPI::Broodwar->drawTextMap(BWAPI::Position(unit->getPosition().x - 16, unit->getPosition().y + 25), "-ATTACKING-", BWAPI::Colors::Orange);
            }
            if (info.currentState == &DefendingState::getInstance()) {
                BWAPI::Broodwar->drawTextMap(BWAPI::Position(unit->getPosition().x - 16, unit->getPosition().y + 25), "-DEFENDING-", BWAPI::Colors::Orange);
            }
            if (info.currentState == &IdleState::getInstance()) {
                BWAPI::Broodwar->drawTextMap(BWAPI::Position(unit->getPosition().x - 16, unit->getPosition().y + 25), "-IDLE-", BWAPI::Colors::Orange);
            }
        }
 
        if (command.getTargetPosition() != BWAPI::Positions::None) {
            BWAPI::Broodwar->drawLineMap(unit->getPosition(), command.getTargetPosition(), info.squadColor);
        }
        if (command.getTargetTilePosition() != BWAPI::TilePositions::None) {
            BWAPI::Broodwar->drawLineMap(unit->getPosition(), BWAPI::Position(command.getTargetTilePosition()), info.squadColor);
        }
        if (command.getTarget() != nullptr) {
            BWAPI::Broodwar->drawLineMap(unit->getPosition(), command.getTarget()->getPosition(), info.squadColor);
        }
 
        // Draws squad ID below unit
        const BWAPI::Position textPos(unit->getPosition().x - 20, unit->getPosition().y + 20);
        BWAPI::Broodwar->drawTextMap(textPos, "%d", info.squadId);
    }
}

drawSquadBox()

void Squad::drawSquadBox

(

)

Definition at line 123 of file Squad.cpp.

                         {
    int leftMost = 0;
    int topMost = 0;
    int rightMost = 0;
    int bottomMost = 0;
    constexpr int offset = 16;
 
    // Something for making observer more visible in group
    if (observer != nullptr) {
        const BWAPI::Position topLeft = BWAPI::Position(observer->getPosition().x - offset, observer->getPosition().y - offset);
        const BWAPI::Position bottomRight = BWAPI::Position(observer->getPosition().x + offset, observer->getPosition().y + offset);
        BWAPI::Broodwar->drawBoxMap(topLeft, bottomRight, BWAPI::Colors::Purple);
    }
 
    // Boundary box of the squad
    for (const auto& unit : info.units) {
        const int dist = unit->getPosition().getApproxDistance(leader->getPosition());
        const int maxDist = 300;
        if (dist < maxDist) {
            const int x = unit->getPosition().x - leader->getPosition().x;
            const int y = unit->getPosition().y - leader->getPosition().y;
 
            if (x < leftMost) { leftMost = x; }
            if (x > rightMost) { rightMost = x; }
            if (y < topMost) { topMost = y; }
            if (y > bottomMost) { bottomMost = y; }
        }
    }
 
    // Drawing squad boundary box (color based on squad state)
    const BWAPI::Position topLeft = (leader->getPosition() + BWAPI::Position(leftMost - offset, topMost - offset)).makeValid();
    const BWAPI::Position bottomRight = (leader->getPosition() + BWAPI::Position(rightMost + offset, bottomMost + offset)).makeValid();
    BWAPI::Broodwar->drawBoxMap(topLeft, bottomRight, CombatManager::stateColorMap[info.currentState]);
}

observerOnFrame()

void Squad::observerOnFrame

(

)

Defines the behavior of the observer unit in the squad.

If the observer is not under attack, it will stay above the leader.
If the observer is under attack, it will run towards the base (typically away from enemies).

Definition at line 109 of file Squad.cpp.

                            {
    // No matter the state, observer should have same behavior.
    // If not in danger, stay above leader.
    // Else, run towards base (typically away from enemies)
    if (observer != nullptr && leader != nullptr) {
        if (!observer->isUnderAttack() || observer->getUnitsInRadius(100, BWAPI::Filter::IsEnemy && BWAPI::Filter::CanAttack).empty()) {
            observer->move(leader->getPosition());
        }
        else {
            observer->move(BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation()));
        }
    }
}

onFrame()

void Squad::onFrame

(

)

Definition at line 11 of file Squad.cpp.

                    {
    // Process current squad state
    info.currentState->Update(this);
 
    observerOnFrame();
 
#ifdef DEBUG_SQUAD
    drawDebugInfo();
#endif
}

operator!=()

bool Squad::operator!= ( const Squad & other )

inlinenoexcept

Definition at line 82 of file Squad.h.

                                                     {
        return !(*this == other);
    }

operator==()

bool Squad::operator== ( const Squad & other )

inlinenoexcept

Definition at line 79 of file Squad.h.

                                                     {
        return this->info.squadId == other.info.squadId;
    }

removeUnit()

void Squad::removeUnit

(

BWAPI::Unit

unit

)

Definition at line 30 of file Squad.cpp.

                                    {
    if (unit == nullptr) {
        return;
    }
 
    if (unit == leader) {
        BOIDS::leaderRadiusMap.erase(unit);
        info.units.erase(std::remove(info.units.begin(), info.units.end(), unit), info.units.end());
 
        if (info.units.empty()){
            return;
        }
 
        // Closest unit to the leader is assigned as the new leader
        double closest = std::numeric_limits<double>::infinity();
        BWAPI::Unit closestUnit = nullptr;
        const BWAPI::Position leaderPos = unit->getPosition();
        for (BWAPI::Unit _unit : info.units) {
            if (!_unit || !_unit->exists()) {
                continue;
            }
 
            const BWAPI::Position unitPos = _unit->getPosition();
            const double dist = unitPos.getDistance(leaderPos);
 
            if (dist < closest) {
                closest = dist;
                closestUnit = _unit;
            }
        }
 
        // Assign closest unit to leader as the new leader
        if (closestUnit != nullptr) {
            leader = closestUnit;
        }
    }
    else if (unit == observer) {
        observer = nullptr;
    }
    else {
        info.units.erase(std::remove(info.units.begin(), info.units.end(), unit), info.units.end());
    }
}

setState()

void Squad::setState

(

SquadState &

newState

)

Definition at line 22 of file Squad.cpp.

                                         {
    if (info.currentState != nullptr) {
        info.currentState->Exit(this);
    }
    info.currentState = &newState;
    info.currentState->Enter(this);
}

Member Data Documentation

info

SquadInfo Squad::info

Definition at line 60 of file Squad.h.

leader

BWAPI::Unit Squad::leader = nullptr

Definition at line 58 of file Squad.h.

observer

BWAPI::Unit Squad::observer = nullptr

Definition at line 59 of file Squad.h.

---

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

• src/protobot/Squad.h
• src/protobot/Squad.cpp