ScoutingManager Manages all scouting units and their behaviors. Assigns units to the appropriate scouting behavior, updates them each frame, tracks enemy locations, and coordinates transitions between scouting and combat. More...

#include <ScoutingManager.h>

Public Member Functions
	ScoutingManager (ProtoBotCommander *commander=nullptr)
	Manages all scouting behavior in ProtoBot.
void	onStart ()
	Called once at game start.
void	onFrame ()
	Main update loop executed every frame.
void	assignScout (BWAPI::Unit unit)
	Assigns a unit as a scout and attaches the appropriate behavior.
bool	hasScout () const
	Checks if any scouting units are currently active.
void	setEnemyMain (const BWAPI::TilePosition &tp)
	Sets the enemy main base location and broadcasts it to all scouts.
void	setEnemyNatural (const BWAPI::TilePosition &tp)
	Sets the enemy natural expansion location.
void	onUnitDestroy (BWAPI::Unit unit)
	Handles cleanup when a unit is destroyed.
std::optional< BWAPI::TilePosition >	getEnemyMain () const
std::optional< BWAPI::TilePosition >	getEnemyNatural () const
void	markScout (BWAPI::Unit u)
	Marks a unit as a scout and tracks it by type.
void	unmarkScout (BWAPI::Unit u)
	Removes a unit from scout tracking structures.
bool	isScout (BWAPI::Unit u) const
	Checks whether a unit is currently assigned as a scout.
bool	isCombatScout (BWAPI::Unit u) const
	Checks if a unit is a combat scout (Zealot or Dragoon).
bool	hasWorkerScout () const
void	drawDebug () const
	Draws debug information for all scouting behaviors.
void	drawGlobalDebugPanel () const
void	drawKnownEnemyLocations () const
void	drawScoutDebugFor (BWAPI::Unit unit) const
void	drawScoutTags () const
void	setCombatScoutingStarted (bool v)
bool	combatScoutingStarted () const
bool	canAcceptWorkerScout () const
bool	combatScoutLockActive () const
int	combatScoutLockFramesRemaining () const
void	maybeReturnCombatScoutsToCombat ()
bool	tryReturnScoutToCombat (BWAPI::Unit unit)
	Returns a combat scout unit back to combat control.
bool	isNearActiveCombatSquad (BWAPI::Unit unit) const
void	lockCombatScoutAssignments (int frames)
bool	canAcceptCombatScout (BWAPI::UnitType t) const
bool	canAcceptObserverScout () const
int	numCombatScouts () const
BWAPI::Unit	getAvaliableDetectors ()
	Retrieves an available observer and removes it from scouting.

Public Attributes
bool	scoutingDebugEnabled_ = false
int	combatScoutLockUntilFrame_ = 0

Static Public Attributes
static constexpr int	kScoutReturnToCombatDistPx_ = 10 * 32
static constexpr int	kCombatScoutLockFrames_ = 24 * 10

Private Member Functions
BehaviorVariant	constructBehaviorFor (BWAPI::Unit unit)
	Creates the appropriate scouting behavior for a unit.
int	reserveObserverSlot (int unitId)
void	releaseObserverSlot (int unitId)

Static Private Member Functions
static BWAPI::Unit	findUnitById (int id)

Private Attributes
ProtoBotCommander *	commanderRef = nullptr
std::unordered_map< int, BehaviorVariant >	behaviors_
std::vector< BWAPI::Unit >	scouts_
BWAPI::Unit	workerScout_ { nullptr }
bool	combatScoutingStarted_ { false }
std::optional< BWAPI::TilePosition >	enemyMainCache_
std::optional< BWAPI::TilePosition >	enemyNaturalCache_
bool	inBehaviorFrame_ = false
std::optional< BWAPI::TilePosition >	pendingEnemyMain_
int	maxZealotScouts_ { 2 }
int	maxDragoonScouts_ { 2 }
int	maxObserverScouts_ { 4 }
int	proxyPatrolZealotId_ = -1
std::vector< BWAPI::Unit >	combatZealots_
std::vector< BWAPI::Unit >	combatDragoons_
std::vector< BWAPI::Unit >	observerScouts_
int	observerSlotOwner_ [4] = { -1, -1, -1, -1 }
std::vector< BWAPI::Unit >	darkTemplarScouts_

Detailed Description

ScoutingManager Manages all scouting units and their behaviors. Assigns units to the appropriate scouting behavior, updates them each frame, tracks enemy locations, and coordinates transitions between scouting and combat.

Definition at line 44 of file ScoutingManager.h.

Constructor & Destructor Documentation

◆ ScoutingManager()

ScoutingManager::ScoutingManager ( ProtoBotCommander * commander = nullptr )

explicit

Manages all scouting behavior in ProtoBot.

Responsibilities:

Assign scouting units and attach behaviors
Manage scouting state and unit roles
Track enemy main and natural locations
Coordinate transitions between scouting and combat

Uses a BehaviorVariant system to support multiple scout types:

