ScoutingObserver Controls scouting behavior for a Protoss Observer. Maintains vision over key enemy locations, avoids detection threats, and monitors expansions using a slot-based system. Observers either hold fixed positions near the enemy base or dynamically patrol expansion locations to provide map awareness. More...

#include <ScoutingObserver.h>

Public Member Functions
	ScoutingObserver (ProtoBotCommander cmd=nullptr, ScoutingManager mgr=nullptr)
void	onStart ()
	Initializes the observer scouting state.
void	onFrame ()
	Main update loop executed every frame.
void	onUnitDestroy (BWAPI::Unit u)
	Handles observer destruction.
void	assign (BWAPI::Unit u)
	Assigns a unit as the scouting observer.
void	setEnemyMain (const BWAPI::TilePosition &tp)
	Sets the enemy main base and recomputes observation posts.
void	setObserverSlot (int idx)
void	drawDebug () const
	Draws debug information for the observer on the map.

Private Types
enum class	State { Idle , MoveToPost , Hold , AvoidDetection , Done }

Private Member Functions
void	computePosts ()
	Computes observation posts around the enemy base.
BWAPI::Position	postTarget () const
	Returns the current target position for this observer.
void	issueMove (const BWAPI::Position &p, bool force=false, int reissueDist=64)
	Issues a movement command to the observer.
bool	detectorThreat (BWAPI::Position &avoidTo) const
	Detects nearby enemy detectors and computes a safe escape position.
bool	isUnsafe (const BWAPI::Position &p) const
	Determines if a position is unsafe based on threat data.
BWAPI::Position	pickDetourToward (const BWAPI::Position &target) const
	Selects a safe detour toward a target position.
bool	haveVisionAt (const BWAPI::Position &p, int radiusPx) const
	Checks whether the bot currently has vision at a position.
void	rebuildSlot3Checkpoints ()
	Rebuilds roaming checkpoints for slot 3 observers.

Static Private Member Functions
static int	detectionRadiusFor (const BWAPI::UnitType &t)
static BWAPI::Position	clampToMapPx (const BWAPI::Position &p, int margin=16)
static double	groundPathLengthPx (const BWAPI::Position &from, const BWAPI::Position &to)

Private Attributes
ProtoBotCommander *	commanderRef = nullptr
ScoutingManager *	manager = nullptr
BWAPI::Unit	observer { nullptr }
State	state = State::Idle
std::vector< BWAPI::Position >	posts
int	slotIndex = -1
std::optional< BWAPI::TilePosition >	enemyMainTile
BWAPI::Position	enemyMainPos = BWAPI::Positions::Invalid
int	lastMoveFrame = 0
int	lastThreatFrame = -10000
BWAPI::Position	slot3Home = BWAPI::Positions::Invalid
bool	slot3HomeSet = false
bool	slot3ReturningHome = false
std::vector< BWAPI::Position >	slot3Checkpoints
int	slot3NextRebuildFrame = 0
bool	slot3NeedsRebuild = false
int	slot3NextIdx = 0
int	slot3NextMoveFrame = 0
BWAPI::Position	slot3CurTarget = BWAPI::Positions::Invalid

Static Private Attributes
static constexpr int	kMoveCooldown = 6
static constexpr int	kSafeFramesToReturn = 48
static constexpr int	kEdgeMarginPx = 8
static constexpr int	kHoldReissueDist = 16
static constexpr int	kAirThreatThreshold = 40
static constexpr int	kDetectReactBufferPx = 48
static constexpr int	kSlot3RebuildEveryFrames = 24 * 6
static constexpr int	kSlot3MinBetweenMoves = 24
static constexpr int	kSlot3ArriveDist = 96

Detailed Description

ScoutingObserver Controls scouting behavior for a Protoss Observer. Maintains vision over key enemy locations, avoids detection threats, and monitors expansions using a slot-based system. Observers either hold fixed positions near the enemy base or dynamically patrol expansion locations to provide map awareness.

Definition at line 22 of file ScoutingObserver.h.

Member Enumeration Documentation

◆ State

enum class ScoutingObserver::State

strongprivate

Definition at line 42 of file ScoutingObserver.h.

42{ Idle, MoveToPost, Hold, AvoidDetection, Done };

Constructor & Destructor Documentation

◆ ScoutingObserver()

ScoutingObserver::ScoutingObserver	(	ProtoBotCommander *	cmd = nullptr,
		ScoutingManager *	mgr = nullptr )

inlineexplicit

Definition at line 25 of file ScoutingObserver.h.

26 : commanderRef(cmd), manager(mgr) {

27 }

Member Function Documentation

◆ assign()

void ScoutingObserver::assign ( BWAPI::Unit u )

