ScoutingZealot Controls scouting behavior for Zealot and Dragoon units. Combines positioning, threat detection, and movement control to provide safe and consistent map scouting. More...

#include <ScoutingZealot.h>

Public Member Functions
	ScoutingZealot (ProtoBotCommander commander, ScoutingManager manager)
void	onStart ()
	Initializes the zealot scouting state.
void	onFrame ()
	Main update loop executed every frame.
void	onUnitDestroy (BWAPI::Unit unit)
	Handles cleanup when the scouting unit is destroyed.
void	setEnemyMain (const BWAPI::TilePosition &tp)
	Sets the enemy main base location and updates scouting behavior.
void	assign (BWAPI::Unit unit)
	Assigns a unit as a scouting zealot.
bool	hasScout () const
void	setProxyPatroller (bool v)
void	drawDebug () const
	Draws debug information for the scouting unit.

Private Types
enum class	State { Idle , WaitEnemyMain , ProxyPatrol , MoveToNatural , HoldEdge , Reposition , Done }

Private Member Functions
BWAPI::Position	homeRetreatPoint () const
void	computeEnemyNatural ()
	Determines the enemy natural expansion location.
BWAPI::Position	pickEdgeOfVisionSpot ()
	Selects a position near the edge of enemy vision at the natural.
BWAPI::Position	pickNaturalChokeSpot ()
BWAPI::Position	findReachableNearby (const BWAPI::Position &desired) const
	Finds a reachable nearby position if the desired location is invalid.
BWAPI::Position	pushAwayFromResources (const BWAPI::Position &p, int clearPx) const
bool	threatenedNow () const
	Checks whether the unit is currently threatened.
void	issueMove (const BWAPI::Position &p, bool force=false, int reissueDist=32)
	Issues movement commands with anti-stuck handling.
void	rebuildProxyPoints ()
	Builds patrol points used for proxy scouting.
bool	isNear (const BWAPI::Position &a, const BWAPI::Position &b, int distPx) const
BWAPI::Unit	findPrimaryThreat (int radiusPx) const
void	retreatHomeMicro (BWAPI::Unit threat)
	Executes retreat and kiting behavior toward home base.
BWAPI::Unit	findInWeaponRangeTarget () const
int	attackCommitFrames () const
bool	tryFireAndCommit (BWAPI::Unit target)
	Attempts to attack a target and commit to the attack briefly.
bool	isGoodKiteTarget (BWAPI::Unit u, int radiusPx) const

Static Private Member Functions
static double	groundPathLengthPx (const BWAPI::Position &from, const BWAPI::Position &to)
static BWAPI::Position	clampToMapPx (const BWAPI::Position &p, int marginPx=32)

Private Attributes
State	returnStateAfterReposition = State::HoldEdge
ProtoBotCommander *	commanderRef = nullptr
ScoutingManager *	manager = nullptr
BWAPI::Unit	zealot = nullptr
std::optional< BWAPI::TilePosition >	enemyMainTile
BWAPI::Position	enemyMainPos = BWAPI::Positions::Invalid
BWAPI::TilePosition	enemyNaturalTile = BWAPI::TilePositions::Invalid
BWAPI::Position	enemyNaturalPos = BWAPI::Positions::Invalid
State	state = State::Idle
int	lastMoveIssueFrame = 0
int	lastThreatFrame = -100000
int	lastAttackCmdFrame = -100000
int	lastTargetSelectFrame = -100000
int	proxyRebuildReadyFrame = 0
std::vector< BWAPI::Position >	proxyPoints
int	proxyNextIdx = 0
int	proxyNextRebuildFrame = 0
int	proxyNextMoveFrame = 0
BWAPI::Position	proxyCurTarget = BWAPI::Positions::Invalid
bool	isProxyPatroller = false
std::vector< BWAPI::Position >	cachedProxyPoints
bool	proxyPointsBuiltOnce = false
BWAPI::Position	cachedPerch = BWAPI::Positions::Invalid
int	cachedPerchFrame = -100000
BWAPI::Position	lastIssuedGoal = BWAPI::Positions::Invalid
BWAPI::Position	lastPos = BWAPI::Positions::Invalid
int	stuckFrames = 0
BWAPI::Unit	lastAttackTarget = nullptr

Static Private Attributes
static constexpr int	kMoveCooldownFrames = 8
static constexpr int	kEdgeMarginPx = 24
static constexpr int	kThreatRadiusPx = 256
static constexpr int	kRepositionStepPx = 160
static constexpr int	kCalmFramesToReturn = 72
static constexpr int	kDangerClosePx = 96
static constexpr int	kTargetStickFrames = 18
static constexpr int	kProxyRebuildEveryFrames = 24 * 10
static constexpr int	kProxyArriveDist = 96
static constexpr int	kProxyMinBetweenMoves = 12
static constexpr double	kMaxGroundDist = 180 * 32
static constexpr int	kPerchRecalcFrames = 24
static constexpr int	kGoalChangeResetDist = 64

Detailed Description

ScoutingZealot Controls scouting behavior for Zealot and Dragoon units. Combines positioning, threat detection, and movement control to provide safe and consistent map scouting.

/// Uses a state-driven system to:

Move toward and hold the enemy natural edge
Avoid entering the enemy main base
React to threats using retreat and kiting logic
Patrol proxy locations to detect early enemy structures

Definition at line 23 of file ScoutingZealot.h.

Member Enumeration Documentation

◆ State

enum class ScoutingZealot::State

strongprivate

Definition at line 47 of file ScoutingZealot.h.

    {
        Idle,
        WaitEnemyMain,
        ProxyPatrol,
        MoveToNatural,
        HoldEdge,
        Reposition,
        Done
    };

Constructor & Destructor Documentation

◆ ScoutingZealot()

ScoutingZealot::ScoutingZealot	(	ProtoBotCommander *	commander,
		ScoutingManager *	manager )

inlineexplicit

Definition at line 26 of file ScoutingZealot.h.

        : commanderRef(commander), manager(manager)
    {
    }

Member Function Documentation

◆ assign()

void ScoutingZealot::assign ( BWAPI::Unit unit )

Assigns a unit as a scouting zealot.

Initializes behavior based on role:

Proxy patrol zealots begin patrol setup
Standard scouts wait for or move toward enemy natural

Parameters

unit	Unit to assign as scout

Definition at line 155 of file ScoutingZealot.cpp.

                                          {
 
    if (!unit || !unit->exists()) return;
 
    zealot = unit;
    //BWAPI::Broodwar->printf("[ZealotScout] assign id=%d type=%s",
        //zealot->getID(), zealot->getType().c_str());
 
    if (isProxyPatroller)
    {
        proxyPoints.clear();
        proxyNextIdx = 0;
        proxyCurTarget = BWAPI::Positions::Invalid;
        proxyRebuildReadyFrame = BWAPI::Broodwar->getFrameCount() + 1;
        state = State::ProxyPatrol;
        return;
    }
    state = enemyMainPos.isValid() ? State::MoveToNatural : State::WaitEnemyMain;
}

◆ attackCommitFrames()

int ScoutingZealot::attackCommitFrames ( ) const

private

Definition at line 1519 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return 0;
    }
 
    const int range = zealot->getType().groundWeapon().maxRange();
 
    // Dragoons need a bigger window so we don't cancel their windup.
    if (range > 32)
    {
        return 8;
    }
 
    // Zealot (melee) is fine with a tiny commit.
    return 2;
}

◆ clampToMapPx()

BWAPI::Position ScoutingZealot::clampToMapPx	(	const BWAPI::Position &	p,
		int	marginPx = 32 )