Probe
Zealot / Dragoon
Observer
Dark Templar

Initializes the ScoutingManager with a reference to the commander.

Parameters

commander Pointer to ProtoBotCommander

Definition at line 25 of file ScoutingManager.cpp.

    : commanderRef(commander)
{
}

Member Function Documentation

◆ assignScout()

void ScoutingManager::assignScout ( BWAPI::Unit unit )

Assigns a unit as a scout and attaches the appropriate behavior.

Handles different unit types:

Worker (Probe scout)
Observer (detector scouting)
Combat units (Zealot / Dragoon scouting)

Also removes the unit from combat control.

Parameters

unit	Unit to assign as a scout

Definition at line 134 of file ScoutingManager.cpp.

{
    if (!unit || !unit->exists()) return;
 
    const auto t = unit->getType();
 
    if (t.isWorker())
    {
        if (workerScout_ && workerScout_->exists()) return;
    }
    else if (t == BWAPI::UnitTypes::Protoss_Observer)
    {
        if (!canAcceptObserverScout()) return;
        int slot = reserveObserverSlot(unit->getID());
        if (slot < 0) return;
    }
    else
    {
        // zealot or dragoon
        if (!canAcceptCombatScout(unit->getType()))
        {
            return;
        }
    }
    // build a behavior instance for THIS unit and store by id
    BehaviorVariant sb = constructBehaviorFor(unit);
    
    if (t == BWAPI::UnitTypes::Protoss_Zealot)
    {
        if (proxyPatrolZealotId_ == -1)
        {
            proxyPatrolZealotId_ = unit->getID();
        }
 
        if (auto* z = std::get_if<ScoutingZealot>(&sb))
        {
            z->setProxyPatroller(unit->getID() == proxyPatrolZealotId_);
        }
    }
 
    if (t == BWAPI::UnitTypes::Protoss_Observer) 
    {
        // find slot we reserved (it�s in observerSlotOwner_)
        int slot = -1;
        for (int i = 0; i < 4; ++i) if (observerSlotOwner_[i] == unit->getID()) { slot = i; break; }
        if (slot >= 0) {
            if (auto* ob = std::get_if<ScoutingObserver>(&sb)) 
            {
                ob->setObserverSlot(slot);
            }
            observerScouts_.push_back(unit);
        }
    }
 
    visit_start(sb);
    visit_assign(sb, unit);
 
    // cache into the map (overwrite if re-assigning the same id)
    behaviors_[unit->getID()] = std::move(sb);
 
    if (commanderRef)
    {
        commanderRef->combatManager.detachUnit(unit);
    }
 
    // bookkeeping
    markScout(unit);
}

◆ canAcceptCombatScout()

bool ScoutingManager::canAcceptCombatScout ( BWAPI::UnitType t ) const

inline

Definition at line 92 of file ScoutingManager.h.

    {
        if (t == BWAPI::UnitTypes::Protoss_Dark_Templar)
        {
            return true;
        }
 
        if (combatScoutLockActive())
        {
            return false;
        }
 
        if (t == BWAPI::UnitTypes::Protoss_Zealot)
        {
            return int(combatZealots_.size()) < maxZealotScouts_;
        }
 
        if (t == BWAPI::UnitTypes::Protoss_Dragoon)
        {
            return int(combatDragoons_.size()) < maxDragoonScouts_;
        }
 
        return false;
    }

◆ canAcceptObserverScout()

bool ScoutingManager::canAcceptObserverScout ( ) const

inline

Definition at line 117 of file ScoutingManager.h.

117{ return (int)observerScouts_.size() < maxObserverScouts_; }

◆ canAcceptWorkerScout()

bool ScoutingManager::canAcceptWorkerScout ( ) const

inline

Definition at line 78 of file ScoutingManager.h.

78{ return !combatScoutingStarted_ && !workerScout_; }

◆ combatScoutingStarted()

bool ScoutingManager::combatScoutingStarted ( ) const

inline

Definition at line 76 of file ScoutingManager.h.

76{ return combatScoutingStarted_; }

◆ combatScoutLockActive()

bool ScoutingManager::combatScoutLockActive ( ) const

Definition at line 758 of file ScoutingManager.cpp.

{
    return BWAPI::Broodwar->getFrameCount() < combatScoutLockUntilFrame_;
}

◆ combatScoutLockFramesRemaining()

int ScoutingManager::combatScoutLockFramesRemaining ( ) const

Definition at line 763 of file ScoutingManager.cpp.

{
    const int remaining = combatScoutLockUntilFrame_ - BWAPI::Broodwar->getFrameCount();
    return remaining > 0 ? remaining : 0;
}

◆ constructBehaviorFor()

BehaviorVariant ScoutingManager::constructBehaviorFor ( BWAPI::Unit unit )

private

Creates the appropriate scouting behavior for a unit.

Supports:

Probe
Zealot / Dragoon
Observer
Dark Templar

Falls back to Probe behavior if type is unsupported.

Parameters