Assigns a unit as the scouting observer.

Initializes behavior based on assigned slot:

Slot 3: roaming expansion checker
Other slots: fixed observation posts

Parameters

u	Observer unit

Definition at line 68 of file ScoutingObserver.cpp.

                                         {
    if (!u || !u->exists()) return;
 
    observer = u;
 
    if (enemyMainPos.isValid() && posts.empty())
    {
        computePosts();
    }
 
    // Slot 3: home is wherever we are right now
    if (slotIndex == 3 && !slot3HomeSet)
    {
        slot3Home = observer->getPosition();
        slot3Home = clampToMapPx(slot3Home, 12);
        slot3HomeSet = true;
        slot3NextRebuildFrame = 0;
        slot3NextIdx = 0;
        slot3CurTarget = BWAPI::Positions::Invalid;
    }
 
    if (slotIndex == 3)
    {
        state = State::Hold;
    }
    else
    {
        state = (slotIndex >= 0 && !posts.empty()) ? State::MoveToPost : State::Idle;
    }
}

◆ clampToMapPx()

BWAPI::Position ScoutingObserver::clampToMapPx	(	const BWAPI::Position &	p,
		int	margin = 16 )

staticprivate

Definition at line 462 of file ScoutingObserver.cpp.

{
    const int x = std::max(margin, std::min(p.x, mapWpx() - 1 - margin));
    const int y = std::max(margin, std::min(p.y, mapHpx() - 1 - margin));
    return BWAPI::Position(x, y);
}

◆ computePosts()

void ScoutingObserver::computePosts ( )

private

Computes observation posts around the enemy base.

Selects:

Enemy main
Natural expansion
Additional nearby expansions

Ensures posts are reachable and valid positions.

Definition at line 313 of file ScoutingObserver.cpp.

{
    posts.clear();
    if (!enemyMainPos.isValid() || !enemyMainTile.has_value()) return;
 
    const TilePosition enemyMain = *enemyMainTile;
    const Position enemyMainCenter = Position(enemyMain) + Position(16, 16);
    const auto* mainArea = BWEM::Map::Instance().GetArea(enemyMain);
 
    // 0) Over enemy main, slightly above center
    Position mainCenter = enemyMainCenter + Position(0, -32);
    posts.push_back(clampToMapPx(mainCenter, 16));
 
    struct Candidate { const BWEM::Base* base; double gdist; Position pos; };
    std::vector<Candidate> cands;
 
    // Collect non-starting, reachable bases NOT in the main's area
    for (const BWEM::Area& area : BWEM::Map::Instance().Areas())
    {
        for (const BWEM::Base& base : area.Bases()) {
            if (base.Starting()) continue;
 
            const auto* bArea = BWEM::Map::Instance().GetArea(base.Location());
            if (bArea == mainArea) continue;
 
            // Prefer base center if available; else location + (16,16)
            Position basePos = base.Center(); // BWEM::Base::Center is BWAPI::Position
            if (!basePos.isValid()) basePos = Position(base.Location()) + Position(16, 16);
 
            const auto& path = BWEM::Map::Instance().GetPath(enemyMainCenter, basePos, nullptr);
            if (path.empty()) continue; // unreachable by ground
 
            double g = groundPathLengthPx(enemyMainCenter, basePos);
            cands.push_back({ &base, g, basePos });
        }
    }
 
    std::sort(cands.begin(), cands.end(),
        [](const Candidate& a, const Candidate& b) { return a.gdist < b.gdist; });
 
    // 1) natural (closest), 2) second closest expo, 3) third closest expo
    if (!cands.empty())      posts.push_back(cands[0].pos);
    if (cands.size() >= 2)   posts.push_back(cands[1].pos);
    if (cands.size() >= 3)   posts.push_back(cands[2].pos);
 
    // Nudge every post slightly "above" and clamp
    for (auto& p : posts) p = clampToMapPx(p + Position(0, -24), 12);
 
    // Ensure exactly 4 posts (pad with main if needed)
    while (posts.size() < 4) posts.push_back(mainCenter);
    if (posts.size() > 4) posts.resize(4);
}

◆ detectionRadiusFor()

int ScoutingObserver::detectionRadiusFor ( const BWAPI::UnitType & t )

staticprivate

Definition at line 449 of file ScoutingObserver.cpp.

{
    if (t == BWAPI::UnitTypes::Terran_Missile_Turret) return 224;
    if (t == BWAPI::UnitTypes::Protoss_Photon_Cannon) return 224;
    if (t == BWAPI::UnitTypes::Zerg_Spore_Colony)     return 224;
    if (t == BWAPI::UnitTypes::Terran_Science_Vessel) return 224;
    if (t == BWAPI::UnitTypes::Protoss_Observer)      return 224; // enemy obs can reveal you to army
    int r = t.sightRange();
    if (r <= 0) r = 224;
    // a small bias outward
    return r;
}