staticprivate

Definition at line 1021 of file ScoutingZealot.cpp.

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

◆ computeEnemyNatural()

void ScoutingZealot::computeEnemyNatural ( )

private

Determines the enemy natural expansion location.

Selects the closest reachable non-starting base outside of the enemy main area.

Definition at line 448 of file ScoutingZealot.cpp.

                                         {
    enemyNaturalTile = BWAPI::TilePositions::Invalid;
    enemyNaturalPos = BWAPI::Positions::Invalid;
    if (!enemyMainTile.has_value()) return;
 
    const BWAPI::TilePosition enemyMain = *enemyMainTile;
    const BWAPI::Position enemyMainCenter = BWAPI::Position(enemyMain) + BWAPI::Position(16, 16);
 
    const BWEM::Area* mainArea = BWEM::Map::Instance().GetArea(enemyMain);
    double bestDist = 1e30;
 
    // Look at all non-starting bases NOT in the enemy main's area; pick shortest ground path
    for (const BWEM::Area& area : BWEM::Map::Instance().Areas()) {
        for (const BWEM::Base& base : area.Bases()) {
            if (base.Starting()) continue;
 
            const BWEM::Area* bArea = BWEM::Map::Instance().GetArea(base.Location());
            if (bArea == mainArea) continue; // don't consider bases inside enemy main area
 
            BWAPI::Position basePos = BWAPI::Position(base.Location());
            const auto& path = BWEM::Map::Instance().GetPath(enemyMainCenter, basePos, nullptr);
            if (path.empty()) continue; // unreachable
 
            double gdist = ScoutingZealot::groundPathLengthPx(enemyMainCenter, basePos);
            if (gdist < bestDist) {
                bestDist = gdist;
                enemyNaturalTile = base.Location();
                enemyNaturalPos = basePos;
            }
        }
    }
 
    if (enemyNaturalPos.isValid()) {
        //Broodwar->drawCircleMap(enemyNaturalPos, 10, Colors::Cyan, true);
        //->drawTextMap(enemyNaturalPos, "nat");
    }
 
}

◆ drawDebug()

void ScoutingZealot::drawDebug ( ) const

Draws debug information for the scouting unit.

Displays:

Current state
Target positions
Threats and attack targets
Proxy patrol routes

Definition at line 1616 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return;
    }
 
    BWAPI::Position p = zealot->getPosition();
 
    const char* stateName = "Unknown";
 
    switch (state)
    {
    case State::Idle:
        stateName = "Idle";
        break;
    case State::WaitEnemyMain:
        stateName = "WaitEnemyMain";
        break;
    case State::ProxyPatrol:
        stateName = "ProxyPatrol";
        break;
    case State::MoveToNatural:
        stateName = "MoveToNatural";
        break;
    case State::HoldEdge:
        stateName = "HoldEdge";
        break;
    case State::Reposition:
        stateName = "Reposition";
        break;
    case State::Done:
        stateName = "Done";
        break;
    }
 
    BWAPI::Broodwar->drawCircleMap(p, 20, BWAPI::Colors::Green, false);
 
    const char* label = zealot->getType() == BWAPI::UnitTypes::Protoss_Dragoon
        ? "Dragoon Scout"
        : "Zealot Scout";
 
    BWAPI::Broodwar->drawTextMap(p.x - 40, p.y - 46, "\x07%s", label);
    BWAPI::Broodwar->drawTextMap(p.x - 40, p.y - 34, "\x11State: %s", stateName);
 
    if (isProxyPatroller)
    {
        BWAPI::Broodwar->drawTextMap(p.x - 40, p.y - 22, "\x10Role: Proxy Patrol");
    }
    else
    {
        BWAPI::Broodwar->drawTextMap(p.x - 40, p.y - 22, "\x10Role: Natural Edge");
    }
 
    if (enemyMainPos.isValid())
    {
        BWAPI::Broodwar->drawCircleMap(enemyMainPos, 20, BWAPI::Colors::Red, false);
        BWAPI::Broodwar->drawTextMap(enemyMainPos.x + 8, enemyMainPos.y - 8, "\x08Enemy Main");
    }
 
    if (enemyNaturalPos.isValid())
    {
        BWAPI::Broodwar->drawCircleMap(enemyNaturalPos, 18, BWAPI::Colors::Cyan, false);
        BWAPI::Broodwar->drawTextMap(enemyNaturalPos.x + 8, enemyNaturalPos.y - 8, "\x0f" "Enemy Natural");
    }
 
    if (state == State::MoveToNatural || state == State::HoldEdge || state == State::Reposition)
    {
        BWAPI::Position perch = cachedPerch.isValid() ? cachedPerch : enemyNaturalPos;
 
        if (perch.isValid())
        {
            BWAPI::Broodwar->drawLineMap(p, perch, BWAPI::Colors::Green);
            BWAPI::Broodwar->drawCircleMap(perch, 10, BWAPI::Colors::Green, false);
            BWAPI::Broodwar->drawTextMap(perch.x + 6, perch.y - 6, "\x07Perch");
        }
    }
 
    if (state == State::ProxyPatrol)
    {
        for (int i = 0; i < (int)proxyPoints.size(); ++i)
        {
            BWAPI::Color c = (i == proxyNextIdx - 1) ? BWAPI::Colors::Orange : BWAPI::Colors::Yellow;
 
            BWAPI::Broodwar->drawCircleMap(proxyPoints[i], 7, c, false);
            BWAPI::Broodwar->drawTextMap(proxyPoints[i].x + 5, proxyPoints[i].y - 5, "#%d", i);
 
            if (i + 1 < (int)proxyPoints.size())
            {
                BWAPI::Broodwar->drawLineMap(proxyPoints[i], proxyPoints[i + 1], BWAPI::Colors::Orange);
            }
        }
 
        if (proxyCurTarget.isValid())
        {
            BWAPI::Broodwar->drawLineMap(p, proxyCurTarget, BWAPI::Colors::Orange);
            BWAPI::Broodwar->drawCircleMap(proxyCurTarget, 10, BWAPI::Colors::Orange, false);
            BWAPI::Broodwar->drawTextMap(proxyCurTarget.x + 6, proxyCurTarget.y - 6, "\x10Proxy Target");
        }
    }
 
    BWAPI::Unit threat = findPrimaryThreat(kThreatRadiusPx);
    if (threat && threat->exists())
    {
        BWAPI::Broodwar->drawLineMap(p, threat->getPosition(), BWAPI::Colors::Red);
        BWAPI::Broodwar->drawCircleMap(threat->getPosition(), 12, BWAPI::Colors::Red, false);
        BWAPI::Broodwar->drawTextMap(
            threat->getPosition().x + 6,
            threat->getPosition().y - 6,
            "\x08Threat"
        );
    }
 
    if (lastAttackTarget && lastAttackTarget->exists())
    {
        BWAPI::Broodwar->drawLineMap(p, lastAttackTarget->getPosition(), BWAPI::Colors::Purple);
        BWAPI::Broodwar->drawCircleMap(lastAttackTarget->getPosition(), 10, BWAPI::Colors::Purple, false);
        BWAPI::Broodwar->drawTextMap(
            p.x - 40,
            p.y - 10,
            "\x05Attack: %s",
            lastAttackTarget->getType().getName().c_str()
        );
    }
 
    if (cachedPerch.isValid())
    {
        BWAPI::Broodwar->drawCircleMap(cachedPerch, 8, BWAPI::Colors::Blue, false);
    }
 
    if (lastIssuedGoal.isValid())
    {
        BWAPI::Broodwar->drawLineMap(p, lastIssuedGoal, BWAPI::Colors::White);
    }
}

