|
BWAPI
|
|
BWAPI
|
#include <BorderTracker.h>
Public Member Functions | |
| BorderTrackerClass () | |
| const std::map< PositionType, std::set< BorderPosition > > & | getBorderPositions () const |
| const std::set< BorderPosition > & | getBorderPositions (PositionType type) |
| void | onBegin () |
| void | update () |
| void | toggleDebugInfo () |
Private Member Functions | |
| void | recalculateBorders () |
| void | drawDebugInfo (std::map< PositionType, std::set< BorderPosition >>::const_iterator it) |
Private Attributes | |
| std::map< PositionType, std::set< BorderPosition > > | mBorderPositions |
| std::set< Base > | mMyBases |
| std::set< Base > | mEnemyBases |
| std::set< Region > | mMyRegions |
| std::set< Region > | mMyForwardRegions |
| std::set< Region > | mEnemyRegions |
| std::set< Chokepoint > | mMyBorder |
| std::set< Chokepoint > | mMyForwardBorder |
| std::set< Chokepoint > | mEnemyBorder |
| bool | mShowDebugInfo |
| std::set< Region > | mLargeRegions |
Definition at line 8 of file BorderTracker.h.
| BorderTrackerClass::BorderTrackerClass | ( | ) | [inline] |
Definition at line 11 of file BorderTracker.h.
{}
| void BorderTrackerClass::drawDebugInfo | ( | std::map< PositionType, std::set< BorderPosition >>::const_iterator | it | ) | [private] |
Definition at line 278 of file BorderTracker.cpp.
References BWAPI::Colors::Blue, PositionTypeDef::BotControlRegion, PositionTypeDef::ContainChokepoint, PositionTypeDef::DefenseChokepoint, PositionTypeDef::EnemyChokepoint, PositionTypeDef::EnemyControlRegion, PositionTypeDef::ForwardChokepoint, PositionTypeDef::ForwardRegion, BWAPI::Colors::Green, BWAPI::Colors::Grey, mBorderPositions, BWAPI::Colors::Orange, BWAPI::Colors::Purple, BWAPI::Colors::Red, and BWAPI::Colors::Yellow.
Referenced by update().
{
if(it == mBorderPositions.end() || it->second.size() == 0)
return;
for(std::set<BorderPosition>::const_iterator bp = it->second.begin(); bp != it->second.end(); ++bp)
{
switch(bp->mType.underlying())
{
case PositionType::ContainChokepoint:
case PositionType::ForwardChokepoint:
case PositionType::EnemyChokepoint:
case PositionType::DefenseChokepoint:
{
BWAPI::Color color = bp->mType == PositionType::DefenseChokepoint ? BWAPI::Colors::Green : (bp->mType == PositionType::EnemyChokepoint ? BWAPI::Colors::Red : (bp->mType == PositionType::ForwardChokepoint ? BWAPI::Colors::Blue : BWAPI::Colors::Yellow));
bp->mChoke->draw(color);
break;
}
case PositionType::EnemyControlRegion:
case PositionType::BotControlRegion:
case PositionType::ForwardRegion:
{
BWAPI::Color color = bp->mType == PositionType::BotControlRegion ? BWAPI::Colors::Grey : (bp->mType == PositionType::ForwardRegion ? BWAPI::Colors::Orange : BWAPI::Colors::Purple);
bp->mRegion->draw(color);
break;
}
}
}
}
| const std::map<PositionType, std::set<BorderPosition> >& BorderTrackerClass::getBorderPositions | ( | ) | const [inline] |
Definition at line 13 of file BorderTracker.h.
References mBorderPositions.
{ return mBorderPositions; }
| const std::set<BorderPosition>& BorderTrackerClass::getBorderPositions | ( | PositionType | type | ) | [inline] |
Definition at line 14 of file BorderTracker.h.
References mBorderPositions.
{ return mBorderPositions[type]; }
| void BorderTrackerClass::onBegin | ( | ) |
Definition at line 6 of file BorderTracker.cpp.
References Singleton< T >::Instance(), and mLargeRegions.
{
for each(Region region in TerrainAnaysis::Instance().getRegions())
{
if(region->getSize() > 100000)
mLargeRegions.insert(region);
}
}
| void BorderTrackerClass::recalculateBorders | ( | ) | [private] |
Definition at line 47 of file BorderTracker.cpp.
References PositionTypeDef::BotControlRegion, PositionTypeDef::DefenseChokepoint, PositionTypeDef::EnemyChokepoint, PositionTypeDef::EnemyControlRegion, PositionTypeDef::ForwardChokepoint, PositionTypeDef::ForwardRegion, Singleton< T >::Instance(), mBorderPositions, mEnemyBases, mEnemyBorder, mEnemyRegions, mLargeRegions, mMyBases, mMyBorder, mMyForwardBorder, mMyForwardRegions, mMyRegions, PositionTypeDef::SharedChokepoint, and PositionTypeDef::TechDefenseChokepoint.
Referenced by update().
{
mMyRegions.clear();
mMyForwardRegions.clear();
mMyBorder.clear();
mMyForwardBorder.clear();
mEnemyRegions.clear();
mEnemyBorder.clear();
mBorderPositions.clear();
std::set<Region> canReachSelf;
std::set<Region> canReachEnemy;
std::map<Region, int> regionTech;
//Add all my regions to the set
for each(Base base in mMyBases)
{
if(mLargeRegions.count(base->getRegion()) == 0)
{
regionTech[base->getRegion()] += base->getNumberOfTechBuildings();
mMyRegions.insert(base->getRegion());
canReachSelf.insert(base->getRegion());
}
}
//Add all enemy regions to the set
for each(Base base in mEnemyBases)
{
if(mLargeRegions.count(base->getRegion()) == 0)
{
regionTech[base->getRegion()] += base->getNumberOfTechBuildings();
mEnemyRegions.insert(base->getRegion());
canReachEnemy.insert(base->getRegion());
}
}
//If there are enemy bases
if(!mEnemyBases.empty())
{
bool exploring = true;
while(exploring)
{
exploring = false;
//Go through the regions
for each(Region region in TerrainAnaysis::Instance().getRegions())
{
for each(Chokepoint chokepoint in region->getChokepoints())
{
Region secondRegion = chokepoint->getRegions().first;
if(region == secondRegion)
secondRegion = chokepoint->getRegions().second;
//if this region is in the set and the connected region cannot be reached by the enemy, it can be considered ours.
if(canReachSelf.count(region) != 0 && mEnemyRegions.count(secondRegion) == 0 && canReachSelf.count(secondRegion) == 0)
{
canReachSelf.insert(secondRegion);
exploring = true;
}
//if this region is in the set and the connected region cannot be reached by me, it can be considered the enemies.
if(canReachEnemy.count(region) != 0 && mMyRegions.count(secondRegion) == 0 && canReachEnemy.count(secondRegion) == 0)
{
canReachEnemy.insert(secondRegion);
exploring = true;
}
}
}
}
}
for each(Region region in TerrainAnaysis::Instance().getRegions())
{
//if we can reach this region and the enemy can't, it can be ours
if(canReachSelf.count(region) != 0 && canReachEnemy.count(region) == 0)
{
mBorderPositions[PositionType::BotControlRegion].insert(BorderPosition(PositionType::BotControlRegion, region));
mMyRegions.insert(region);
mMyForwardRegions.insert(region);
}
//if we cant reach this region and the enemy can, it can be the enemies
if(canReachSelf.count(region) == 0 && canReachEnemy.count(region) != 0)
{
mBorderPositions[PositionType::EnemyControlRegion].insert(BorderPosition(PositionType::EnemyControlRegion, region));
mEnemyRegions.insert(region);
}
}
//any chokepoints that dont straddle 2 regions are defense chokepoints
for each(Region region in mMyRegions)
{
for each(Chokepoint chokepoint in region->getChokepoints())
{
if(mMyBorder.count(chokepoint) == 0)
mMyBorder.insert(chokepoint);
else
mMyBorder.erase(chokepoint);
}
}
std::map<Chokepoint, int> borderChokeTech;
for each(Chokepoint chokepoint in mMyBorder)
{
Region startRegion = chokepoint->getRegions().first;
if(mMyRegions.count(startRegion) == 0)
startRegion = chokepoint->getRegions().second;
std::set<Region> visitedRegions;
std::set<Region> unvisitedRegions;
int controlledAreaTech = 0;
unvisitedRegions.insert(startRegion);
while(!unvisitedRegions.empty())
{
std::set<Region>::iterator it = unvisitedRegions.begin();
visitedRegions.insert(*it);
controlledAreaTech += regionTech[*it];
for each(Chokepoint connectedChoke in (*it)->getChokepoints())
{
if(mMyBorder.count(connectedChoke) != 0)
continue;
Region connectedRegion = connectedChoke->getRegions().first;
if(connectedRegion == *it)
connectedRegion = connectedChoke->getRegions().second;
if(visitedRegions.count(connectedRegion) == 0)
unvisitedRegions.insert(connectedRegion);
}
unvisitedRegions.erase(it);
}
borderChokeTech[chokepoint] = controlledAreaTech;
}
for each(Region region in mEnemyRegions)
{
for each(Chokepoint chokepoint in region->getChokepoints())
{
if (mEnemyBorder.count(chokepoint) == 0)
mEnemyBorder.insert(chokepoint);
else
mEnemyBorder.erase(chokepoint);
}
}
mMyForwardBorder = mMyBorder;
for each(Chokepoint chokepoint in mMyBorder)
{
mBorderPositions[PositionType::DefenseChokepoint].insert(BorderPosition(PositionType::DefenseChokepoint, chokepoint));
if(mEnemyBorder.count(chokepoint) != 0)
mBorderPositions[PositionType::SharedChokepoint].insert(BorderPosition(PositionType::SharedChokepoint, chokepoint));
if(borderChokeTech[chokepoint] > 0)
mBorderPositions[PositionType::TechDefenseChokepoint].insert(BorderPosition(PositionType::TechDefenseChokepoint, chokepoint));
}
for each(Chokepoint chokepoint in mEnemyBorder)
{
mBorderPositions[PositionType::EnemyChokepoint].insert(BorderPosition(PositionType::EnemyChokepoint, chokepoint));
}
if(!mEnemyBases.empty())
{
bool expanding = true;
while(expanding)
{
expanding = false;
for each(Chokepoint chokepoint in mMyForwardBorder)
{
//get the region the otherside of this chokepoint
Region region = chokepoint->getRegions().first;
if(mMyForwardRegions.count(region) != 0)
region = chokepoint->getRegions().second;
//make sure it isn't an enemy region
if(mEnemyRegions.find(region) != mEnemyRegions.end())
continue;
int oldCount = 0;
int newCount = 0;
//count the number of chokepoints part of our border and those not
for each(Chokepoint chokepoint in region->getChokepoints())
{
if(mMyForwardBorder.find(chokepoint) != mMyForwardBorder.end())
++oldCount;
else
++newCount;
}
//if we can reduce the number of chokepoints
if(newCount <= oldCount)
{
//reverse regions, so we consider this region ours.
for each(Chokepoint chokepoint in region->getChokepoints())
{
if(mMyForwardBorder.count(chokepoint) != 0)
mMyForwardBorder.erase(chokepoint);
else
mMyForwardBorder.insert(chokepoint);
}
mMyForwardRegions.insert(region);
expanding = true;
break;
}
}
}
}
for each(Chokepoint chokepoint in mMyForwardBorder)
{
if(mMyBorder.count(chokepoint) == 0)
mBorderPositions[PositionType::ForwardChokepoint].insert(BorderPosition(PositionType::ForwardChokepoint, chokepoint));
}
for each(Region region in mMyForwardRegions)
{
if(mMyRegions.count(region) == 0)
mBorderPositions[PositionType::ForwardRegion].insert(BorderPosition(PositionType::ForwardRegion, region));
}
}
| void BorderTrackerClass::toggleDebugInfo | ( | ) | [inline] |
Definition at line 19 of file BorderTracker.h.
References mShowDebugInfo.
{ mShowDebugInfo = !mShowDebugInfo; }
| void BorderTrackerClass::update | ( | ) |
Definition at line 15 of file BorderTracker.cpp.
References PositionTypeDef::BotControlRegion, PositionTypeDef::ContainChokepoint, PositionTypeDef::DefenseChokepoint, drawDebugInfo(), PositionTypeDef::EnemyChokepoint, PositionTypeDef::EnemyControlRegion, PositionTypeDef::ForwardChokepoint, PositionTypeDef::ForwardRegion, PositionTypeDef::HoldBase, Singleton< T >::Instance(), mBorderPositions, mEnemyBases, mLargeRegions, mMyBases, mShowDebugInfo, PositionTypeDef::Position, recalculateBorders(), BWAPI::Colors::Red, PositionTypeDef::SharedChokepoint, and PositionTypeDef::TechDefenseChokepoint.
{
std::set<Base> myBases = BaseTracker::Instance().getImportantBases();
std::set<Base> enemyBases = BaseTracker::Instance().getEnemyImportantBases();
if(enemyBases != mEnemyBases || myBases != mMyBases)
{
mMyBases = myBases;
mEnemyBases = enemyBases;
recalculateBorders();
}
drawDebugInfo(mBorderPositions.find(PositionType::TechDefenseChokepoint));
if(mShowDebugInfo)
{
for each(Region region in mLargeRegions)
{
region->draw(BWAPI::Colors::Red);
}
drawDebugInfo(mBorderPositions.find(PositionType::EnemyControlRegion));
drawDebugInfo(mBorderPositions.find(PositionType::BotControlRegion));
drawDebugInfo(mBorderPositions.find(PositionType::ForwardRegion));
drawDebugInfo(mBorderPositions.find(PositionType::ContainChokepoint));
drawDebugInfo(mBorderPositions.find(PositionType::ForwardChokepoint));
drawDebugInfo(mBorderPositions.find(PositionType::EnemyChokepoint));
drawDebugInfo(mBorderPositions.find(PositionType::DefenseChokepoint));
drawDebugInfo(mBorderPositions.find(PositionType::SharedChokepoint));
drawDebugInfo(mBorderPositions.find(PositionType::Position));
drawDebugInfo(mBorderPositions.find(PositionType::HoldBase));
}
}
std::map<PositionType, std::set<BorderPosition> > BorderTrackerClass::mBorderPositions [private] |
Definition at line 24 of file BorderTracker.h.
Referenced by drawDebugInfo(), getBorderPositions(), recalculateBorders(), and update().
std::set<Base> BorderTrackerClass::mEnemyBases [private] |
Definition at line 27 of file BorderTracker.h.
Referenced by recalculateBorders(), and update().
std::set<Chokepoint> BorderTrackerClass::mEnemyBorder [private] |
Definition at line 35 of file BorderTracker.h.
Referenced by recalculateBorders().
std::set<Region> BorderTrackerClass::mEnemyRegions [private] |
Definition at line 31 of file BorderTracker.h.
Referenced by recalculateBorders().
std::set<Region> BorderTrackerClass::mLargeRegions [private] |
Definition at line 39 of file BorderTracker.h.
Referenced by onBegin(), recalculateBorders(), and update().
std::set<Base> BorderTrackerClass::mMyBases [private] |
Definition at line 26 of file BorderTracker.h.
Referenced by recalculateBorders(), and update().
std::set<Chokepoint> BorderTrackerClass::mMyBorder [private] |
Definition at line 33 of file BorderTracker.h.
Referenced by recalculateBorders().
std::set<Chokepoint> BorderTrackerClass::mMyForwardBorder [private] |
Definition at line 34 of file BorderTracker.h.
Referenced by recalculateBorders().
std::set<Region> BorderTrackerClass::mMyForwardRegions [private] |
Definition at line 30 of file BorderTracker.h.
Referenced by recalculateBorders().
std::set<Region> BorderTrackerClass::mMyRegions [private] |
Definition at line 29 of file BorderTracker.h.
Referenced by recalculateBorders().
bool BorderTrackerClass::mShowDebugInfo [private] |
Definition at line 37 of file BorderTracker.h.
Referenced by toggleDebugInfo(), and update().
1.7.6.1