◆ detectorThreat()

bool ScoutingObserver::detectorThreat ( BWAPI::Position & avoidTo ) const

private

Detects nearby enemy detectors and computes a safe escape position.

Parameters

avoidTo Output position to move away from detection

Returns: True if a detection threat exists

Definition at line 407 of file ScoutingObserver.cpp.

{
    if (!observer || !observer->exists()) return false;
    const Position me = observer->getPosition();
 
    int bestOver = INT_MIN;
    Position bestPos = Positions::Invalid;
 
    for (auto e : Broodwar->enemy()->getUnits()) 
    {
        if (!e || !e->exists()) continue;
        const auto t = e->getType();
        if (!t.isDetector()) continue;
 
        const int detR = detectionRadiusFor(t);   // detector radius in px
        const int d = e->getDistance(me);
        const int over = detR - d;                // >0 means we are inside detection
 
        // If we're inside (or nearly at the edge), compute a point just outside
        if (over >= -kDetectReactBufferPx) 
        {
            // step along vector from detector->me to just outside radius+margin
            const Position c = e->getPosition();
            int dx = me.x - c.x, dy = me.y - c.y;
            double len = std::max(1.0, std::sqrt(double(dx * dx + dy * dy)));
            const int want = detR + kEdgeMarginPx + kDetectReactBufferPx;
            Position out(c.x + int(dx / len * want), c.y + int(dy / len * want));
            out = clampToMapPx(out, 12);
 
            // pick the �most violating� detector (largest over) to react to
            if (over > bestOver) 
            {
                bestOver = over;
                bestPos = out;
            }
        }
    }
 
    if (bestPos.isValid()) { avoidTo = bestPos; return true; }
    return false;
}

◆ drawDebug()

void ScoutingObserver::drawDebug ( ) const

Draws debug information for the observer on the map.

Displays:

Current state
Assigned slot
Target positions
Observation posts and checkpoints

Definition at line 799 of file ScoutingObserver.cpp.

{
    if (!observer || !observer->exists())
    {
        return;
    }
 
    BWAPI::Position p = observer->getPosition();
 
    BWAPI::Broodwar->drawCircleMap(p, 20, BWAPI::Colors::Cyan, false);
    BWAPI::Broodwar->drawTextMap(p.x - 34, p.y - 42, "\x0fObserver Scout");
    BWAPI::Broodwar->drawTextMap(p.x - 34, p.y - 30, "\x11Slot: %d", slotIndex);
 
    const char* stateName = "Unknown";
 
    switch (state)
    {
    case State::Idle:
        stateName = "Idle";
        break;
    case State::MoveToPost:
        stateName = "MoveToPost";
        break;
    case State::Hold:
        stateName = "Hold";
        break;
    case State::AvoidDetection:
        stateName = "AvoidDetection";
        break;
    case State::Done:
        stateName = "Done";
        break;
    }
 
    BWAPI::Broodwar->drawTextMap(p.x - 34, p.y - 18, "\x11State: %s", stateName);
 
    BWAPI::Position tgt = BWAPI::Positions::Invalid;
 
    if (slotIndex == 3)
    {
        if (slot3CurTarget.isValid())
        {
            tgt = slot3CurTarget;
        }
        else if (slot3HomeSet)
        {
            tgt = slot3Home;
        }
    }
    else
    {
        tgt = postTarget();
    }
 
    if (tgt.isValid())
    {
        BWAPI::Broodwar->drawLineMap(p, tgt, BWAPI::Colors::Green);
        BWAPI::Broodwar->drawCircleMap(tgt, 10, BWAPI::Colors::Green, false);
    }
 
    if (enemyMainPos.isValid())
    {
        BWAPI::Broodwar->drawCircleMap(enemyMainPos, 24, BWAPI::Colors::Red, false);
        BWAPI::Broodwar->drawTextMap(enemyMainPos.x - 20, enemyMainPos.y - 18, "\x08Enemy Main");
    }
 
    for (int i = 0; i < (int)posts.size(); ++i)
    {
        BWAPI::Color c = BWAPI::Colors::White;
 
        if (i == 0)
        {
            c = BWAPI::Colors::Yellow;
        }
        else if (i == 1)
        {
            c = BWAPI::Colors::Cyan;
        }
        else if (i == 2)
        {
            c = BWAPI::Colors::Purple;
        }
        else if (i == 3)
        {
            c = BWAPI::Colors::Orange;
        }
 
        BWAPI::Broodwar->drawCircleMap(posts[i], 8, c, true);
        BWAPI::Broodwar->drawTextMap(posts[i].x + 6, posts[i].y - 6, "#%d", i);
    }
 
    if (slotIndex == 3)
    {
        for (int i = 0; i < (int)slot3Checkpoints.size(); ++i)
        {
            BWAPI::Broodwar->drawCircleMap(slot3Checkpoints[i], 6, BWAPI::Colors::Orange, false);
 
            if (i + 1 < (int)slot3Checkpoints.size())
            {
                BWAPI::Broodwar->drawLineMap(slot3Checkpoints[i], slot3Checkpoints[i + 1], BWAPI::Colors::Orange);
            }
        }
 
        if (slot3HomeSet)
        {
            BWAPI::Broodwar->drawCircleMap(slot3Home, 10, BWAPI::Colors::Blue, false);
            BWAPI::Broodwar->drawTextMap(slot3Home.x + 6, slot3Home.y - 6, "\x10Obs Home");
        }
    }
}