◆ findInWeaponRangeTarget()

BWAPI::Unit ScoutingZealot::findInWeaponRangeTarget ( ) const

private

Definition at line 1476 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return nullptr;
    }
 
    BWAPI::Unit best = nullptr;
    int bestD = INT_MAX;
 
    for (auto& e : BWAPI::Broodwar->enemy()->getUnits())
    {
        if (!e || !e->exists())
        {
            continue;
        }
 
        if (e->getType().isWorker())
        {
            continue;
        }
 
        if (!zealot->canAttackUnit(e))
        {
            continue;
        }
 
        if (!zealot->isInWeaponRange(e))
        {
            continue;
        }
 
        const int d = zealot->getDistance(e);
        if (d < bestD)
        {
            bestD = d;
            best = e;
        }
    }
 
    return best;
}

◆ findPrimaryThreat()

BWAPI::Unit ScoutingZealot::findPrimaryThreat ( int radiusPx ) const

private

Definition at line 1365 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return nullptr;
    }
 
    BWAPI::Unit best = nullptr;
    int bestD = INT_MAX;
 
    for (auto& e : BWAPI::Broodwar->enemy()->getUnits())
    {
        if (!e || !e->exists())
        {
            continue;
        }
 
        if (!canBeKitedByScoutUnit(zealot, e))
        {
            continue;
        }
 
        const int d = zealot->getDistance(e);
        if (d > radiusPx)
        {
            continue;
        }
 
        if (d < bestD)
        {
            bestD = d;
            best = e;
        }
    }
 
    return best;
}

◆ findReachableNearby()

BWAPI::Position ScoutingZealot::findReachableNearby ( const BWAPI::Position & desired ) const

private

Finds a reachable nearby position if the desired location is invalid.

Searches surrounding positions for a walkable and pathable alternative.

Parameters

desired Desired target position

Returns: Reachable position near the desired location

Definition at line 742 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return desired;
    }
 
    const BWAPI::Position from = zealot->getPosition();
    if (!from.isValid() || !desired.isValid())
    {
        return desired;
    }
 
    auto isOk = [&](const BWAPI::Position& p)
        {
            if (!p.isValid())
            {
                return false;
            }
 
            if (!isWalkablePx(p))
            {
                return false;
            }
 
            if (!hasGroundPath(from, p))
            {
                return false;
            }
 
            return true;
        };
 
    if (isOk(desired))
    {
        return desired;
    }
 
    // Search ring: try a few radii around the desired point
    static const int radii[] = { 32, 64, 96, 128, 160, 192 };
    static const int dirs[][2] =
    {
        {  1,  0 }, { -1,  0 }, {  0,  1 }, {  0, -1 },
        {  1,  1 }, {  1, -1 }, { -1,  1 }, { -1, -1 }
    };
 
    for (int r : radii)
    {
        for (const auto& d : dirs)
        {
            BWAPI::Position p(desired.x + d[0] * r, desired.y + d[1] * r);
            p = clampToMapPx(p, 8);
 
            if (isOk(p))
            {
                return p;
            }
        }
    }
 
    // Last resort: head toward natural center if reachable
    if (enemyNaturalPos.isValid() && isOk(enemyNaturalPos))
    {
        return enemyNaturalPos;
    }
 
    // Give up, return desired (caller may still handle stuck)
    return desired;
}

◆ groundPathLengthPx()

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

staticprivate

Definition at line 861 of file ScoutingZealot.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;
}

◆ hasScout()

bool ScoutingZealot::hasScout ( ) const

inline

Definition at line 37 of file ScoutingZealot.h.

37{ return zealot && zealot->exists(); }

◆ homeRetreatPoint()

BWAPI::Position ScoutingZealot::homeRetreatPoint ( ) const

private

Definition at line 433 of file ScoutingZealot.cpp.

{
    BWAPI::Position home = g_myMainPos.isValid()
        ? g_myMainPos
        : BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation());
    return ScoutingZealot::clampToMapPx(home, 32);
}

◆ isGoodKiteTarget()

bool ScoutingZealot::isGoodKiteTarget	(	BWAPI::Unit	u,
		int	radiusPx ) const

private

Definition at line 1586 of file ScoutingZealot.cpp.

{
    if (!u || !u->exists())
    {
        return false;
    }
 
    if (u->getPlayer() != BWAPI::Broodwar->enemy())
    {
        return false;
    }
 
    if (!canBeKitedByScoutUnit(zealot, u))
    {
        return false;
    }
 
    return zealot->getDistance(u) <= radiusPx;
}

◆ isNear()

bool ScoutingZealot::isNear	(	const BWAPI::Position &	a,
		const BWAPI::Position &	b,
		int	distPx ) const

private

Definition at line 1028 of file ScoutingZealot.cpp.

{
    return a.getApproxDistance(b) <= distPx;
}

◆ issueMove()

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

private

Issues movement commands with anti-stuck handling.

Includes:

Movement throttling
Stuck detection and recovery
Goal tracking

Parameters

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

Definition at line 913 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists() || !p.isValid())
    {
        return;
    }
 
    const int now = BWAPI::Broodwar->getFrameCount();
 
    // If the goal changed meaningfully, reset stuck tracking.
    if (lastIssuedGoal.isValid())
    {
        const int goalDelta = p.getApproxDistance(lastIssuedGoal);
        if (goalDelta > kGoalChangeResetDist)
        {
            stuckFrames = 0;
        }
    }
    lastIssuedGoal = p;
 
    // Stuck detection: only when we intend to be moving toward the same goal.
    if (lastPos.isValid())
    {
        const int moved = zealot->getPosition().getApproxDistance(lastPos);
 
        if (moved < 4 && zealot->isMoving())
        {
            stuckFrames += 1;
        }
        else
        {
            stuckFrames = 0;
        }
    }
    lastPos = zealot->getPosition();
 
    if (stuckFrames > 24)
    {
        // Try a few nudges around current position, biased toward goal.
        BWAPI::Position here = zealot->getPosition();
        BWAPI::Position best = BWAPI::Positions::Invalid;
 
        const int dx = p.x - here.x;
        const int dy = p.y - here.y;
 
        auto tryNudge = [&](int ox, int oy)
            {
                if (best.isValid())
                {
                    return;
                }
 
                BWAPI::Position np(here.x + ox, here.y + oy);
                np = clampToMapPx(np, 8);
 
                if (!isWalkablePx(np))
                {
                    return;
                }
 
                if (!hasGroundPath(here, np))
                {
                    return;
                }
 
                best = np;
            };
 
        // Forward-ish, then side steps, then back-ish
        const int step = 64;
        const int sx = (dx >= 0) ? 1 : -1;
        const int sy = (dy >= 0) ? 1 : -1;
 
        tryNudge(step * sx, 0);
        tryNudge(0, step * sy);
        tryNudge(step * sx, step * sy);
 
        tryNudge(0, step * -sy);
        tryNudge(step * -sx, 0);
        tryNudge(step * -sx, step * sy);
        tryNudge(step * sx, step * -sy);
 
        if (best.isValid())
        {
            zealot->move(best);
            lastMoveIssueFrame = now;
            stuckFrames = 0;
            return;
        }
 
        // If no good nudge found, just reset and let normal move happen.
        stuckFrames = 0;
    }
 
    if (!force && now - lastMoveIssueFrame < kMoveCooldownFrames)
    {
        return;
    }
 
    if (force || zealot->getDistance(p) > reissueDist || !zealot->isMoving())
    {
        zealot->move(p);
        lastMoveIssueFrame = now;
    }
 
    //Broodwar->drawLineMap(zealot->getPosition(), p, Colors::Orange);
}