unit	Unit to create behavior for

Returns: BehaviorVariant representing the unit's scouting logic

Definition at line 377 of file ScoutingManager.cpp.

{
    const auto t = unit->getType();
 
    if (t == BWAPI::UnitTypes::Protoss_Probe) 
    {
        ScoutingProbe probe(commanderRef, this);
        // pass cache if we already know main
        if (enemyMainCache_) probe.setEnemyMain(*enemyMainCache_);
        //BWAPI::Broodwar->printf("[SM] behavior = Probe for id=%d", unit->getID());
        return probe;
    }
 
    if (t == BWAPI::UnitTypes::Protoss_Zealot || t == BWAPI::UnitTypes::Protoss_Dragoon) 
    {
        ScoutingZealot z(commanderRef, this);
        if (enemyMainCache_) z.setEnemyMain(*enemyMainCache_);
        //BWAPI::Broodwar->printf("[SM] behavior = ZealotBehavior for %s id=%d",
          //  t.c_str(), unit->getID());
        return z;
    }
 
    if (t == BWAPI::UnitTypes::Protoss_Observer) 
    {
        ScoutingObserver o(commanderRef, this);
        if (enemyMainCache_) o.setEnemyMain(*enemyMainCache_);
        //BWAPI::Broodwar->printf("[SM] behavior = Observer for id=%d", unit->getID());
        return o;
    }
 
    if (t == BWAPI::UnitTypes::Protoss_Dark_Templar)
    {
        DarkTemplar dt(commanderRef, this);
 
        if (enemyMainCache_)
        {
            dt.setEnemyMain(*enemyMainCache_);
        }
 
        return dt;
    }
 
    // fallback
    ScoutingProbe fallback(commanderRef, this);
    if (enemyMainCache_) fallback.setEnemyMain(*enemyMainCache_);
   // BWAPI::Broodwar->printf("[SM] behavior = Fallback->Probe for id=%d", unit->getID());
    return fallback;
}

◆ drawDebug()

void ScoutingManager::drawDebug ( ) const

Draws debug information for all scouting behaviors.

Includes:

Global scouting info
Enemy locations
Per-unit debug visuals

Definition at line 601 of file ScoutingManager.cpp.

{
    if (!scoutingDebugEnabled_)
    {
        return;
    }
 
    drawGlobalDebugPanel();
    drawKnownEnemyLocations();
 
    for (const auto& [id, sb] : behaviors_)
    {
        std::visit(DrawBehaviorDebugVisitor{}, sb);
    }
}

◆ drawGlobalDebugPanel()

void ScoutingManager::drawGlobalDebugPanel ( ) const

Definition at line 617 of file ScoutingManager.cpp.

{
 
    int x = 10;
    int y = 30;
 
    BWAPI::Broodwar->drawTextScreen(x, y, "\x07Scouting Debug");
    y += 14;
 
    BWAPI::Broodwar->drawTextScreen(
        x,
        y,
        "Enemy Main: %s",
        enemyMainCache_.has_value() ? "\x07Known" : "\x08Unknown"
    );
    y += 12;
 
    BWAPI::Broodwar->drawTextScreen(
        x,
        y,
        "Worker Scout: %s",
        (workerScout_ && workerScout_->exists()) ? "\x07 Active" : "\x08None"
    );
    y += 12;
 
    BWAPI::Broodwar->drawTextScreen(x, y, "Combat Scouts: %d", numCombatScouts());
    y += 12;
 
    BWAPI::Broodwar->drawTextScreen(x, y, "Observer Scouts: %d", (int)observerScouts_.size());
    y += 12;
 
    const int totalScouts =
        (workerScout_ && workerScout_->exists() ? 1 : 0) +
        (int)combatZealots_.size() +
        (int)combatDragoons_.size() +
        (int)observerScouts_.size() +
        (int)darkTemplarScouts_.size();
 
    BWAPI::Broodwar->drawTextScreen(x, y, "All Scouts: %d", totalScouts);
    y += 12;
 
    BWAPI::Broodwar->drawTextScreen(
        x,
        y,
        "Combat Scouting Started: %s",
        combatScoutingStarted_ ? "\x07Yes" : "\x08No"
    );
}

◆ drawKnownEnemyLocations()

void ScoutingManager::drawKnownEnemyLocations ( ) const

Definition at line 666 of file ScoutingManager.cpp.

{
 
    if (enemyMainCache_.has_value())
    {
        BWAPI::Position p(enemyMainCache_.value());
        BWAPI::Broodwar->drawCircleMap(p, 96, BWAPI::Colors::Cyan, false);
        BWAPI::Broodwar->drawTextMap(p.x, p.y - 18, "\x0f Enemy Main");
    }
 
}

◆ drawScoutDebugFor()

void ScoutingManager::drawScoutDebugFor ( BWAPI::Unit unit ) const

Definition at line 678 of file ScoutingManager.cpp.