◆ groundPathLengthPx()

double ScoutingObserver::groundPathLengthPx	(	const BWAPI::Position &	from,
		const BWAPI::Position &	to )

staticprivate

Definition at line 469 of file ScoutingObserver.cpp.

{
    auto& m = BWEM::Map::Instance();
    const auto& path = m.GetPath(from, to, nullptr);
    if (path.empty()) return from.getDistance(to);
    double sum = 0.0;
    BWAPI::Position prev = from;
    for (const BWEM::ChokePoint* cp : path) 
    {
        if (!cp) continue;
        BWAPI::Position c(cp->Center());
        sum += prev.getDistance(c);
        prev = c;
    }
    sum += prev.getDistance(to);
    return sum;
}

◆ haveVisionAt()

bool ScoutingObserver::haveVisionAt	(	const BWAPI::Position &	p,
		int	radiusPx ) const

private

Checks whether the bot currently has vision at a position.

Parameters

p	Position to check
radiusPx	Search radius

Returns: True if vision is available

Definition at line 617 of file ScoutingObserver.cpp.

{
    if (!p.isValid()) return true;
 
    // If tile is visible this frame, we definitely have vision.
    if (BWAPI::Broodwar->isVisible(BWAPI::TilePosition(p)))
    {
        return true;
    }
 
    // Otherwise, check if any of our units are physically near it.
    for (auto u : BWAPI::Broodwar->self()->getUnits())
    {
        if (!u || !u->exists()) continue;
        if (u->getDistance(p) <= radiusPx) return true;
    }
 
    return false;
}

◆ issueMove()

void ScoutingObserver::issueMove	(	const BWAPI::Position &	p,
		bool	force = false,
		int	reissueDist = 64 )

private

Issues a movement command to the observer.

Includes throttling to prevent excessive command spam.

Parameters

p	Target position
force	Force movement regardless of cooldown
reissueDist	Minimum distance to reissue move

Definition at line 388 of file ScoutingObserver.cpp.

{
    if (!observer || !observer->exists() || !p.isValid()) return;
    const int now = Broodwar->getFrameCount();
    if (!force && now - lastMoveFrame < kMoveCooldown) return;
    if (force || observer->getDistance(p) > reissueDist || !observer->isMoving()) 
    {
        observer->move(p);
        lastMoveFrame = now;
    }
   //Broodwar->drawLineMap(observer->getPosition(), p, Colors::White);
}

◆ isUnsafe()

bool ScoutingObserver::isUnsafe ( const BWAPI::Position & p ) const

private

Determines if a position is unsafe based on threat data.

Parameters

p	Position to evaluate

Returns: True if unsafe

Definition at line 493 of file ScoutingObserver.cpp.

{
    if (!commanderRef) return false;
 
    const auto threat = commanderRef->queryThreatAt(p);
 
    if (threat.detectorThreat > 0)
    {
        return true;
    }
 
    if (threat.airThreat > kAirThreatThreshold)
    {
        return true;
    }
 
    return false;
}

◆ onFrame()

void ScoutingObserver::onFrame ( )

Main update loop executed every frame.

Handles:

Movement toward observation posts
Detection avoidance
Slot-based scouting behavior

Slot behavior:

Slots 0�2: move to and hold posts
Slot 3: roam and check expansions