◆ onFrame()

void ScoutingZealot::onFrame ( )

Main update loop executed every frame.

Controls state transitions and behavior including:

Moving to enemy natural
Holding edge positions
Avoiding enemy main base
Repositioning under threat
Proxy patrol routing

Definition at line 229 of file ScoutingZealot.cpp.

                             {
    if (!zealot || !zealot->exists() || state == State::Done) return;
    /*
    BWAPI::Broodwar->drawTextMap(zealot->getPosition(),
        "\x11Zealot[%d] %s", zealot->getID(),
           (state == State::Idle ?              "Idle" :
            state == State::ProxyPatrol ?       "ProxyPatrol" :
            state == State::WaitEnemyMain ?     "WaitEnemyMain" :
            state == State::MoveToNatural ?     "MoveToNatural" :
            state == State::HoldEdge ?          "HoldEdge" :
            state == State::Reposition ?        "Reposition" : "Done"));
    */
 
    // --- hard avoid enemy main every frame ---
    if (enemyMainTile.has_value() && zealot && zealot->exists()) {
        const auto* mainArea = BWEM::Map::Instance().GetArea(*enemyMainTile);
        const auto* hereArea = BWEM::Map::Instance().GetArea(zealot->getTilePosition());
        if (mainArea && hereArea == mainArea) {
            //BWAPI::Broodwar->drawTextMap(zealot->getPosition(), "\x08[AVOID MAIN]");
            issueMove(pickEdgeOfVisionSpot(), /*force*/true);
            return;
        }
    }
 
    switch (state) {
    case State::Idle:
        // wait until we know the main
        if (isProxyPatroller)
        {
            proxyRebuildReadyFrame = BWAPI::Broodwar->getFrameCount() + 1;
            state = State::ProxyPatrol;
        }
        else
        {
            state = enemyMainPos.isValid() ? State::MoveToNatural : State::WaitEnemyMain;
        }
        break;
 
    case State::WaitEnemyMain:
        // commander will call setEnemyMain() once your Probe finds it
        if (commanderRef) 
        {
            const auto& e = commanderRef->enemy();
            if (e.main.has_value()) 
            {
                setEnemyMain(*e.main);       
                break;
            }
        }
        break;
 
    case State::MoveToNatural:
    {
        if (!enemyMainPos.isValid())
        {
            state = State::WaitEnemyMain;
            break;
        }
 
        if (!enemyNaturalPos.isValid())
        {
            computeEnemyNatural();
        }
 
        BWAPI::Unit threat = findPrimaryThreat(kThreatRadiusPx);
 
        if (threat || zealot->isUnderAttack())
        {
            lastThreatFrame = BWAPI::Broodwar->getFrameCount();
            returnStateAfterReposition = State::MoveToNatural;
            state = State::Reposition;
 
            retreatHomeMicro(threat);
            break;
        }
 
        if (enemyNaturalPos.isValid())
        {
            const BWAPI::Position perch = pickNaturalChokeSpot();
            issueMove(perch);
 
            if (zealot->getDistance(perch) < 96)
            {
                state = State::HoldEdge;
            }
        }
 
        break;
    }
 
    case State::HoldEdge:
    {
        BWAPI::Unit threat = findPrimaryThreat(kThreatRadiusPx);
 
        if (threat || zealot->isUnderAttack())
        {
            lastThreatFrame = BWAPI::Broodwar->getFrameCount();
            returnStateAfterReposition = State::HoldEdge;
            state = State::Reposition;
 
            retreatHomeMicro(threat);
            break;
        }
 
 
 
        break;
    }
 
    case State::Reposition:
    {
        const int now = BWAPI::Broodwar->getFrameCount();
        BWAPI::Unit threat = findPrimaryThreat(kThreatRadiusPx);
 
        if (threat || zealot->isUnderAttack())
        {
            lastThreatFrame = now;
            retreatHomeMicro(threat);
            break;
        }
 
        if (now - lastThreatFrame >= kCalmFramesToReturn)
        {
            if (returnStateAfterReposition == State::MoveToNatural)
            {
                issueMove(pickNaturalChokeSpot(), true);
                state = State::MoveToNatural;
            }
            else
            {
                issueMove(pickNaturalChokeSpot(), true);
                state = State::HoldEdge;
            }
 
            break;
        }
 
        break;
    }
    case State::ProxyPatrol:
    {
        const int now = Broodwar->getFrameCount();
 
        // If zealot is missing points, rebuild here.
        if (proxyPoints.empty() && now >= proxyRebuildReadyFrame)
        {
            rebuildProxyPoints();
        }
 
        if (proxyPoints.empty())
        {
            // fallback: just stand
            if (!zealot->isMoving() && !zealot->isAttacking())
            {
                zealot->holdPosition();
            }
            break;
        }
 
        // advance target when reached
        if (!proxyCurTarget.isValid() || zealot->getDistance(proxyCurTarget) <= 96)
        {
            if (proxyPoints.empty())
            {
                proxyCurTarget = BWAPI::Positions::Invalid;
                break;
            }
 
            if (proxyNextIdx < 0 || proxyNextIdx >= (int)proxyPoints.size())
            {
                proxyNextIdx = 0;
            }
 
            proxyCurTarget = proxyPoints[proxyNextIdx];
            ++proxyNextIdx;
        }
 
        BWAPI::Position tgt = proxyCurTarget;
 
        if (!isWalkablePx(tgt) || !hasGroundPath(zealot->getPosition(), tgt))
        {
            tgt = findReachableNearby(tgt);
            proxyCurTarget = tgt;
        }
 
        issueMove(tgt, /*force*/false, /*reissueDist*/64);
 
        break;
    }
 
    case State::Done:
    default:
        break;
    }
 
    // tiny debug
    /*if (enemyNaturalPos.isValid())
        Broodwar->drawCircleMap(enemyNaturalPos, 12, Colors::Cyan, true);
        */
}

◆ onStart()

void ScoutingZealot::onStart ( )

Initializes the zealot scouting state.

Sets initial state and tracking values, including home position and movement timers.

Definition at line 136 of file ScoutingZealot.cpp.

                             {
    // We only act when assigned + enemy main becomes known
    state = State::Idle;
    lastMoveIssueFrame = 0;
    lastThreatFrame = -10000;
    g_myMainPos = BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation());
    //BWAPI::Broodwar->printf("[ZealotScout] onStart()");
}

◆ onUnitDestroy()

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

Handles cleanup when the scouting unit is destroyed.

Clears references and marks behavior as complete.

Parameters

unit	Destroyed unit

Definition at line 211 of file ScoutingZealot.cpp.

                                                 {
    if (zealot && unit == zealot) {
        zealot = nullptr;
        state = State::Done;
    }
}

◆ pickEdgeOfVisionSpot()

BWAPI::Position ScoutingZealot::pickEdgeOfVisionSpot ( )

private

Selects a position near the edge of enemy vision at the natural.

Ensures the unit remains outside the enemy main while maintaining vision of key areas.