{
    if (!unit || !unit->exists())
    {
        return;
    }
 
    const BWAPI::Position p = unit->getPosition();
 
    BWAPI::Broodwar->drawCircleMap(p, 18, BWAPI::Colors::Green, false);
 
    const BWAPI::UnitType t = unit->getType();
 
    const char* role = "Scout";
 
    if (t == BWAPI::UnitTypes::Protoss_Probe)
    {
        role = "Probe Scout";
    }
    else if (t == BWAPI::UnitTypes::Protoss_Zealot)
    {
        role = "Zealot Scout";
    }
    else if (t == BWAPI::UnitTypes::Protoss_Dragoon)
    {
        role = "Dragoon Scout";
    }
    else if (t == BWAPI::UnitTypes::Protoss_Observer)
    {
        role = "Observer Scout";
    }
    else if (t == BWAPI::UnitTypes::Protoss_Dark_Templar)
    {
        role = "DT Scout";
    }
 
    BWAPI::Broodwar->drawTextMap(p.x - 28, p.y - 30, "\x07%s", role);
 
    if (enemyMainCache_.has_value())
    {
        BWAPI::Position mainPos(enemyMainCache_.value());
        BWAPI::Broodwar->drawLineMap(p, mainPos, BWAPI::Colors::Green);
    }
 
    if (enemyNaturalCache_.has_value())
    {
        BWAPI::Position natPos(enemyNaturalCache_.value());
        BWAPI::Broodwar->drawCircleMap(natPos, 16, BWAPI::Colors::Orange, false);
    }
}

◆ drawScoutTags()

void ScoutingManager::drawScoutTags ( ) const

Definition at line 731 of file ScoutingManager.cpp.

{
    if (workerScout_ && workerScout_->exists()) 
    {
        const auto p = workerScout_->getPosition();
        //BWAPI::Broodwar->drawTextMap(p.x - 16, p.y + 20, "\x07SCOUT (Worker)");
    }
    for (auto u : combatZealots_) 
    {
        if (!u || !u->exists()) continue;
        const auto p = u->getPosition();
        //BWAPI::Broodwar->drawTextMap(p.x - 16, p.y + 20, "\x07SCOUT (Zealot)");
    }
    for (auto u : combatDragoons_) 
    {
        if (!u || !u->exists()) continue;
        const auto p = u->getPosition();
        //BWAPI::Broodwar->drawTextMap(p.x - 16, p.y + 20, "\x07SCOUT (Dragoon)");
    }
    for (auto u : observerScouts_) 
    {
        if (!u || !u->exists()) continue;
        const auto p = u->getPosition();
        //BWAPI::Broodwar->drawTextMap(p.x - 16, p.y + 32, "\x10SCOUT (Observer)");
    }
}

◆ findUnitById()

BWAPI::Unit ScoutingManager::findUnitById ( int id )

staticprivate

Definition at line 426 of file ScoutingManager.cpp.

{
    for (auto u : BWAPI::Broodwar->self()->getUnits())
        if (u && u->exists() && u->getID() == id) return u;
    return nullptr;
}

◆ getAvaliableDetectors()

BWAPI::Unit ScoutingManager::getAvaliableDetectors ( )

Retrieves an available observer and removes it from scouting.

Transfers control back to combat systems.

Returns: Observer unit if available, otherwise nullptr

Definition at line 915 of file ScoutingManager.cpp.

{
    for (auto it = observerScouts_.begin(); it != observerScouts_.end(); ++it)
    {
        BWAPI::Unit obs = *it;
        if (!obs || !obs->exists())
            continue;
 
        const int id = obs->getID();
 
        // 1) Remove behavior so ScoutingManager stops controlling it
        auto bIt = behaviors_.find(id);
        if (bIt != behaviors_.end())
        {
            // Let the behavior clean itself up
            visit_onUnitDestroy(bIt->second, obs);
            behaviors_.erase(bIt);
        }
 
        // 2) Release observer slot
        releaseObserverSlot(id);
 
        // 3) Remove from scout bookkeeping
        observerScouts_.erase(it);
 
        // 4) Done: return unit to combat
        //BWAPI::Broodwar->printf("[SM] Reassigning Observer %d to combat", id);
        return obs;
    }
 
    // No available observers
    return nullptr;
}

◆ getEnemyMain()

std::optional< BWAPI::TilePosition > ScoutingManager::getEnemyMain ( ) const

inline

Definition at line 60 of file ScoutingManager.h.

60{ return enemyMainCache_; }

◆ getEnemyNatural()

std::optional< BWAPI::TilePosition > ScoutingManager::getEnemyNatural ( ) const

inline

Definition at line 61 of file ScoutingManager.h.

61{ return enemyNaturalCache_; }

◆ hasScout()

bool ScoutingManager::hasScout ( ) const

Checks if any scouting units are currently active.

Returns: True if at least one scout exists

Definition at line 208 of file ScoutingManager.cpp.