Definition at line 141 of file ScoutingObserver.cpp.

                               {
    if (!observer || !observer->exists() || state == State::Done) return;
 
    if (!enemyMainPos.isValid())
    {
        state = State::Idle;
        return;
    }
 
    if (posts.empty()) computePosts();
    if (slotIndex < 0) return;
 
    // Detection avoidance (your existing logic)
    BWAPI::Position safePt;
    if (detectorThreat(safePt))
    {
        lastThreatFrame = Broodwar->getFrameCount();
        issueMove(safePt, /*force*/true, /*reissue*/32);
        state = State::AvoidDetection;
        return;
    }
 
    const int now = Broodwar->getFrameCount();
 
    // --------------------------
    // Slot 3: roaming expansion checker
    // --------------------------
    if (slotIndex == 3 && slot3HomeSet)
    {
        if (slot3Checkpoints.empty())
        {
            rebuildSlot3Checkpoints();
        }
        // If we have checkpoints, go visit them
        // If we have checkpoints, go visit them
        if (!slot3Checkpoints.empty())
        {
            // If we�re returning home after a sweep, ignore checkpoints until we get home.
            if (slot3ReturningHome)
            {
                if (observer->getDistance(slot3Home) <= kSlot3ArriveDist)
                {
                    slot3ReturningHome = false;
 
                    if (slot3NeedsRebuild)
                    {
                        rebuildSlot3Checkpoints();
                        slot3NeedsRebuild = false;
                    }
                }
                else if (now >= slot3NextMoveFrame)
                {
                    issueMove(slot3Home, false, kHoldReissueDist);
                    slot3NextMoveFrame = now + kSlot3MinBetweenMoves;
                }
 
                return;
            }
 
            // Pick/advance target
            if (!slot3CurTarget.isValid() || observer->getDistance(slot3CurTarget) <= kSlot3ArriveDist)
            {
                // Finished the list: rebuild ONCE and keep patrolling from current position.
                // Only go home if rebuild produces no nodes.
                if (slot3NextIdx >= (int)slot3Checkpoints.size())
                {
                    rebuildSlot3Checkpoints();
 
                    slot3NextIdx = 0;
                    slot3CurTarget = BWAPI::Positions::Invalid;
 
                    if (slot3Checkpoints.empty())
                    {
                        slot3ReturningHome = true; // only now do we go home
                    }
 
                    return;
                }
                slot3CurTarget = slot3Checkpoints[slot3NextIdx++];
            }
 
            // Move toward current target (throttled)
            if (slot3CurTarget.isValid() && now >= slot3NextMoveFrame)
            {
                const BWAPI::Position step = pickDetourToward(slot3CurTarget);
                issueMove(step, false, 64);
                slot3NextMoveFrame = now + kSlot3MinBetweenMoves;
            }
 
            return;
        }
 
        // No checkpoints: just hold home
        if (now - lastMoveFrame > 48)
        {
            issueMove(slot3Home, /*force*/true, kHoldReissueDist);
        }
 
        return;
    }
 
    // --------------------------
    // Normal slots 0-2 behavior (your existing switch)
    // --------------------------
    if (slotIndex >= (int)posts.size()) return;
 
    switch (state) {
    case State::Idle:
        state = State::MoveToPost;
        break;
 
    case State::MoveToPost: 
    {
        const BWAPI::Position tgt = postTarget();
        const BWAPI::Position step = pickDetourToward(tgt);
 
        issueMove(step, false, 64);
 
        if (observer->getDistance(tgt) <= 80)
        {
            state = State::Hold;
        }
        break;
    }
 
    case State::Hold: {
        const Position tgt = postTarget();
        if (!observer->isMoving() && !observer->isAttacking()) 
        {
            // Hold is just "don't drift"; observers can't hold-position command,
            // but reissue a move to target occasionally to keep tight.
            if (Broodwar->getFrameCount() - lastMoveFrame > 48)
                issueMove(tgt, /*force*/true, kHoldReissueDist);
        }
        break;
    }
 
    case State::AvoidDetection: 
    {
        // Once calm enough, return to post
        if (Broodwar->getFrameCount() - lastThreatFrame >= kSafeFramesToReturn) 
        {
            state = State::MoveToPost;
        }
        break;
    }
    default: break;
    }
 
    // tiny debug
    /*
    Broodwar->drawTextMap(observer->getPosition(), "\x11OBS slot %d", slotIndex);
    for (int i = 0; i < (int)posts.size(); ++i) {
        auto c = (i == 0) ? Colors::Yellow : (i == 1 ? Colors::Cyan : (i == 2 ? Colors::Purple : Colors::Orange));
        Broodwar->drawCircleMap(posts[i], 8, c, true);
        Broodwar->drawTextMap(posts[i], "#%d", i);
    }*/
}

◆ onStart()

void ScoutingObserver::onStart ( )

Initializes the observer scouting state.

Resets movement tracking, threat tracking, and clears any existing observation posts.

Definition at line 52 of file ScoutingObserver.cpp.

                               {
    lastMoveFrame = 0;
    lastThreatFrame = -10000;
    posts.clear();
    state = State::Idle;
}