Definition at line 494 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return BWAPI::Positions::Invalid;
    }
 
    if (!enemyNaturalPos.isValid())
    {
        return enemyNaturalPos;
    }
 
    const int now = BWAPI::Broodwar->getFrameCount();
 
    // Reuse cached perch for a bit to prevent thrash.
    if (cachedPerch.isValid())
    {
        const bool recent = (now - cachedPerchFrame) < kPerchRecalcFrames;
        const bool closeEnough = zealot->getDistance(cachedPerch) <= 96;
 
        if (recent || closeEnough)
        {
            return cachedPerch;
        }
    }
 
    const auto* natArea = BWEM::Map::Instance().GetArea(enemyNaturalTile);
    const auto* mainArea = enemyMainTile.has_value()
        ? BWEM::Map::Instance().GetArea(*enemyMainTile)
        : nullptr;
 
    BWAPI::Position natCenter = enemyNaturalPos;
    if (natArea)
    {
        for (const auto& b : natArea->Bases())
        {
            if (b.Location() == enemyNaturalTile)
            {
                long long sx = 0;
                long long sy = 0;
                int n = 0;
 
                for (auto* m : b.Minerals())
                {
                    if (!m)
                    {
                        continue;
                    }
 
                    BWAPI::Position p(m->Pos());
                    if (!p.isValid())
                    {
                        continue;
                    }
 
                    sx += p.x;
                    sy += p.y;
                    ++n;
                }
 
                if (n > 0)
                {
                    natCenter = BWAPI::Position(int(sx / n), int(sy / n));
                }
 
                break;
            }
        }
    }
 
    BWAPI::Position myCenter = g_myMainPos.isValid()
        ? g_myMainPos
        : BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation());
 
    int dirx = myCenter.x - natCenter.x;
    int diry = myCenter.y - natCenter.y;
    if (dirx == 0 && diry == 0)
    {
        dirx = 1;
    }
 
    const int sight = BWAPI::UnitTypes::Protoss_Zealot.sightRange();
    const int want = std::max(0, sight - kEdgeMarginPx);
 
    const double len = std::max(1.0, std::sqrt(double(dirx * dirx + diry * diry)));
 
    BWAPI::Position candidate(
        natCenter.x + int((dirx / len) * want),
        natCenter.y + int((diry / len) * want)
    );
 
    BWAPI::Position clamped = clampToMapPx(candidate, 8);
 
    if (mainArea)
    {
        const auto* tgtArea = BWEM::Map::Instance().GetArea(BWAPI::TilePosition(clamped));
        if (tgtArea == mainArea)
        {
            for (int i = 0; i < 3; ++i)
            {
                const auto* a = BWEM::Map::Instance().GetArea(BWAPI::TilePosition(clamped));
                if (a != mainArea)
                {
                    break;
                }
 
                clamped = BWAPI::Position(
                    clamped.x + int((myCenter.x - clamped.x) * 0.3),
                    clamped.y + int((myCenter.y - clamped.y) * 0.3)
                );
 
                clamped = clampToMapPx(clamped, 8);
            }
        }
    }
 
    BWAPI::Position reachable = findReachableNearby(clamped);
 
    // Cache result to prevent constant goal changes.
    cachedPerch = reachable;
    cachedPerchFrame = now;
 
    return cachedPerch;
}

◆ pickNaturalChokeSpot()

BWAPI::Position ScoutingZealot::pickNaturalChokeSpot ( )

private

Definition at line 619 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return BWAPI::Positions::Invalid;
    }
 
    if (!enemyNaturalPos.isValid())
    {
        return enemyNaturalPos;
    }
 
    const int now = BWAPI::Broodwar->getFrameCount();
 
    if (cachedPerch.isValid())
    {
        const bool recent = (now - cachedPerchFrame) < kPerchRecalcFrames;
        const bool closeEnough = zealot->getDistance(cachedPerch) <= 96;
 
        if (recent || closeEnough)
        {
            return cachedPerch;
        }
    }
 
    const BWAPI::Position myCenter = g_myMainPos.isValid()
        ? g_myMainPos
        : BWAPI::Position(BWAPI::Broodwar->self()->getStartLocation());
 
    const BWEM::Area* natArea = BWEM::Map::Instance().GetArea(enemyNaturalTile);
    if (!natArea)
    {
        BWAPI::Position fallback = findReachableNearby(clampToMapPx(enemyNaturalPos, 8));
        cachedPerch = fallback;
        cachedPerchFrame = now;
        return cachedPerch;
    }
 
    BWAPI::Position best = BWAPI::Positions::Invalid;
    double bestScore = 1e30;
 
    for (const BWEM::ChokePoint* cp : natArea->ChokePoints())
    {
        if (!cp)
        {
            continue;
        }
 
        BWAPI::Position c(cp->Center());
        c = clampToMapPx(c, 8);
 
        if (!c.isValid())
        {
            continue;
        }
 
        if (!hasGroundPath(myCenter, c))
        {
            continue;
        }
 
        // Score:
        //  - close to natural
        //  - also "toward our base" by preferring shorter ground path to our base
        const double dn = groundPathLengthPx(enemyNaturalPos, c);
        const double dh = groundPathLengthPx(myCenter, c);
 
        const double score = dn + (0.45 * dh);
 
        if (score < bestScore)
        {
            bestScore = score;
            best = c;
        }
    }
 
    if (!best.isValid())
    {
        BWAPI::Position fallback = findReachableNearby(clampToMapPx(enemyNaturalPos, 8));
        cachedPerch = fallback;
        cachedPerchFrame = now;
        return cachedPerch;
    }
 
    // Nudge the choke point a little toward our base so we stay on "our side"
    {
        int vx = myCenter.x - best.x;
        int vy = myCenter.y - best.y;
 
        if (vx == 0 && vy == 0)
        {
            vx = 1;
        }
 
        const double len = std::max(1.0, std::sqrt(double(vx * vx + vy * vy)));
        const int stepPx = 3 * 32; // 3 tiles toward home
 
        best = BWAPI::Position(
            best.x + int((vx / len) * stepPx),
            best.y + int((vy / len) * stepPx)
        );
 
        best = clampToMapPx(best, 8);
    }
 
    // Avoid silly spots around geysers/minerals, then snap to reachable
    best = pushAwayFromResources(best, 3 * 32);
    best = findReachableNearby(best);
 
    cachedPerch = best;
    cachedPerchFrame = now;
 
    return cachedPerch;
}

◆ pushAwayFromResources()

BWAPI::Position ScoutingZealot::pushAwayFromResources	(	const BWAPI::Position &	p,
		int	clearPx ) const

private

Definition at line 812 of file ScoutingZealot.cpp.

{
    BWAPI::Position p = start;
 
    if (!p.isValid())
    {
        return p;
    }
 
    for (int i = 0; i < 6; ++i)
    {
        BWAPI::Unit r = closestNeutralResourceTo(p);
        if (!r)
        {
            break;
        }
 
        const BWAPI::Position rp = r->getPosition();
        const int d = rp.getApproxDistance(p);
 
        if (d >= clearPx)
        {
            break;
        }
 
        int vx = p.x - rp.x;
        int vy = p.y - rp.y;
 
        if (vx == 0 && vy == 0)
        {
            vx = 1;
        }
 
        const double len = std::max(1.0, std::sqrt(double(vx * vx + vy * vy)));
        const int need = clearPx - d;
 
        p = BWAPI::Position(
            p.x + int((vx / len) * need),
            p.y + int((vy / len) * need)
        );
 
        p = clampToMapPx(p, 16);
    }
 
    return p;
}

◆ rebuildProxyPoints()

void ScoutingZealot::rebuildProxyPoints ( )

private

Builds patrol points used for proxy scouting.

Generates positions around:

Main base chokes
Neighboring areas
Natural expansion
Map perimeter regions