{
    if (workerScout_ && workerScout_->exists())
    {
        return true;
    }
 
    for (auto u : combatZealots_)
    {
        if (u && u->exists())
        {
            return true;
        }
    }
 
    for (auto u : combatDragoons_)
    {
        if (u && u->exists())
        {
            return true;
        }
    }
 
    for (auto u : observerScouts_)
    {
        if (u && u->exists())
        {
            return true;
        }
    }
 
    for (auto u : darkTemplarScouts_)
    {
        if (u && u->exists())
        {
            return true;
        }
    }
 
    return false;
}

◆ hasWorkerScout()

bool ScoutingManager::hasWorkerScout ( ) const

Definition at line 560 of file ScoutingManager.cpp.

560{ return workerScout_ && workerScout_->exists(); }

◆ isCombatScout()

bool ScoutingManager::isCombatScout ( BWAPI::Unit u ) const

Checks if a unit is a combat scout (Zealot or Dragoon).

Parameters

u	Unit to check

Returns: True if unit is a combat scout

Definition at line 550 of file ScoutingManager.cpp.

{
    if (!u) return false;
    if (std::find(combatZealots_.begin(), combatZealots_.end(), u) != combatZealots_.end())
        return true;
    if (std::find(combatDragoons_.begin(), combatDragoons_.end(), u) != combatDragoons_.end())
        return true;
    return false;
}

◆ isNearActiveCombatSquad()

bool ScoutingManager::isNearActiveCombatSquad ( BWAPI::Unit unit ) const

Definition at line 863 of file ScoutingManager.cpp.

{
    if (!unit || !unit->exists() || !commanderRef)
    {
        return false;
    }
 
    auto nearAnySquad =
        [&](const std::vector<Squad*>& squads) -> bool
        {
            for (const Squad* squad : squads)
            {
                if (!squad || !squad->leader || !squad->leader->exists())
                {
                    continue;
                }
 
                if (unit->getDistance(squad->leader) <= kScoutReturnToCombatDistPx_)
                {
                    return true;
                }
            }
 
            return false;
        };
 
    if (nearAnySquad(CombatManager::AttackingSquads))
    {
        return true;
    }
 
    if (nearAnySquad(CombatManager::ReinforcingSquads))
    {
        return true;
    }
 
    return false;
}

◆ isScout()

bool ScoutingManager::isScout ( BWAPI::Unit u ) const

Checks whether a unit is currently assigned as a scout.

Parameters

u	Unit to check

Returns: True if the unit is a scout

Definition at line 533 of file ScoutingManager.cpp.

{
    if (!u)                                                                                                 return false;
    if (workerScout_ == u)                                                                                  return true;
    if (std::find(combatZealots_.begin(), combatZealots_.end(), u) != combatZealots_.end())                 return true;
    if (std::find(combatDragoons_.begin(), combatDragoons_.end(), u) != combatDragoons_.end())              return true;
    if (std::find(observerScouts_.begin(), observerScouts_.end(), u) != observerScouts_.end())              return true;
    if (std::find(darkTemplarScouts_.begin(), darkTemplarScouts_.end(), u) != darkTemplarScouts_.end())     return true;
    return false;
}

◆ lockCombatScoutAssignments()

void ScoutingManager::lockCombatScoutAssignments ( int frames )

Definition at line 902 of file ScoutingManager.cpp.

{
    const int now = BWAPI::Broodwar->getFrameCount();
    combatScoutLockUntilFrame_ = std::max(combatScoutLockUntilFrame_, now + frames);
}

◆ markScout()

void ScoutingManager::markScout ( BWAPI::Unit u )

Marks a unit as a scout and tracks it by type.

Adds the unit to the appropriate scouting collection.

Parameters

u	Unit to mark as scout

Definition at line 440 of file ScoutingManager.cpp.

{
    if (!u || !u->exists()) return;
 
    const auto t = u->getType();
 
    if (t.isWorker()) {
        if (!workerScout_) workerScout_ = u;
        return;
    }
 
    if (t == BWAPI::UnitTypes::Protoss_Observer)
    {
        if (std::find(observerScouts_.begin(), observerScouts_.end(), u) == observerScouts_.end())
        {
            observerScouts_.push_back(u);
        }
        return;
    }
    if (t == BWAPI::UnitTypes::Protoss_Zealot) {
        if ((int)combatZealots_.size() < maxZealotScouts_ &&
            std::find(combatZealots_.begin(), combatZealots_.end(), u) == combatZealots_.end()) {
            combatZealots_.push_back(u);
        }
        return;
    }
 
    if (t == BWAPI::UnitTypes::Protoss_Dragoon) {
        if ((int)combatDragoons_.size() < maxDragoonScouts_ &&
            std::find(combatDragoons_.begin(), combatDragoons_.end(), u) == combatDragoons_.end()) {
            combatDragoons_.push_back(u);
        }
        return;
    }
    if (t == BWAPI::UnitTypes::Protoss_Dark_Templar)
    {
        if (std::find(darkTemplarScouts_.begin(), darkTemplarScouts_.end(), u) == darkTemplarScouts_.end())
        {
            darkTemplarScouts_.push_back(u);
        }
        return;
    }
}