◆ onUnitDestroy()

void ScoutingObserver::onUnitDestroy ( BWAPI::Unit u )

Handles observer destruction.

Clears the assigned unit and marks behavior as complete.

Parameters

u	Destroyed unit

Definition at line 121 of file ScoutingObserver.cpp.

                                                {
    if (observer && u == observer) {
        observer = nullptr;
        state = State::Done;
    }
}

◆ pickDetourToward()

BWAPI::Position ScoutingObserver::pickDetourToward ( const BWAPI::Position & target ) const

private

Selects a safe detour toward a target position.

Attempts alternative paths to avoid threats while still progressing toward the goal.

Parameters

target Target position

Returns: Best safe position to move toward

Definition at line 521 of file ScoutingObserver.cpp.

{
    if (!observer || !observer->exists())
    {
        return BWAPI::Positions::Invalid;
    }
 
    const BWAPI::Position me = observer->getPosition();
 
    // If target itself is safe, just go directly.
    if (!isUnsafe(target))
    {
        return target;
    }
 
    // Try a few detours around our current heading.
    const BWAPI::Position toTgt = BWAPI::Position(target.x - me.x, target.y - me.y);
 
    // If we're basically on top of target, no detour helps.
    if (std::abs(toTgt.x) + std::abs(toTgt.y) < 8)
    {
        return target;
    }
 
    // Candidate radii (pixels)
    const int radii[] = { 96, 160, 224, 288 };
 
    // Candidate angles around heading (radians)
    const double angles[] =
    {
        0.0,
        0.35, -0.35,
        0.70, -0.70,
        1.05, -1.05,
        1.40, -1.40
    };
 
    int bestScore = INT_MIN;
    BWAPI::Position bestPos = BWAPI::Positions::Invalid;
 
    // Normalize direction roughly (avoid expensive normalize)
    BWAPI::Position dir = toTgt;
    const int len = std::max(1, int(std::sqrt(double(dir.x * dir.x + dir.y * dir.y))));
    dir = BWAPI::Position(int(double(dir.x) / len * 64.0), int(double(dir.y) / len * 64.0)); // scaled
 
    for (int r : radii)
    {
        for (double a : angles)
        {
            BWAPI::Position cand = me + rotatePoint(BWAPI::Position(int(dir.x * (double(r) / 64.0)), int(dir.y * (double(r) / 64.0))), a);
            cand = clampToMapPx(cand, 12);
 
            // Must be walkable-ish (observers fly, but avoid silly invalid positions)
            if (!cand.isValid())
            {
                continue;
            }
 
            // Skip unsafe candidates.
            if (isUnsafe(cand))
            {
                continue;
            }
 
            // Score: prefer getting closer to target, with a mild bias for larger steps.
            const int distNow = me.getApproxDistance(target);
            const int distCand = cand.getApproxDistance(target);
            const int progress = distNow - distCand;
 
            const int score = progress + (r / 8);
 
            if (score > bestScore)
            {
                bestScore = score;
                bestPos = cand;
            }
        }
    }
 
    // If nothing safe found, just return the safest �least bad� direction (fallback).
    if (!bestPos.isValid())
    {
        return target;
    }
 
    return bestPos;
}

◆ postTarget()

BWAPI::Position ScoutingObserver::postTarget ( ) const

private

Returns the current target position for this observer.

Returns: Target position based on assigned slot

Definition at line 372 of file ScoutingObserver.cpp.

{
    if (slotIndex >= 0 && slotIndex < (int)posts.size())
        return posts[slotIndex];
    return enemyMainPos;
}

◆ rebuildSlot3Checkpoints()

void ScoutingObserver::rebuildSlot3Checkpoints ( )

private

Rebuilds roaming checkpoints for slot 3 observers.

Selects expansion locations to patrol while:

Avoiding friendly bases
Avoiding overlap with other observers
Avoiding unsafe areas

Definition at line 676 of file ScoutingObserver.cpp.