Points are filtered for reachability and spacing.

Definition at line 1045 of file ScoutingZealot.cpp.

{
    if (proxyPointsBuiltOnce && !cachedProxyPoints.empty())
    {
        proxyPoints = cachedProxyPoints;
        proxyNextIdx = 0;
        proxyCurTarget = BWAPI::Positions::Invalid;
        return;
    }
    proxyPoints.clear();
    proxyNextIdx = 0;
    proxyCurTarget = BWAPI::Positions::Invalid;
 
    if (!zealot || !zealot->exists())
    {
        return;
    }
 
 
    
 
    const BWAPI::TilePosition myMainTp = BWAPI::Broodwar->self()->getStartLocation();
    const BWEM::Area* myMainArea = BWEM::Map::Instance().GetArea(myMainTp);
    if (!myMainArea)
    {
        return;
    }
 
    const BWAPI::Position myMainCenter = BWAPI::Position(myMainTp) + BWAPI::Position(16, 16);
 
    auto isInArea = [&](const BWEM::Area* area, const BWAPI::TilePosition& t) -> bool
    {
        if (!t.isValid() || !area)
        {
            return false;
        }
 
        const BWEM::Area* a = BWEM::Map::Instance().GetArea(t);
        return a == area;
    };
 
    auto addPoint = [&](BWAPI::Position p)
    {
        if (!p.isValid())
        {
            return;
        }
 
        p = clampToMapPx(p, 16);
 
        if (!hasGroundPath(myMainCenter, p))
        {
            return;
        }
 
        if (!isWalkablePx(p))
        {
            // Snap to something nearby that we can actually stand on
            p = findReachableNearby(p);
 
            if (!p.isValid() || !hasGroundPath(myMainCenter, p))
            {
                return;
            }
        }
 
        p = pushAwayFromResources(p, 3 * 32);
        p = findReachableNearby(p);
 
        if (!p.isValid() || !hasGroundPath(myMainCenter, p))
        {
            return;
        }
 
        for (const auto& existing : proxyPoints)
        {
            if (isNear(existing, p, 3 * 32)) // was 5*32
            {
                return;
            }
        }
 
        proxyPoints.push_back(p);
 
    };
 
    
 
    // 1) Main-area chokes
    for (const BWEM::ChokePoint* cp : myMainArea->ChokePoints())
    {
        if (!cp)
        {
            continue;
        }
        addPoint(BWAPI::Position(cp->Center()));
    }
 
    // 2) Neighbor-area chokes (typical proxy routes)
    for (const BWEM::Area* n : myMainArea->AccessibleNeighbours())
    {
        if (!n)
        {
            continue;
        }
 
        for (const BWEM::ChokePoint* cp : n->ChokePoints())
        {
            if (!cp)
            {
                continue;
            }
            addPoint(BWAPI::Position(cp->Center()));
        }
    }
 
    // 3) Add our natural base center (closest non-starting base not in main area)
    
 
    double bestDist = 1e30;
    BWAPI::Position bestNat = BWAPI::Positions::Invalid;
 
    for (const BWEM::Area& area : BWEM::Map::Instance().Areas())
    {
        for (const BWEM::Base& base : area.Bases())
        {
            if (base.Starting())
            {
                continue;
            }
 
            const BWEM::Area* bArea = BWEM::Map::Instance().GetArea(base.Location());
            if (bArea == myMainArea)
            {
                continue;
            }
 
            BWAPI::Position basePos = base.Center();
            if (!basePos.isValid())
            {
                basePos = BWAPI::Position(base.Location()) + BWAPI::Position(16, 16);
            }
 
            const auto& path = BWEM::Map::Instance().GetPath(myMainCenter, basePos, nullptr);
            if (path.empty())
            {
                continue;
            }
 
            const double d = groundPathLengthPx(myMainCenter, basePos);
            if (d < bestDist)
            {
                bestDist = d;
                bestNat = basePos;
            }
        }
    }
 
    if (bestNat.isValid())
    {
        addPoint(bestNat);
    }
 
    // If we somehow got nothing, at least patrol home
    if (proxyPoints.empty())
    {
        addPoint(g_myMainPos);
    }
 
    
 
    // 4) Perimeter ring: boundary tiles of our main area (proxy pylons tucked around edges)
    {
        const int stepTiles = 4; // lower = more points;
        const BWAPI::TilePosition topLeft = myMainArea->TopLeft();
        const BWAPI::TilePosition bottomRight = myMainArea->BottomRight();
 
        for (int y = topLeft.y; y <= bottomRight.y; y += stepTiles)
        {
            for (int x = topLeft.x; x <= bottomRight.x; x += stepTiles)
            {
                BWAPI::TilePosition t(x, y);
                if (!isInArea(myMainArea, t))
                {
                    continue;
                }
 
                // If any 4-neighbor is NOT in our main area, this is a boundary-ish tile
                const BWAPI::TilePosition n1(x + 1, y);
                const BWAPI::TilePosition n2(x - 1, y);
                const BWAPI::TilePosition n3(x, y + 1);
                const BWAPI::TilePosition n4(x, y - 1);
 
                if (isInArea(myMainArea, n1) && isInArea(myMainArea, n2) && isInArea(myMainArea, n3) && isInArea(myMainArea, n4))
                {
                    continue;
                }
 
                addPoint(BWAPI::Position(t) + BWAPI::Position(16, 16));
            }
        }
    }
    /*
    // 5) Air-close but ground-far points (cliff/maze-y proxy spots near us)
    {
        const double kMinRatio = 1.4;
        const int kMaxAirDist = 40 * 32;
        const int sampleStepTiles = 3;
        const double kMaxGroundDist = 140.0 * 32.0;
 
        const int margin = 12;
        const BWAPI::TilePosition topLeft = myMainArea->TopLeft();
        const BWAPI::TilePosition bottomRight = myMainArea->BottomRight();
 
        for (int y = topLeft.y - margin; y <= bottomRight.y + margin; y += sampleStepTiles)
        {
            for (int x = topLeft.x - margin; x <= bottomRight.x + margin; x += sampleStepTiles)
            {
                BWAPI::TilePosition t(x, y);
                if (!t.isValid())
                {
                    continue;
                }
 
                BWAPI::Position p = BWAPI::Position(t) + BWAPI::Position(16, 16);
                p = clampToMapPx(p, 16);
 
                const int air = myMainCenter.getApproxDistance(p);
                if (air > kMaxAirDist)
                {
                    continue;
                }
 
                const auto& path = BWEM::Map::Instance().GetPath(myMainCenter, p, nullptr);
                if (path.empty())
                {
                    continue;
                }
 
                const double ground = groundPathLengthPx(myMainCenter, p);
                if (ground <= 1.0)
                {
                    continue;
                }
 
                if (ground > kMaxGroundDist)
                {
                    continue;
                }
 
                if (ground >= double(air) * kMinRatio)
                {
                    addPoint(p);
                }
            }
        }
    }*/
    auto addRing = [&](BWAPI::Position center, int radius, int n)
    {
        for (int i = 0; i < n; ++i)
        {
            const double a = (6.28318530718 * i) / double(n);
            BWAPI::Position p(
                center.x + int(std::cos(a) * radius),
                center.y + int(std::sin(a) * radius)
            );
 
            addPoint(p);
        }
    };
 
    if ((int)proxyPoints.size() < 6)
    {
        BWAPI::Position c = myMainCenter;
        addRing(c, 8 * 32, 12);
        addRing(c, 12 * 32, 12);
 
        if (bestNat.isValid())
        {
            addRing(bestNat, 6 * 32, 10);
        }
    }
 
 
    // Order: nearest-neighbor greedy starting from zealot
    std::vector<BWAPI::Position> ordered;
    ordered.reserve(proxyPoints.size());
 
    BWAPI::Position cur = zealot->getPosition();
 
    while (!proxyPoints.empty())
    {
        int bestIdx = 0;
        int bestD = INT_MAX;
 
        for (int i = 0; i < (int)proxyPoints.size(); ++i)
        {
            const int d = cur.getApproxDistance(proxyPoints[i]);
            if (d < bestD)
            {
                bestD = d;
                bestIdx = i;
            }
        }
 
        ordered.push_back(proxyPoints[bestIdx]);
        cur = proxyPoints[bestIdx];
        proxyPoints.erase(proxyPoints.begin() + bestIdx);
    }
 
    
 
    proxyPoints = std::move(ordered);
 
 
    cachedProxyPoints = proxyPoints;
    proxyPointsBuiltOnce = !cachedProxyPoints.empty();
}