◆ maybeReturnCombatScoutsToCombat()

void ScoutingManager::maybeReturnCombatScoutsToCombat ( )

Definition at line 769 of file ScoutingManager.cpp.

{
    std::vector<BWAPI::Unit> candidates;
 
    candidates.reserve(combatZealots_.size() + combatDragoons_.size());
 
    for (BWAPI::Unit u : combatZealots_)
    {
        if (u && u->exists())
        {
            candidates.push_back(u);
        }
    }
 
    for (BWAPI::Unit u : combatDragoons_)
    {
        if (u && u->exists())
        {
            candidates.push_back(u);
        }
    }
 
    for (BWAPI::Unit u : candidates)
    {
        if (!u || !u->exists())
        {
            continue;
        }
 
        if (isNearActiveCombatSquad(u))
        {
            tryReturnScoutToCombat(u);
        }
    }
}

◆ numCombatScouts()

int ScoutingManager::numCombatScouts ( ) const

inline

Definition at line 120 of file ScoutingManager.h.

    {
        return int(combatZealots_.size() + combatDragoons_.size());
    }

◆ onFrame()

void ScoutingManager::onFrame ( )

Main update loop executed every frame.

Updates all active scouting behaviors and handles:

Deferred enemy main detection
Returning scouts to combat
Debug drawing

Definition at line 97 of file ScoutingManager.cpp.

{
    // iterate all active behaviors; each owns its own state
    inBehaviorFrame_ = true;
    for (auto& [id, sb] : behaviors_)
    {
        visit_frame(sb);
    }
    inBehaviorFrame_ = false;
 
    if (!enemyMainCache_.has_value() && pendingEnemyMain_.has_value())
    {
        const auto tp = *pendingEnemyMain_;
        pendingEnemyMain_.reset();
        setEnemyMain(tp); // now it is safe to broadcast
    }
 
    maybeReturnCombatScoutsToCombat();
 
    if (scoutingDebugEnabled_) 
    {
        drawDebug();
    }
}

◆ onStart()

void ScoutingManager::onStart ( )

Called once at game start.

Used to initialize scouting systems.

Definition at line 36 of file ScoutingManager.cpp.

{
    //std::cout << "Scouting Manager Initialized\n";
    //drawScoutTags();
}

◆ onUnitDestroy()

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

Handles cleanup when a unit is destroyed.

Removes scouting behavior and updates tracking structures.

Parameters

unit	Destroyed unit

Definition at line 310 of file ScoutingManager.cpp.

{
    if (!unit)
    {
        return;
    }
 
    const int id = unit->getID();
 
    // Only do anything if it was a scout or had a behavior.
    const bool hadBehavior = behaviors_.find(id) != behaviors_.end();
    const bool wasScout = isScout(unit);
 
    if (!hadBehavior && !wasScout)
    {
        return;
    }
 
    unmarkScout(unit);
 
    if (id == proxyPatrolZealotId_)
    {
        proxyPatrolZealotId_ = -1;
    }
 
    auto it = behaviors_.find(id);
    if (it != behaviors_.end())
    {
        visit_onUnitDestroy(it->second, unit);
        behaviors_.erase(it);
    }
 
    releaseObserverSlot(id);
    observerScouts_.erase(std::remove(observerScouts_.begin(), observerScouts_.end(), unit),
        observerScouts_.end());
 
}

◆ releaseObserverSlot()

void ScoutingManager::releaseObserverSlot ( int unitId )

private

Definition at line 358 of file ScoutingManager.cpp.

{
    for (int i = 0; i < 4; ++i) if (observerSlotOwner_[i] == unitId) observerSlotOwner_[i] = -1;
}

◆ reserveObserverSlot()

int ScoutingManager::reserveObserverSlot ( int unitId )

private

Definition at line 348 of file ScoutingManager.cpp.

{
    // priority order is 0..3; pick first free
    for (int i = 0; i < 4; ++i) 
    {
        if (observerSlotOwner_[i] == -1) { observerSlotOwner_[i] = unitId; return i; }
    }
    return -1;
}

◆ setCombatScoutingStarted()

void ScoutingManager::setCombatScoutingStarted ( bool v )

inline

Definition at line 75 of file ScoutingManager.h.

75{ combatScoutingStarted_ = v; }

◆ setEnemyMain()

void ScoutingManager::setEnemyMain ( const BWAPI::TilePosition & tp )

Sets the enemy main base location and broadcasts it to all scouts.

If called during a behavior frame, the update is deferred to avoid modifying state mid-iteration.

Parameters

tp	Enemy main tile position

Definition at line 258 of file ScoutingManager.cpp.