{
    slot3Checkpoints.clear();
 
    if (!observer || !observer->exists())
    {
        slot3NextIdx = 0;
        slot3CurTarget = BWAPI::Positions::Invalid;
        return;
    }
 
    // Tuning knobs
    const int kNexusExcludeRadius = 10 * 32;      // 10 tiles
    const int kObserverCoverRadius = 14 * 32;     // 14 tiles
    const int kMaxPatrolPoints = 16;               // cap to keep it stable
    const int kMinPatrolPoints = 2;               // ensure at least 2 so its not just freaking out
 
    std::vector<BWAPI::Position> candidates;
    candidates.reserve(32);
 
    for (const BWEM::Area& area : BWEM::Map::Instance().Areas())
    {
        for (const BWEM::Base& base : area.Bases())
        {
            BWAPI::Position pos = base.Center();
            if (!pos.isValid())
            {
                pos = BWAPI::Position(base.Location()) + BWAPI::Position(16, 16);
            }
 
            pos = clampToMapPx(pos, 12);
 
            if (hasOurNexusNear(pos, kNexusExcludeRadius))
            {
                continue;
            }
 
            if (isOtherObserverCovering(pos, observer, kObserverCoverRadius))
            {
                continue;
            }
 
            // This is your �detectors matter while moving, not in cost� rule:
            // We only use isUnsafe as a hard filter (optional).
            // If you want it NOT to be a hard filter, remove this and rely on pickDetourToward().
            if (isUnsafe(pos))
            {
                continue;
            }
 
            candidates.push_back(pos);
        }
    }
 
    if (candidates.empty())
    {
        slot3NextIdx = 0;
        slot3CurTarget = BWAPI::Positions::Invalid;
        return;
    }
 
    // Nearest-neighbor greedy ordering (straight-line distance).
    BWAPI::Position cur = observer->getPosition();
 
    while (!candidates.empty() && (int)slot3Checkpoints.size() < kMaxPatrolPoints)
    {
        int bestIdx = -1;
        int bestD = INT_MAX;
 
        for (int i = 0; i < (int)candidates.size(); ++i)
        {
            const int d = cur.getApproxDistance(candidates[i]);
            if (d < bestD)
            {
                bestD = d;
                bestIdx = i;
            }
        }
 
        if (bestIdx < 0)
        {
            break;
        }
 
        slot3Checkpoints.push_back(candidates[bestIdx]);
        cur = candidates[bestIdx];
        candidates.erase(candidates.begin() + bestIdx);
    }
 
    // If we ended up with only 1 but we had more candidates, force-add one more nearest
    // so it doesn�t look �stuck�.
    if ((int)slot3Checkpoints.size() < kMinPatrolPoints && !candidates.empty())
    {
        int bestIdx = 0;
        int bestD = INT_MAX;
 
        for (int i = 0; i < (int)candidates.size(); ++i)
        {
            const int d = cur.getApproxDistance(candidates[i]);
            if (d < bestD)
            {
                bestD = d;
                bestIdx = i;
            }
        }
 
        slot3Checkpoints.push_back(candidates[bestIdx]);
    }
 
    slot3NextIdx = 0;
    slot3CurTarget = BWAPI::Positions::Invalid;
}

◆ setEnemyMain()

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

Sets the enemy main base and recomputes observation posts.

Transitions the observer from Idle to active scouting if a valid slot is assigned.

Parameters

tp	Enemy main tile position

Definition at line 107 of file ScoutingObserver.cpp.

                                                          {
    enemyMainTile = tp;
    enemyMainPos = Position(tp);
    computePosts();
    if (state == State::Idle && slotIndex >= 0) state = State::MoveToPost;
}

◆ setObserverSlot()

void ScoutingObserver::setObserverSlot ( int idx )

inline

Definition at line 37 of file ScoutingObserver.h.

37{ slotIndex = idx; }

Member Data Documentation

◆ commanderRef

ProtoBotCommander* ScoutingObserver::commanderRef = nullptr

private

Definition at line 44 of file ScoutingObserver.h.

◆ enemyMainPos

BWAPI::Position ScoutingObserver::enemyMainPos = BWAPI::Positions::Invalid

private

Definition at line 55 of file ScoutingObserver.h.

◆ enemyMainTile

std::optional<BWAPI::TilePosition> ScoutingObserver::enemyMainTile

private

Definition at line 54 of file ScoutingObserver.h.

◆ kAirThreatThreshold

int ScoutingObserver::kAirThreatThreshold = 40

staticconstexprprivate

Definition at line 65 of file ScoutingObserver.h.

◆ kDetectReactBufferPx

int ScoutingObserver::kDetectReactBufferPx = 48

staticconstexprprivate

Definition at line 66 of file ScoutingObserver.h.

◆ kEdgeMarginPx

int ScoutingObserver::kEdgeMarginPx = 8

staticconstexprprivate

Definition at line 63 of file ScoutingObserver.h.

◆ kHoldReissueDist

int ScoutingObserver::kHoldReissueDist = 16

staticconstexprprivate

Definition at line 64 of file ScoutingObserver.h.

◆ kMoveCooldown

int ScoutingObserver::kMoveCooldown = 6

staticconstexprprivate

Definition at line 61 of file ScoutingObserver.h.

◆ kSafeFramesToReturn

int ScoutingObserver::kSafeFramesToReturn = 48

staticconstexprprivate