◆ retreatHomeMicro()

void ScoutingZealot::retreatHomeMicro ( BWAPI::Unit threat )

private

Executes retreat and kiting behavior toward home base.

Attempts to attack if possible, otherwise moves away from threats while maintaining safe distance.

Parameters

threat Primary threat unit

Definition at line 1411 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists())
    {
        return;
    }
 
    // If we're mid-windup / firing, don't change anything.
    if (zealot->isStartingAttack() || zealot->isAttackFrame())
    {
        return;
    }
 
    const int now = BWAPI::Broodwar->getFrameCount();
 
    BWAPI::Unit target = nullptr;
 
    // Stick to last target for a short window to avoid retarget stutter.
    if (lastAttackTarget && lastAttackTarget->exists())
    {
        if (now - lastTargetSelectFrame < kTargetStickFrames)
        {
            if (isGoodKiteTarget(lastAttackTarget, kThreatRadiusPx))
            {
                target = lastAttackTarget;
            }
        }
    }
 
    // If we don't have a sticky target, pick a new one.
    if (!target)
    {
        BWAPI::Unit candidate = nullptr;
 
        if (isGoodKiteTarget(threat, kThreatRadiusPx))
        {
            candidate = threat;
        }
        else
        {
            candidate = findPrimaryThreat(kThreatRadiusPx);
        }
 
        target = candidate;
 
        if (target)
        {
            lastAttackTarget = target;
            lastTargetSelectFrame = now;
        }
    }
 
    // If in range, try to shoot (tryFireAndCommit also "locks" the target).
    if (target && target->exists())
    {
        if (tryFireAndCommit(target))
        {
            return;
        }
    }
 
    // No shot right now: kite step.
    issueMove(homeRetreatPoint(), true, 64);
}

◆ setEnemyMain()

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

Sets the enemy main base location and updates scouting behavior.

Computes the enemy natural and transitions the unit to natural-edge scouting unless acting as a proxy patroller.

Parameters

tp	Enemy main tile position

Definition at line 183 of file ScoutingZealot.cpp.

                                                        {
    enemyMainTile = tp;
    enemyMainPos = Position(tp);
 
    // If this zealot is the proxy patrol zealot,
    // do NOT switch state into enemy natural logic.
    if (state == State::ProxyPatrol)
    {
        return;
    }
 
    computeEnemyNatural();
    state = enemyNaturalPos.isValid() ? State::MoveToNatural : State::WaitEnemyMain;
 
    // Immediate course set to the natural edge perch (don�t step into main first)
    if (enemyNaturalPos.isValid()) {
        issueMove(pickEdgeOfVisionSpot(), /*force*/true);
        //BWAPI::Broodwar->printf("[ZealotScout] setEnemyMain (%d,%d)", tp.x, tp.y);
    }
}

◆ setProxyPatroller()

void ScoutingZealot::setProxyPatroller ( bool v )

inline

Definition at line 39 of file ScoutingZealot.h.

    {
        isProxyPatroller = v;
    }

◆ threatenedNow()

bool ScoutingZealot::threatenedNow ( ) const

private

Checks whether the unit is currently threatened.

Considers nearby enemy combat units and attack status.

Returns: True if under threat

Definition at line 887 of file ScoutingZealot.cpp.

                                         {
    if (!zealot || !zealot->exists()) return false;
    if (zealot->isUnderAttack()) return true;
 
    for (auto& e : Broodwar->enemy()->getUnits()) {
        if (!e || !e->exists()) continue;
        if (e->getType().isWorker()) continue;         // <-- ignore workers
        if (!e->getType().canAttack()) continue;       // skip non-combat
        if (e->getDistance(zealot) < kThreatRadiusPx)  // inside danger bubble
            return true;
    }
    return false;
}

◆ tryFireAndCommit()

bool ScoutingZealot::tryFireAndCommit ( BWAPI::Unit target )

private

Attempts to attack a target and commit to the attack briefly.

Prevents attack cancellation during weapon windup.

Parameters

target Target unit

Returns: True if attack was issued or committed

Definition at line 1546 of file ScoutingZealot.cpp.

{
    if (!zealot || !zealot->exists() || !target || !target->exists())
    {
        return false;
    }
 
    if (!zealot->canAttackUnit(target))
    {
        return false;
    }
 
    if (!zealot->isInWeaponRange(target))
    {
        return false;
    }
 
    // Lock target choice even if weapon is cooling down.
    lastAttackTarget = target;
 
    const int now = BWAPI::Broodwar->getFrameCount();
    const int commit = attackCommitFrames();
 
    if (now - lastAttackCmdFrame < commit && lastAttackTarget == target)
    {
        lastTargetSelectFrame = now;
        return true;
    }
 
    if (zealot->getGroundWeaponCooldown() == 0)
    {
        zealot->attack(target);
        lastAttackCmdFrame = now;
        lastTargetSelectFrame = now;
        return true;
    }
 
    return false;
}

Member Data Documentation

◆ cachedPerch

BWAPI::Position ScoutingZealot::cachedPerch = BWAPI::Positions::Invalid

private

Definition at line 98 of file ScoutingZealot.h.

◆ cachedPerchFrame

int ScoutingZealot::cachedPerchFrame = -100000

private

Definition at line 99 of file ScoutingZealot.h.

◆ cachedProxyPoints

std::vector<BWAPI::Position> ScoutingZealot::cachedProxyPoints

private

Definition at line 93 of file ScoutingZealot.h.

◆ commanderRef

ProtoBotCommander* ScoutingZealot::commanderRef = nullptr

private

Definition at line 58 of file ScoutingZealot.h.

◆ enemyMainPos

BWAPI::Position ScoutingZealot::enemyMainPos = BWAPI::Positions::Invalid

private

Definition at line 63 of file ScoutingZealot.h.

◆ enemyMainTile

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

private

Definition at line 62 of file ScoutingZealot.h.

◆ enemyNaturalPos

BWAPI::Position ScoutingZealot::enemyNaturalPos = BWAPI::Positions::Invalid

private

Definition at line 65 of file ScoutingZealot.h.

◆ enemyNaturalTile

BWAPI::TilePosition ScoutingZealot::enemyNaturalTile = BWAPI::TilePositions::Invalid

private

Definition at line 64 of file ScoutingZealot.h.

◆ isProxyPatroller

bool ScoutingZealot::isProxyPatroller = false

private

Definition at line 92 of file ScoutingZealot.h.

◆ kCalmFramesToReturn

int ScoutingZealot::kCalmFramesToReturn = 72