{
    if (!tp.isValid())
    {
        return;
    }
 
    // Already known: ignore duplicates
    if (enemyMainCache_.has_value())
    {
        return;
    }
 
    // If called from inside behavior onFrame, defer the broadcast
    if (inBehaviorFrame_)
    {
        pendingEnemyMain_ = tp;
        return;
    }
 
    // Commit + broadcast
    enemyMainCache_ = tp;
 
    if (commanderRef)
    {
        commanderRef->onEnemyMainFound(tp);
    }
 
    for (auto& [id, sb] : behaviors_)
    {
        visit_setEnemyMain(sb, tp);
    }
}

◆ setEnemyNatural()

void ScoutingManager::setEnemyNatural ( const BWAPI::TilePosition & tp )

Sets the enemy natural expansion location.

Parameters

tp	Enemy natural tile position

Definition at line 297 of file ScoutingManager.cpp.

{
    enemyNaturalCache_ = tp;
    if (commanderRef) commanderRef->onEnemyNaturalFound(tp);
}

◆ tryReturnScoutToCombat()

bool ScoutingManager::tryReturnScoutToCombat ( BWAPI::Unit unit )

Returns a combat scout unit back to combat control.

Removes scouting behavior and reassigns the unit to CombatManager.

Parameters

unit	Unit to return

Returns: True if reassignment succeeded

Definition at line 813 of file ScoutingManager.cpp.

{
    if (!unit || !unit->exists() || !commanderRef)
    {
        return false;
    }
 
    const BWAPI::UnitType t = unit->getType();
 
    // ONLY ScoutingZealot units (Zealot + Dragoon)
    if (t != BWAPI::UnitTypes::Protoss_Zealot &&
        t != BWAPI::UnitTypes::Protoss_Dragoon)
    {
        return false;
    }
 
    if (!isScout(unit))
    {
        return false;
    }
 
    const int id = unit->getID();
 
    // If this was the proxy patrol unit, clear it
    if (id == proxyPatrolZealotId_)
    {
        proxyPatrolZealotId_ = -1;
    }
 
    // Remove behavior
    auto it = behaviors_.find(id);
    if (it != behaviors_.end())
    {
        visit_onUnitDestroy(it->second, unit);
        behaviors_.erase(it);
    }
 
    // Remove from scout tracking
    unmarkScout(unit);
 
    // Give back to combat
    if (commanderRef->combatManager.assignUnit(unit))
    {
        lockCombatScoutAssignments(kCombatScoutLockFrames_);
        return true;
    }
 
    return false;
}

◆ unmarkScout()

void ScoutingManager::unmarkScout ( BWAPI::Unit u )

Removes a unit from scout tracking structures.

Parameters

u	Unit to remove

Definition at line 489 of file ScoutingManager.cpp.

{
    if (!u) return;
 
    if (workerScout_ == u) {
        workerScout_ = nullptr;
        return;
    }
 
    if (u->getType() == BWAPI::UnitTypes::Protoss_Zealot) {
        combatZealots_.erase(std::remove(combatZealots_.begin(), combatZealots_.end(), u),
            combatZealots_.end());
        return;
    }
 
    if (u->getType() == BWAPI::UnitTypes::Protoss_Dragoon) {
        combatDragoons_.erase(std::remove(combatDragoons_.begin(), combatDragoons_.end(), u),
            combatDragoons_.end());
        return;
    }
 
    if (u->getType() == BWAPI::UnitTypes::Protoss_Dark_Templar)
    {
        darkTemplarScouts_.erase(std::remove(darkTemplarScouts_.begin(), darkTemplarScouts_.end(), u),
            darkTemplarScouts_.end());
        return;
    }
 
    combatZealots_.erase(std::remove(combatZealots_.begin(), combatZealots_.end(), u),
        combatZealots_.end());
    combatDragoons_.erase(std::remove(combatDragoons_.begin(), combatDragoons_.end(), u),
        combatDragoons_.end());
    observerScouts_.erase(std::remove(observerScouts_.begin(), observerScouts_.end(), u), 
        observerScouts_.end());
    darkTemplarScouts_.erase(std::remove(darkTemplarScouts_.begin(), darkTemplarScouts_.end(), u),
        darkTemplarScouts_.end());
}

Member Data Documentation

◆ behaviors_

std::unordered_map<int, BehaviorVariant> ScoutingManager::behaviors_

private

Definition at line 131 of file ScoutingManager.h.

◆ combatDragoons_

std::vector<BWAPI::Unit> ScoutingManager::combatDragoons_

private

Definition at line 154 of file ScoutingManager.h.

◆ combatScoutingStarted_

bool ScoutingManager::combatScoutingStarted_ { false }

private

Definition at line 139 of file ScoutingManager.h.

139{ false };

◆ combatScoutLockUntilFrame_

int ScoutingManager::combatScoutLockUntilFrame_ = 0

Definition at line 88 of file ScoutingManager.h.

◆ combatZealots_

std::vector<BWAPI::Unit> ScoutingManager::combatZealots_

private

Definition at line 153 of file ScoutingManager.h.

◆ commanderRef

ProtoBotCommander* ScoutingManager::commanderRef = nullptr

private

Definition at line 128 of file ScoutingManager.h.

