BWAPI
Public Member Functions | Private Member Functions | Private Attributes
RequirementGroup Class Reference

#include <RequirementGroup.h>

List of all members.

Public Member Functions

 RequirementGroup ()
std::pair< int, int > earliestTime ()
bool operator== (const RequirementGroup &other) const
bool operator< (const RequirementGroup &other) const
void reserve (int time)
bool empty () const
void clear ()
UnitGroup getUnits () const
void addMineralRequirement (int minerals)
void addGasRequirement (int gas)
void addSupplyRequirement (int supply)
void addTimeRequirement (int time)
void addUnitRequirement (Unit unit, int priority, int duration, Position position=BWAPI::Positions::None)
void addUnitFilterRequirement (int priority, int duration, UnitFilter unitFilter, Position position=BWAPI::Positions::None)
void addUnitFilterRequirement (int priority, int duration, UnitFilter unitFilter, int quantity, Position position=BWAPI::Positions::None)
void addTechForTypeRequirement (BWAPI::UnitType unitType)
void addTechForTypeRequirement (BWAPI::UpgradeType upgradeType, int level)
void addTechForTypeRequirement (BWAPI::TechType techType)

Private Member Functions

bool recurseForUnitTime (int &latestTime, std::vector< Requirement >::iterator currentRequirement, int currentStartTime, int currentEndTime, std::set< Unit > &currentUnits)

Private Attributes

std::vector< RequirementmOtherRequirements
std::vector< RequirementmUnitRequirements

Detailed Description

Definition at line 8 of file RequirementGroup.h.


Constructor & Destructor Documentation

Definition at line 5 of file RequirementGroup.cpp.

{
}

Member Function Documentation

void RequirementGroup::addGasRequirement ( int  gas) [inline]
void RequirementGroup::addMineralRequirement ( int  minerals) [inline]
void RequirementGroup::addSupplyRequirement ( int  supply) [inline]
void RequirementGroup::addTechForTypeRequirement ( BWAPI::UpgradeType  upgradeType,
int  level 
) [inline]

Definition at line 35 of file RequirementGroup.h.

References mOtherRequirements.

{ mOtherRequirements.push_back(Requirement(upgradeType, level)); }

Definition at line 36 of file RequirementGroup.h.

References mOtherRequirements.

{ mOtherRequirements.push_back(Requirement(techType)); }
void RequirementGroup::addTimeRequirement ( int  time) [inline]

Definition at line 28 of file RequirementGroup.h.

References mOtherRequirements, and RequirementTypeDef::Time.

Referenced by GatherTask::updateRequirements().

Here is the caller graph for this function:

void RequirementGroup::addUnitFilterRequirement ( int  priority,
int  duration,
UnitFilter  unitFilter,
Position  position = BWAPI::Positions::None 
) [inline]
void RequirementGroup::addUnitFilterRequirement ( int  priority,
int  duration,
UnitFilter  unitFilter,
int  quantity,
Position  position = BWAPI::Positions::None 
)

Definition at line 125 of file RequirementGroup.cpp.

References addUnitFilterRequirement().

{
        for(int i = 0; i < quantity; ++i)
                addUnitFilterRequirement(priority, duration, unitFilter, position);
}

Here is the call graph for this function:

void RequirementGroup::addUnitRequirement ( Unit  unit,
int  priority,
int  duration,
Position  position = BWAPI::Positions::None 
) [inline]

Definition at line 30 of file RequirementGroup.h.

References mUnitRequirements.

Referenced by DefaultSquadTask::updateRequirements().

{ mUnitRequirements.push_back(Requirement(priority, duration, unit, position)); }

Here is the caller graph for this function:

Definition at line 101 of file RequirementGroup.cpp.

References mOtherRequirements, and mUnitRequirements.

{
        mOtherRequirements.clear();
        mUnitRequirements.clear();
}
std::pair< int, int > RequirementGroup::earliestTime ( )

Definition at line 9 of file RequirementGroup.cpp.

References BWAPI::Broodwar, BWAPI::Game::getFrameCount(), Requirement::maxTime, mOtherRequirements, mUnitRequirements, and recurseForUnitTime().

Referenced by TaskManagerClass::updateRequirement().