staticconstexprprivate

Definition at line 73 of file ScoutingZealot.h.

◆ kDangerClosePx

int ScoutingZealot::kDangerClosePx = 96

staticconstexprprivate

Definition at line 75 of file ScoutingZealot.h.

◆ kEdgeMarginPx

int ScoutingZealot::kEdgeMarginPx = 24

staticconstexprprivate

Definition at line 70 of file ScoutingZealot.h.

◆ kGoalChangeResetDist

int ScoutingZealot::kGoalChangeResetDist = 64

staticconstexprprivate

Definition at line 107 of file ScoutingZealot.h.

◆ kMaxGroundDist

double ScoutingZealot::kMaxGroundDist = 180 * 32

staticconstexprprivate

Definition at line 84 of file ScoutingZealot.h.

◆ kMoveCooldownFrames

int ScoutingZealot::kMoveCooldownFrames = 8

staticconstexprprivate

Definition at line 69 of file ScoutingZealot.h.

◆ kPerchRecalcFrames

int ScoutingZealot::kPerchRecalcFrames = 24

staticconstexprprivate

Definition at line 106 of file ScoutingZealot.h.

◆ kProxyArriveDist

int ScoutingZealot::kProxyArriveDist = 96

staticconstexprprivate

Definition at line 82 of file ScoutingZealot.h.

◆ kProxyMinBetweenMoves

int ScoutingZealot::kProxyMinBetweenMoves = 12

staticconstexprprivate

Definition at line 83 of file ScoutingZealot.h.

◆ kProxyRebuildEveryFrames

int ScoutingZealot::kProxyRebuildEveryFrames = 24 * 10

staticconstexprprivate

Definition at line 81 of file ScoutingZealot.h.

◆ kRepositionStepPx

int ScoutingZealot::kRepositionStepPx = 160

staticconstexprprivate

Definition at line 72 of file ScoutingZealot.h.

◆ kTargetStickFrames

int ScoutingZealot::kTargetStickFrames = 18

staticconstexprprivate

Definition at line 78 of file ScoutingZealot.h.

◆ kThreatRadiusPx

int ScoutingZealot::kThreatRadiusPx = 256

staticconstexprprivate

Definition at line 71 of file ScoutingZealot.h.

◆ lastAttackCmdFrame

int ScoutingZealot::lastAttackCmdFrame = -100000

private

Definition at line 76 of file ScoutingZealot.h.

◆ lastAttackTarget

BWAPI::Unit ScoutingZealot::lastAttackTarget = nullptr

private

Definition at line 130 of file ScoutingZealot.h.

◆ lastIssuedGoal

BWAPI::Position ScoutingZealot::lastIssuedGoal = BWAPI::Positions::Invalid

private

Definition at line 101 of file ScoutingZealot.h.

◆ lastMoveIssueFrame

int ScoutingZealot::lastMoveIssueFrame = 0

private

Definition at line 68 of file ScoutingZealot.h.

◆ lastPos

BWAPI::Position ScoutingZealot::lastPos = BWAPI::Positions::Invalid

private

Definition at line 103 of file ScoutingZealot.h.

◆ lastTargetSelectFrame

int ScoutingZealot::lastTargetSelectFrame = -100000

private

Definition at line 77 of file ScoutingZealot.h.

◆ lastThreatFrame

int ScoutingZealot::lastThreatFrame = -100000

private

Definition at line 74 of file ScoutingZealot.h.

◆ manager

ScoutingManager* ScoutingZealot::manager = nullptr

private

Definition at line 59 of file ScoutingZealot.h.

◆ proxyCurTarget

BWAPI::Position ScoutingZealot::proxyCurTarget = BWAPI::Positions::Invalid

private

Definition at line 91 of file ScoutingZealot.h.

◆ proxyNextIdx

int ScoutingZealot::proxyNextIdx = 0

private

Definition at line 88 of file ScoutingZealot.h.

◆ proxyNextMoveFrame

int ScoutingZealot::proxyNextMoveFrame = 0

private

Definition at line 90 of file ScoutingZealot.h.

◆ proxyNextRebuildFrame

int ScoutingZealot::proxyNextRebuildFrame = 0

private

Definition at line 89 of file ScoutingZealot.h.

◆ proxyPoints

std::vector<BWAPI::Position> ScoutingZealot::proxyPoints

private

Definition at line 87 of file ScoutingZealot.h.

◆ proxyPointsBuiltOnce

bool ScoutingZealot::proxyPointsBuiltOnce = false

private

Definition at line 94 of file ScoutingZealot.h.

◆ proxyRebuildReadyFrame

int ScoutingZealot::proxyRebuildReadyFrame = 0

private

Definition at line 85 of file ScoutingZealot.h.

◆ returnStateAfterReposition

State ScoutingZealot::returnStateAfterReposition = State::HoldEdge

private

Definition at line 57 of file ScoutingZealot.h.

◆ state

State ScoutingZealot::state = State::Idle

private

Definition at line 67 of file ScoutingZealot.h.

◆ stuckFrames

int ScoutingZealot::stuckFrames = 0

private

Definition at line 104 of file ScoutingZealot.h.

◆ zealot

BWAPI::Unit ScoutingZealot::zealot = nullptr

private

Definition at line 60 of file ScoutingZealot.h.

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

src/protobot/ScoutingZealot.h
src/protobot/ScoutingZealot.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

◆ ScoutingZealot()

Member Function Documentation

◆ assign()

◆ attackCommitFrames()

◆ clampToMapPx()

◆ computeEnemyNatural()

◆ drawDebug()

◆ findInWeaponRangeTarget()

◆ findPrimaryThreat()

◆ findReachableNearby()

◆ groundPathLengthPx()

◆ hasScout()

◆ homeRetreatPoint()

◆ isGoodKiteTarget()

◆ isNear()

◆ issueMove()

◆ onFrame()

◆ onStart()

◆ onUnitDestroy()

◆ pickEdgeOfVisionSpot()

◆ pickNaturalChokeSpot()

◆ pushAwayFromResources()

◆ rebuildProxyPoints()

◆ retreatHomeMicro()

◆ setEnemyMain()

◆ setProxyPatroller()

◆ threatenedNow()

◆ tryFireAndCommit()

Member Data Documentation

◆ cachedPerch

◆ cachedPerchFrame

◆ cachedProxyPoints

◆ commanderRef

◆ enemyMainPos

◆ enemyMainTile

◆ enemyNaturalPos

◆ enemyNaturalTile

◆ isProxyPatroller

◆ kCalmFramesToReturn

◆ kDangerClosePx

◆ kEdgeMarginPx

◆ kGoalChangeResetDist

◆ kMaxGroundDist

◆ kMoveCooldownFrames

◆ kPerchRecalcFrames

◆ kProxyArriveDist

◆ kProxyMinBetweenMoves

◆ kProxyRebuildEveryFrames

◆ kRepositionStepPx

◆ kTargetStickFrames

◆ kThreatRadiusPx

◆ lastAttackCmdFrame

◆ lastAttackTarget

◆ lastIssuedGoal

◆ lastMoveIssueFrame

◆ lastPos

◆ lastTargetSelectFrame

◆ lastThreatFrame

◆ manager

◆ proxyCurTarget

◆ proxyNextIdx

◆ proxyNextMoveFrame

◆ proxyNextRebuildFrame

◆ proxyPoints

◆ proxyPointsBuiltOnce

◆ proxyRebuildReadyFrame

◆ returnStateAfterReposition

◆ state

◆ stuckFrames

◆ zealot