◆ darkTemplarScouts_

std::vector<BWAPI::Unit> ScoutingManager::darkTemplarScouts_

private

Definition at line 165 of file ScoutingManager.h.

◆ enemyMainCache_

std::optional<BWAPI::TilePosition> ScoutingManager::enemyMainCache_

private

Definition at line 140 of file ScoutingManager.h.

◆ enemyNaturalCache_

std::optional<BWAPI::TilePosition> ScoutingManager::enemyNaturalCache_

private

Definition at line 141 of file ScoutingManager.h.

◆ inBehaviorFrame_

bool ScoutingManager::inBehaviorFrame_ = false

private

Definition at line 143 of file ScoutingManager.h.

◆ kCombatScoutLockFrames_

int ScoutingManager::kCombatScoutLockFrames_ = 24 * 10

staticconstexpr

Definition at line 90 of file ScoutingManager.h.

◆ kScoutReturnToCombatDistPx_

int ScoutingManager::kScoutReturnToCombatDistPx_ = 10 * 32

staticconstexpr

Definition at line 89 of file ScoutingManager.h.

◆ maxDragoonScouts_

int ScoutingManager::maxDragoonScouts_ { 2 }

private

Definition at line 148 of file ScoutingManager.h.

148{ 2 };

◆ maxObserverScouts_

int ScoutingManager::maxObserverScouts_ { 4 }

private

Definition at line 149 of file ScoutingManager.h.

149{ 4 };

◆ maxZealotScouts_

int ScoutingManager::maxZealotScouts_ { 2 }

private

Definition at line 147 of file ScoutingManager.h.

147{ 2 };

◆ observerScouts_

std::vector<BWAPI::Unit> ScoutingManager::observerScouts_

private

Definition at line 158 of file ScoutingManager.h.

◆ observerSlotOwner_

int ScoutingManager::observerSlotOwner_[4] = { -1, -1, -1, -1 }

private

Definition at line 159 of file ScoutingManager.h.

159{ -1, -1, -1, -1 }; // unitID or -1

◆ pendingEnemyMain_

std::optional<BWAPI::TilePosition> ScoutingManager::pendingEnemyMain_

private

Definition at line 144 of file ScoutingManager.h.

◆ proxyPatrolZealotId_

int ScoutingManager::proxyPatrolZealotId_ = -1

private

Definition at line 151 of file ScoutingManager.h.

◆ scoutingDebugEnabled_

bool ScoutingManager::scoutingDebugEnabled_ = false

Definition at line 46 of file ScoutingManager.h.

◆ scouts_

std::vector<BWAPI::Unit> ScoutingManager::scouts_

private

Definition at line 137 of file ScoutingManager.h.

◆ workerScout_

BWAPI::Unit ScoutingManager::workerScout_ { nullptr }

private

Definition at line 138 of file ScoutingManager.h.

138{ nullptr };

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

src/protobot/ScoutingManager.h
src/protobot/ScoutingManager.cpp

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ScoutingManager()

Member Function Documentation

◆ assignScout()

◆ canAcceptCombatScout()

◆ canAcceptObserverScout()

◆ canAcceptWorkerScout()

◆ combatScoutingStarted()

◆ combatScoutLockActive()

◆ combatScoutLockFramesRemaining()

◆ constructBehaviorFor()

◆ drawDebug()

◆ drawGlobalDebugPanel()

◆ drawKnownEnemyLocations()

◆ drawScoutDebugFor()

◆ drawScoutTags()

◆ findUnitById()

◆ getAvaliableDetectors()

◆ getEnemyMain()

◆ getEnemyNatural()

◆ hasScout()

◆ hasWorkerScout()

◆ isCombatScout()

◆ isNearActiveCombatSquad()

◆ isScout()

◆ lockCombatScoutAssignments()

◆ markScout()

◆ maybeReturnCombatScoutsToCombat()

◆ numCombatScouts()

◆ onFrame()

◆ onStart()

◆ onUnitDestroy()

◆ releaseObserverSlot()

◆ reserveObserverSlot()

◆ setCombatScoutingStarted()

◆ setEnemyMain()

◆ setEnemyNatural()

◆ tryReturnScoutToCombat()

◆ unmarkScout()

Member Data Documentation

◆ behaviors_

◆ combatDragoons_

◆ combatScoutingStarted_

◆ combatScoutLockUntilFrame_

◆ combatZealots_

◆ commanderRef

◆ darkTemplarScouts_

◆ enemyMainCache_

◆ enemyNaturalCache_

◆ inBehaviorFrame_

◆ kCombatScoutLockFrames_

◆ kScoutReturnToCombatDistPx_

◆ maxDragoonScouts_

◆ maxObserverScouts_

◆ maxZealotScouts_

◆ observerScouts_

◆ observerSlotOwner_

◆ pendingEnemyMain_

◆ proxyPatrolZealotId_

◆ scoutingDebugEnabled_

◆ scouts_

◆ workerScout_