AttackingState Class Reference

The AttackingState has all units in the attacking squad move towards the assigned attack position. More...

#include <SquadStateTypes.h>

Inheritance diagram for AttackingState:

Public Member Functions
void	Enter (Squad *squad)
	Squad is added to AttackingSquads vector in CombatManager.
void	Update (Squad *squad)
	Every frame, loops through all units in the squad. For each unit, finds closest chokepoint position (for avoiding traffic jams).
void	Exit (Squad *squad)
	Squad is removed from AttackingSquads vector in CombatManager.

Static Public Member Functions
static SquadState &	getInstance ()

Public Attributes
set< BWAPI::Position >	chokepointPositions

Private Member Functions
	AttackingState (const AttackingState &)
AttackingState &	operator= (const AttackingState &)

Detailed Description

The AttackingState has all units in the attacking squad move towards the assigned attack position.

In the AttackingState, squads will attack the position. During this movement, three scenarios can occur
- If no enemy is near squad: Continue moving towards attack position
- If an enemy is near squad: Attack enemy and move away towards base while weapons are on cooldown (Kiting)
- If squad is near chokepoint: Ignore kiting behavior and move towards attack position even if weapons are on cooldown (This behavior stops squads from cluttering too much at chokepoints and causing traffic jams)

Definition at line 26 of file SquadStateTypes.h.

Constructor & Destructor Documentation

AttackingState()

AttackingState::AttackingState ( )

inlineprivate

Definition at line 51 of file SquadStateTypes.h.

{};

Member Function Documentation

Enter()

void AttackingState::Enter ( Squad * squad )

virtual

Squad is added to AttackingSquads vector in CombatManager.

Parameters

squad

Implements SquadState.

Definition at line 3 of file SquadStateTypes.cpp.

                                       {
    CombatManager::AttackingSquads.push_back(squad);
    const vector<BWEM::Area>& areas = bwemMap.Areas();
    
    // Grabbing all chokepoints for use in kiting through chokepoints
    for (int i = 0; i < areas.size(); i++) {
        const BWEM::Area* area = bwemMap.GetArea(BWAPI::WalkPosition(areas.at(i).Top()));
        for (const BWEM::ChokePoint* cp : area->ChokePoints()) {
            chokepointPositions.insert(BWAPI::Position(cp->Center()));
        }
    }
 
#ifdef DEBUG_STATES
    cout << "(" << squad->info.squadId << ")" << "Entered ATTACKING state" << endl;
#endif
}

Exit()

void AttackingState::Exit ( Squad * squad )

virtual

Squad is removed from AttackingSquads vector in CombatManager.

Parameters

squad

Implements SquadState.

Definition at line 55 of file SquadStateTypes.cpp.

                                      {
    CombatManager::AttackingSquads.erase(remove(CombatManager::AttackingSquads.begin(), CombatManager::AttackingSquads.end(), squad), CombatManager::AttackingSquads.end());
 
#ifdef DEBUG_STATES
    cout << "(" << squad->info.squadId << ")" << "Exited ATTACKING state" << endl;
#endif
}

getInstance()

SquadState & AttackingState::getInstance ( )

static

Definition at line 63 of file SquadStateTypes.cpp.

{
    static AttackingState singleton;
    return singleton;
}

operator=()

AttackingState & AttackingState::operator= ( const AttackingState & )

inlineprivate

Definition at line 53 of file SquadStateTypes.h.

{};

Update()

void AttackingState::Update ( Squad * squad )

virtual

Every frame, loops through all units in the squad.
For each unit, finds closest chokepoint position (for avoiding traffic jams).

If unit is melee, applies kitingMelee() method from KitingBehaviors class.
If unit is ranged, applies kitingRanged() method from KitingBehaviors class.

Parameters

squad

Implements SquadState.

Definition at line 20 of file SquadStateTypes.cpp.

                                        {
 
    if (!squad->info.commandPos.isValid()) {
        return;
    }
 
    if (squad->info.currentAttackPosition != squad->info.commandPos) {
        squad->info.currentAttackPosition = squad->info.commandPos;
    }
 
    if (BWAPI::Broodwar->getFrameCount() % KITING_FRAME_DELAY != 0) {
        return;
    }
 
    for (BWAPI::Unit& unit : squad->info.units)
    {
        BWAPI::Position closestCPPosition = BWAPI::Positions::Invalid;
        int closestDist = INT_MAX;
        for (BWAPI::Position cpCenter : chokepointPositions) {
            const int dist = unit->getPosition().getApproxDistance(cpCenter);
            if (dist < closestDist) {
                closestDist = dist;
                closestCPPosition = cpCenter;
            }
        }
 
        if (unit->getType() == BWAPI::UnitTypes::Protoss_Zealot) {
            KitingBehaviors::kitingMelee(unit, squad->info.currentAttackPosition);
        }
        else if (unit->getType() == BWAPI::UnitTypes::Protoss_Dragoon) {
            KitingBehaviors::kitingRanged(unit, squad->info.currentAttackPosition, closestCPPosition);
        }
    }
}

Member Data Documentation

chokepointPositions

set<BWAPI::Position> AttackingState::chokepointPositions

Definition at line 49 of file SquadStateTypes.h.

---

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

• src/protobot/SquadStateTypes.h
• src/protobot/SquadStateTypes.cpp