Definition at line 62 of file ScoutingObserver.h.

◆ kSlot3ArriveDist

int ScoutingObserver::kSlot3ArriveDist = 96

staticconstexprprivate

Definition at line 70 of file ScoutingObserver.h.

◆ kSlot3MinBetweenMoves

int ScoutingObserver::kSlot3MinBetweenMoves = 24

staticconstexprprivate

Definition at line 69 of file ScoutingObserver.h.

◆ kSlot3RebuildEveryFrames

int ScoutingObserver::kSlot3RebuildEveryFrames = 24 * 6

staticconstexprprivate

Definition at line 68 of file ScoutingObserver.h.

◆ lastMoveFrame

int ScoutingObserver::lastMoveFrame = 0

private

Definition at line 57 of file ScoutingObserver.h.

◆ lastThreatFrame

int ScoutingObserver::lastThreatFrame = -10000

private

Definition at line 58 of file ScoutingObserver.h.

◆ manager

ScoutingManager* ScoutingObserver::manager = nullptr

private

Definition at line 45 of file ScoutingObserver.h.

◆ observer

BWAPI::Unit ScoutingObserver::observer { nullptr }

private

Definition at line 47 of file ScoutingObserver.h.

47{ nullptr };

◆ posts

std::vector<BWAPI::Position> ScoutingObserver::posts

private

Definition at line 51 of file ScoutingObserver.h.

◆ slot3Checkpoints

std::vector<BWAPI::Position> ScoutingObserver::slot3Checkpoints

private

Definition at line 76 of file ScoutingObserver.h.

◆ slot3CurTarget

BWAPI::Position ScoutingObserver::slot3CurTarget = BWAPI::Positions::Invalid

private

Definition at line 81 of file ScoutingObserver.h.

◆ slot3Home

BWAPI::Position ScoutingObserver::slot3Home = BWAPI::Positions::Invalid

private

Definition at line 73 of file ScoutingObserver.h.

◆ slot3HomeSet

bool ScoutingObserver::slot3HomeSet = false

private

Definition at line 74 of file ScoutingObserver.h.

◆ slot3NeedsRebuild

bool ScoutingObserver::slot3NeedsRebuild = false

private

Definition at line 78 of file ScoutingObserver.h.

◆ slot3NextIdx

int ScoutingObserver::slot3NextIdx = 0

private

Definition at line 79 of file ScoutingObserver.h.

◆ slot3NextMoveFrame

int ScoutingObserver::slot3NextMoveFrame = 0

private

Definition at line 80 of file ScoutingObserver.h.

◆ slot3NextRebuildFrame

int ScoutingObserver::slot3NextRebuildFrame = 0

private

Definition at line 77 of file ScoutingObserver.h.

◆ slot3ReturningHome

bool ScoutingObserver::slot3ReturningHome = false

private

Definition at line 75 of file ScoutingObserver.h.

◆ slotIndex

int ScoutingObserver::slotIndex = -1

private

Definition at line 52 of file ScoutingObserver.h.

◆ state

State ScoutingObserver::state = State::Idle

private

Definition at line 48 of file ScoutingObserver.h.

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

src/protobot/ScoutingObserver.h
src/protobot/ScoutingObserver.cpp

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ State

Constructor & Destructor Documentation

◆ ScoutingObserver()

Member Function Documentation

◆ assign()

◆ clampToMapPx()

◆ computePosts()

◆ detectionRadiusFor()

◆ detectorThreat()

◆ drawDebug()

◆ groundPathLengthPx()

◆ haveVisionAt()

◆ issueMove()

◆ isUnsafe()

◆ onFrame()

◆ onStart()

◆ onUnitDestroy()

◆ pickDetourToward()

◆ postTarget()

◆ rebuildSlot3Checkpoints()

◆ setEnemyMain()

◆ setObserverSlot()

Member Data Documentation

◆ commanderRef

◆ enemyMainPos

◆ enemyMainTile

◆ kAirThreatThreshold

◆ kDetectReactBufferPx

◆ kEdgeMarginPx

◆ kHoldReissueDist

◆ kMoveCooldown

◆ kSafeFramesToReturn

◆ kSlot3ArriveDist

◆ kSlot3MinBetweenMoves

◆ kSlot3RebuildEveryFrames

◆ lastMoveFrame

◆ lastThreatFrame

◆ manager

◆ observer

◆ posts

◆ slot3Checkpoints

◆ slot3CurTarget

◆ slot3Home

◆ slot3HomeSet

◆ slot3NeedsRebuild

◆ slot3NextIdx

◆ slot3NextMoveFrame

◆ slot3NextRebuildFrame

◆ slot3ReturningHome

◆ slotIndex

◆ state