{
        int latestTime = BWAPI::Broodwar->getFrameCount();

        // Loop through all normal requirements
        for(std::vector<Requirement>::iterator requirement = mOtherRequirements.begin(); requirement != mOtherRequirements.end(); ++requirement)
        {
                assert(!requirement->unitRequirement());

                // If the easliest time this requirement is ready is the latest yet, save it
                int thisTime = requirement->earliestTime();
                if(thisTime > latestTime)
                        latestTime = thisTime;
        }

        // Recurse through unit requirements
        std::set<Unit> units;
        if(recurseForUnitTime(latestTime, mUnitRequirements.begin(), latestTime, Requirement::maxTime, units))
        {
                int biggestDelay = 0;
                // now loop through to find any delay in the execution
                for(std::vector<Requirement>::iterator requirement = mUnitRequirements.begin(); requirement != mUnitRequirements.end(); ++requirement)
                {
                        int thisDelay = requirement->getDelay();
                        if(thisDelay > biggestDelay)
                                biggestDelay = thisDelay;
                }

                return std::make_pair(latestTime, biggestDelay);
        }

        // if it didn't find a time, just return
        return std::make_pair(Requirement::maxTime, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool RequirementGroup::empty ( ) const

Definition at line 93 of file RequirementGroup.cpp.

References mOtherRequirements, and mUnitRequirements.

Referenced by TaskManagerClass::updateRequirement().

{
        if(!mOtherRequirements.empty())
                return false;

        return mUnitRequirements.empty();
}

Here is the caller graph for this function:

Definition at line 107 of file RequirementGroup.cpp.

References UnitGroup::insert(), and mUnitRequirements.

Referenced by TaskManagerClass::updateRequirement().

{
        UnitGroup units;
        for(std::vector<Requirement>::const_iterator requirement = mUnitRequirements.begin(); requirement != mUnitRequirements.end(); ++requirement)
                units.insert(requirement->getUnit());

        return units;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool RequirementGroup::operator< ( const RequirementGroup other) const

Definition at line 85 of file RequirementGroup.cpp.

References mOtherRequirements, and mUnitRequirements.

{
        if(mOtherRequirements < other.mOtherRequirements)
                return true;

        return mUnitRequirements < other.mUnitRequirements;
}
bool RequirementGroup::operator== ( const RequirementGroup other) const

Definition at line 77 of file RequirementGroup.cpp.

References mOtherRequirements, and mUnitRequirements.

{
        if(mOtherRequirements == other.mOtherRequirements)
                return mUnitRequirements == other.mUnitRequirements;

        return false;
}
bool RequirementGroup::recurseForUnitTime ( int &  latestTime,
std::vector< Requirement >::iterator  currentRequirement,
int  currentStartTime,
int  currentEndTime,
std::set< Unit > &  currentUnits 
) [private]

Definition at line 44 of file RequirementGroup.cpp.

References Requirement::maxTime, and mUnitRequirements.

Referenced by earliestTime().

{
        // If we have reached the end we have found a time, save it and return
        if(currentRequirement == mUnitRequirements.end())
        {
                latestTime = currentStartTime;
                return true;
        }

        assert(currentRequirement->unitRequirement());

        // get a selection of free times for this requirement
        const std::map<int, int> &unitTimes = currentRequirement->earliestUnitTime(currentStartTime, currentEndTime, currentUnits);

        // For each one
        for(std::map<int, int>::const_iterator it = unitTimes.begin(); it != unitTimes.end(); ++it)
        {
                currentUnits.insert(currentRequirement->getUnit());

                int newEndTime = it->second;
                if(newEndTime != Requirement::maxTime)
                        newEndTime += it->first;

                // go to the next requirement with these times to see if it is suitable for the rest too
                if(recurseForUnitTime(latestTime, ++(std::vector<Requirement>::iterator(currentRequirement)), it->first, newEndTime, currentUnits))
                        return true;

                currentUnits.erase(currentRequirement->getUnit());
        }

        return false;
}

Here is the caller graph for this function:

void RequirementGroup::reserve ( int  time)

Definition at line 116 of file RequirementGroup.cpp.

References mOtherRequirements, and mUnitRequirements.

Referenced by TaskManagerClass::updateRequirement().

{
        for(std::vector<Requirement>::iterator requirement = mOtherRequirements.begin(); requirement != mOtherRequirements.end(); ++requirement)
                requirement->reserve(time);

        for(std::vector<Requirement>::iterator requirement = mUnitRequirements.begin(); requirement != mUnitRequirements.end(); ++requirement)
                requirement->reserve(time);
}

Here is the caller graph for this function:


Member Data Documentation


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines