size_t UnitUtil::GetAllUnitCount(BWAPI::UnitType type)
{
size_t count = 0;
for (const auto & unit : BWAPI::Broodwar->self()->getUnits())
{
// trivial case: unit which exists matches the type
if (unit->getType() == type)
{
count++;
}
// case where a zerg egg contains the unit type
if (unit->getType() == BWAPI::UnitTypes::Zerg_Egg && unit->getBuildType() == type)
{
count += type.isTwoUnitsInOneEgg() ? 2 : 1;
}
// case where a building has started constructing a unit but it doesn't yet have a unit associated with it
if (unit->getRemainingTrainTime() > 0)
{
BWAPI::UnitType trainType = unit->getLastCommand().getUnitType();
if (trainType == type && unit->getRemainingTrainTime() == trainType.buildTime())
{
count++;
}
}
}
return count;
}
void UnitClass::build(TilePosition target, BWAPI::UnitType type)
{
if(exists())
{
const Position targetPosition(target.x()*32+type.tileWidth()*16, target.y()*32+type.tileHeight()*16);
if(getDistance(type, targetPosition) > 48 || !MapHelper::isAllVisible(target, type))
{
move(targetPosition, 0);
return;
}
if(mUnit->getOrder() == BWAPI::Orders::PlaceBuilding)
{
if(mUnit->getBuildType() == type && mUnit->getOrderTargetPosition() == targetPosition)
return;
}
if(mUnit->getLastCommand().getType() == BWAPI::UnitCommandTypes::Build && mUnit->getLastCommand().getUnitType() == type && mUnit->getLastCommand().getTargetTilePosition() == target)
{
if(mLastOrderExecuteTime >= BWAPI::Broodwar->getFrameCount())
return;
}
if(mUnit->build(target, type))
mLastOrderExecuteTime = BWAPI::Broodwar->getFrameCount() + BWAPI::Broodwar->getRemainingLatencyFrames();
else
move(targetPosition, 0);
}
}
void checkSupportedUnitType(const BWAPI::UnitType & type)
{
if (type == BWAPI::UnitTypes::None || type == BWAPI::UnitTypes::Unknown)
{
System::FatalError("Unknown unit type in experiment file");
}
if (type == BWAPI::UnitTypes::Protoss_Corsair ||
type == BWAPI::UnitTypes::Zerg_Devourer ||
type == BWAPI::UnitTypes::Zerg_Scourge ||
type == BWAPI::UnitTypes::Terran_Valkyrie)
{
System::FatalError("Units with just air weapons currently not supported correctly: " + type.getName());
}
if (type.isBuilding() && (type != BWAPI::UnitTypes::Protoss_Photon_Cannon || type != BWAPI::UnitTypes::Zerg_Sunken_Colony || type != BWAPI::UnitTypes::Terran_Missile_Turret))
{
System::FatalError("Non-attacking buildings not currently supported: " + type.getName());
}
if (type.isSpellcaster())
{
System::FatalError("Spell casting units not currently supported: " + type.getName());
}
}
// get the attack priority of a type in relation to a zergling
int RangedManager::getAttackPriority(BWAPI::UnitInterface* rangedUnit, BWAPI::UnitInterface* target)
{
BWAPI::UnitType rangedUnitType = rangedUnit->getType();
BWAPI::UnitType targetType = target->getType();
bool canAttackUs = rangedUnitType.isFlyer() ? targetType.airWeapon() != BWAPI::WeaponTypes::None : targetType.groundWeapon() != BWAPI::WeaponTypes::None;
// highest priority is something that can attack us or aid in combat
if (targetType == BWAPI::UnitTypes::Terran_Medic || canAttackUs ||
targetType == BWAPI::UnitTypes::Terran_Bunker)
{
return 3;
}
// next priority is worker
else if (targetType.isWorker())
{
return 2;
}
// then everything else
else
{
return 1;
}
}
bool BuildOrderManager::hasResources(BWAPI::UnitType t)
{
if (BWAPI::Broodwar->self()->cumulativeMinerals()-this->usedMinerals<t.mineralPrice())
return false;
if (BWAPI::Broodwar->self()->cumulativeGas()-this->usedGas<t.gasPrice())
return false;
return true;
}
void sim::UnitProps::SetType(BWAPI::UnitType type)
{
this->type = type;
maxEnergy[0] = maxEnergy[1] = type.maxEnergy();
sightRange[0] = sightRange[1] = type.sightRange() << pixelShift;
extraArmor[0] = extraArmor[1] = 0;
speed[0] = speed[1] = static_cast<int>((1 << pixelShift) * type.topSpeed());
}
bool BuildOrderManager::hasResources(BWAPI::UnitType t, int time)
{
pair<int, Resources> res;
res.first=time;
res.second.minerals=t.mineralPrice();
res.second.gas=t.gasPrice();
bool ret=hasResources(res);
return ret;
}
void UAlbertaBotModule::onSendText(std::string text)
{
if (Config::Modules::UsingBuildOrderDemo)
{
std::stringstream type;
std::stringstream numUnitType;
size_t numUnits = 0;
size_t i=0;
for (i=0; i<text.length(); ++i)
{
if (text[i] == ' ')
{
i++;
break;
}
type << text[i];
}
for (; i<text.length(); ++i)
{
numUnitType << text[i];
}
numUnits = atoi(numUnitType.str().c_str());
BWAPI::UnitType t;
for (const BWAPI::UnitType & tt : BWAPI::UnitTypes::allUnitTypes())
{
if (tt.getName().compare(type.str()) == 0)
{
t = tt;
break;
}
}
BWAPI::Broodwar->printf("Searching for %d of %s", numUnits, t.getName().c_str());
if (t != BWAPI::UnitType())
{
MetaPairVector goal;
goal.push_back(MetaPair(BWAPI::UnitTypes::Protoss_Probe, 8));
goal.push_back(MetaPair(BWAPI::UnitTypes::Protoss_Gateway, 2));
goal.push_back(MetaPair(t, numUnits));
ProductionManager::Instance().setSearchGoal(goal);
}
else
{
BWAPI::Broodwar->printf("Unknown unit type %s", type.str().c_str());
}
}
}
bool BuildingPlacer::canBuildHere(BWAPI::TilePosition position, BWAPI::UnitType type) const
{
if (!BWAPI::Broodwar->canBuildHere(NULL, position, type))
return false;
for(int x = position.x(); x < position.x() + type.tileWidth(); x++)
for(int y = position.y(); y < position.y() + type.tileHeight(); y++)
if (reserveMap[x][y])
return false;
return true;
}
// add a new building to be constructed
void BuildingManager::addBuildingTask(BWAPI::UnitType type, BWAPI::TilePosition desiredLocation, bool isGasSteal)
{
_reservedMinerals += type.mineralPrice();
_reservedGas += type.gasPrice();
Building b(type, desiredLocation);
b.isGasSteal = isGasSteal;
b.status = BuildingStatus::Unassigned;
_buildings.push_back(b);
}
void UnitCommandManager::drawCommandStatus(BWAPI::UnitInterface* unit)
{
BWAPI::UnitType type = unit->getType();
int width = type.dimensionRight();
int height = type.dimensionDown()/6;
int x1 = unit->getPosition().x - width;
int x2 = unit->getPosition().y + width;
int y1 = unit->getPosition().y - height;
int y2 = unit->getPosition().y + height;
}
void BuildOrderManager::buildAdditional(int count, BWAPI::UnitType t, int priority, BWAPI::TilePosition seedPosition)
{
if (t == BWAPI::UnitTypes::None || t == BWAPI::UnitTypes::Unknown) return;
if (seedPosition == BWAPI::TilePositions::None || seedPosition == BWAPI::TilePositions::Unknown)
seedPosition=BWAPI::Broodwar->self()->getStartLocation();
if (items[priority].units[t.whatBuilds().first].find(t)==items[priority].units[t.whatBuilds().first].end())
items[priority].units[t.whatBuilds().first].insert(make_pair(t,UnitItem(t)));
items[priority].units[t.whatBuilds().first][t].addAdditional(count,seedPosition);
nextUpdateFrame=0;
}
bool BuildingPlacer::canBuildHere(BWAPI::TilePosition position, BWAPI::UnitType type) const
{
//returns true if we can build this type of unit here. Takes into account reserved tiles.
if (!BWAPI::Broodwar->canBuildHere(NULL, position, type))
return false;
for(int x = position.x(); x < position.x() + type.tileWidth(); x++)
for(int y = position.y(); y < position.y() + type.tileHeight(); y++)
if (reserveMap[x][y])
return false;
return true;
}
//----------------------------------------------------------------------------------------------
EntityClassType StarCraftTechTree::TireBaseBuilding(BaseType p_tireId) const
{
BWAPI::UnitType baseType;
if (p_tireId == BASETYPE_END)
return ECLASS_END;
baseType = m_player->getRace().getCenter();
return g_Database.EntityMapping.GetByFirst(baseType.getID());
}
bool BuildingPlacer::canBuildHereWithSpace(BWAPI::TilePosition position, BWAPI::UnitType type) const
{
if (!this->canBuildHere(position, type))
return false;
int width=type.tileWidth();
int height=type.tileHeight();
if (type==BWAPI::UnitTypes::Terran_Command_Center ||
type==BWAPI::UnitTypes::Terran_Factory ||
type==BWAPI::UnitTypes::Terran_Starport ||
type==BWAPI::UnitTypes::Terran_Science_Facility)
{
width+=2;
}
int startx = position.x() - buildDistance;
if (startx<0) startx=0;
int starty = position.y() - buildDistance;
if (starty<0) starty=0;
int endx = position.x() + width + buildDistance;
if (endx>BWAPI::Broodwar->mapWidth()) endx=BWAPI::Broodwar->mapWidth();
int endy = position.y() + height + buildDistance;
if (endy>BWAPI::Broodwar->mapHeight()) endy=BWAPI::Broodwar->mapHeight();
for(int x = startx; x < endx; x++)
for(int y = starty; y < endy; y++)
if (!type.isRefinery())
if (!buildable(x, y))
return false;
if (position.x()>3)
{
int startx2=startx-2;
if (startx2<0) startx2=0;
for(int x = startx2; x < startx; x++)
for(int y = starty; y < endy; y++)
{
std::set<BWAPI::Unit*> units = BWAPI::Broodwar->unitsOnTile(x, y);
for(std::set<BWAPI::Unit*>::iterator i = units.begin(); i != units.end(); i++)
{
if (!(*i)->isLifted())
{
BWAPI::UnitType type=(*i)->getType();
if (type==BWAPI::UnitTypes::Terran_Command_Center ||
type==BWAPI::UnitTypes::Terran_Factory ||
type==BWAPI::UnitTypes::Terran_Starport ||
type==BWAPI::UnitTypes::Terran_Science_Facility)
{
return false;
}
}
}
}
}
return true;
}
CancelTrainTest::CancelTrainTest(BWAPI::UnitType unitType1, BWAPI::UnitType unitType2, BWAPI::UnitType unitType3)
: unitType1(unitType1),
unitType2(unitType2),
unitType3(unitType3),
producer(NULL),
startFrame(-1),
nextFrame(-1)
{
fail = false;
running = false;
producerType = unitType1.whatBuilds().first;
BWAssertF(producerType==unitType2.whatBuilds().first,{fail=true;return;});
// add a new building to be constructed
void BuildingManager::addBuildingTask(BWAPI::UnitType type, BWAPI::TilePosition desiredLocation) {
if (debugMode) { BWAPI::Broodwar->printf("Issuing addBuildingTask: %s", type.getName().c_str()); }
totalBuildTasks++;
// reserve the resources for this building
reservedMinerals += type.mineralPrice();
reservedGas += type.gasPrice();
// set it up to receive a worker
buildingData.addBuilding(ConstructionData::Unassigned, Building(type, desiredLocation));
}
bool UnitHelper::unitProducesGround(BWAPI::UnitType type)
{
static std::set<BWAPI::UnitType> unitData;
if(unitData.empty())
{
for each(BWAPI::UnitType type in BWAPI::UnitTypes::allUnitTypes())
{
if(!type.isFlyer() && type.whatBuilds().first.isBuilding())
unitData.insert(type.whatBuilds().first);
}
}
return unitData.count(type) != 0;
}
/// Returns target attack priority.
/// Returned value must be greater than 0
int VultureManagerExt::getAttackPriority(BWAPI::Unit * selectedUnit, BWAPI::Unit * target)
{
BWAPI::UnitType selectedUnitType = selectedUnit->getType();
BWAPI::UnitType targetType = target->getType();
bool canAttackUs = targetType.groundWeapon() != BWAPI::WeaponTypes::None;
int selectedUnitWeaponRange = selectedUnitType.groundWeapon().maxRange(); // 160, Concussive
int targetWeaponRange = targetType.groundWeapon().maxRange();
// Larvas are low priority targets
if (targetType == BWAPI::UnitTypes::Zerg_Larva
|| targetType == BWAPI::UnitTypes::Protoss_Interceptor)
{
return 1;
}
else if (targetType == BWAPI::UnitTypes::Protoss_Pylon)
{
return 3;
}
else if ((targetType.isBuilding()) && !(targetType.canAttack()))
{
return 2;
}
else if (targetType == BWAPI::UnitTypes::Protoss_Photon_Cannon)
{
return 4;
}
// Templars are extremely dangerous to bio units and should be eliminated asap.
else if (targetType == BWAPI::UnitTypes::Protoss_High_Templar
|| targetType == BWAPI::UnitTypes::Terran_Medic)
{
return selectedUnitWeaponRange + 10;
}
// Faster than Marine (without Stimpack)
else if ((targetType.topSpeed() >= selectedUnitType.topSpeed())
|| ((targetType == BWAPI::UnitTypes::Protoss_Zealot)
&& (BWAPI::Broodwar->enemy()->getUpgradeLevel(BWAPI::UpgradeTypes::Leg_Enhancements) > 0)))
{
return selectedUnitWeaponRange; // return 160
}
// Slower than Vulture
else
{
int priority = selectedUnitWeaponRange - targetWeaponRange;
if (priority <= 0)
{
priority = 1;
}
return priority;
}
}
void ProductionManager::drawProductionInformation(int x, int y)
{
if (!Config::Debug::DrawProductionInfo)
{
return;
}
// fill prod with each unit which is under construction
std::vector<BWAPI::Unit> prod;
for (auto & unit : BWAPI::Broodwar->self()->getUnits())
{
UAB_ASSERT(unit != nullptr, "Unit was null");
if (unit->isBeingConstructed())
{
prod.push_back(unit);
}
}
// sort it based on the time it was started
std::sort(prod.begin(), prod.end(), CompareWhenStarted());
BWAPI::Broodwar->drawTextScreen(x-30, y+20, "\x04 TIME");
BWAPI::Broodwar->drawTextScreen(x, y+20, "\x04 UNIT NAME");
size_t reps = prod.size() < 10 ? prod.size() : 10;
y += 30;
int yy = y;
// for each unit in the _queue
for (auto & unit : prod)
{
std::string prefix = "\x07";
yy += 10;
BWAPI::UnitType t = unit->getType();
if (t == BWAPI::UnitTypes::Zerg_Egg)
{
t = unit->getBuildType();
}
BWAPI::Broodwar->drawTextScreen(x, yy, " %s%s", prefix.c_str(), t.getName().c_str());
BWAPI::Broodwar->drawTextScreen(x - 35, yy, "%s%6d", prefix.c_str(), unit->getRemainingBuildTime());
}
_queue.drawQueueInformation(x, yy+10);
}
bool MorphManager::morph(BWAPI::UnitType type)
{
//morph order starts here
//we only accept buildings that are made from other buildings
//and units that are made from other units
//fix: we should check to make sure the type is not an addon
if (type.isBuilding()!=type.whatBuilds().first->isBuilding())
return false;
morphQueues[*type.whatBuilds().first].push_back(type);
plannedCount[type]++;
return true;
}
void BuildOrderManager::build(int count, BWAPI::UnitType t, int priority, BWAPI::TilePosition seedPosition)
{
if (t == BWAPI::UnitTypes::None || t == BWAPI::UnitTypes::Unknown) return;
if (seedPosition == BWAPI::TilePositions::None || seedPosition == BWAPI::TilePositions::Unknown)
seedPosition=BWAPI::Broodwar->self()->getStartLocation();
if (t==UnitTypes::Protoss_Pylon && this->getPlannedCount(t)==0)
{
if (!this->buildManager->getBuildingPlacer()->canBuildHereWithSpace(seedPosition, t, 3))
seedPosition = this->buildManager->getBuildingPlacer()->getBuildLocationNear(seedPosition, t, 3);
}
if (items[priority].units[t.whatBuilds().first].find(t)==items[priority].units[t.whatBuilds().first].end())
items[priority].units[t.whatBuilds().first].insert(make_pair(t,UnitItem(t)));
items[priority].units[t.whatBuilds().first][t].setNonAdditional(count,seedPosition);
nextUpdateFrame=0;
}
bool HLUnitData::finishUnit(BWAPI::UnitType type)
{
bool found = false;
for (auto &item : _unitMap){
if (item.second.type.getID() == type.getID() && !item.second.completed){
item.second.completed = true;
numCompletedUnits[type.getID()]++;
found = true;
break;
}
}
UAB_ASSERT(found,"Couldn't find unit to finish: %s\n",type.getName().c_str());
return found;
}
//returns the BuildOrderManager's planned count of units for this type
int BuildOrderManager::getPlannedCount(BWAPI::UnitType t, int minPriority)
{
//builder unit type
UnitType builder=t.whatBuilds().first;
int c=this->buildManager->getPlannedCount(t);
//sum all the remaining units for every priority level
for(map<int, PriorityLevel>::iterator p=items.begin();p!=items.end();p++)
{
if (p->first<minPriority) continue; //don't consider planned units below min priority
map<BWAPI::UnitType, map<BWAPI::UnitType, UnitItem > >* units=&(p->second.units);
map<BWAPI::UnitType, map<BWAPI::UnitType, UnitItem > >::iterator i=units->find(builder);
if (i!=units->end())
{
map<BWAPI::UnitType, UnitItem >* units2=&(i->second);
map<BWAPI::UnitType, UnitItem >::iterator j=units2->find(t);
if (j!=units2->end())
{
c+=j->second.getRemainingCount(c);
}
}
}
if (t==UnitTypes::Zerg_Hatchery)
c+=this->getPlannedCount(UnitTypes::Zerg_Lair);
if (t==UnitTypes::Zerg_Lair)
c+=this->getPlannedCount(UnitTypes::Zerg_Hive);
return c;
}
// selects a unit of a given type
BWAPI::Unit ProductionManager::selectUnitOfType(BWAPI::UnitType type, BWAPI::Position closestTo)
{
// if we have none of the unit type, return nullptr right away
if (BWAPI::Broodwar->self()->completedUnitCount(type) == 0)
{
return nullptr;
}
BWAPI::Unit unit = nullptr;
// if we are concerned about the position of the unit, that takes priority
if (closestTo != BWAPI::Positions::None)
{
double minDist(1000000);
for (auto & u : BWAPI::Broodwar->self()->getUnits())
{
if (u->getType() == type)
{
double distance = u->getDistance(closestTo);
if (!unit || distance < minDist) {
unit = u;
minDist = distance;
}
}
}
// if it is a building and we are worried about selecting the unit with the least
// amount of training time remaining
}
else if (type.isBuilding())
{
for (auto & u : BWAPI::Broodwar->self()->getUnits())
{
UAB_ASSERT(u != nullptr, "Unit was null");
if (u->getType() == type && u->isCompleted() && !u->isTraining() && !u->isLifted() &&u->isPowered()) {
return u;
}
}
// otherwise just return the first unit we come across
}
else
{
for (auto & u : BWAPI::Broodwar->self()->getUnits())
{
UAB_ASSERT(u != nullptr, "Unit was null");
if (u->getType() == type && u->isCompleted() && u->getHitPoints() > 0 && !u->isLifted() &&u->isPowered())
{
return u;
}
}
}
// return what we've found so far
return nullptr;
}
void UnitClass::drawUnitTilePosition()
{
TilePosition tile = getTilePosition();
BWAPI::UnitType type = getType();
Player player = getPlayer();
BWAPI::Broodwar->drawBox(BWAPI::CoordinateType::Map, tile.x()*32, tile.y()*32, (tile.x()+type.tileWidth())*32, (tile.y()+type.tileHeight())*32, player->getColor());
}
UnitGroup SelectAll( BWAPI::UnitType type )
{
if ( type.isNeutral() && UnitGroupManager::s_UnitGroupManager->neutral != NULL )
{
return UnitGroupManager::s_UnitGroupManager->data[UnitGroupManager::s_UnitGroupManager->neutral][type];
}
return UnitGroupManager::s_UnitGroupManager->data[BWAPI::Broodwar->self()][type];
}
// get the attack priority of a type in relation to a zergling
int MeleeManager::getAttackPriority(BWAPI::Unit attacker, BWAPI::Unit unit)
{
BWAPI::UnitType type = unit->getType();
if (attacker->getType() == BWAPI::UnitTypes::Protoss_Dark_Templar
&& unit->getType() == BWAPI::UnitTypes::Terran_Missile_Turret
&& (BWAPI::Broodwar->self()->deadUnitCount(BWAPI::UnitTypes::Protoss_Dark_Templar) == 0))
{
return 13;
}
if (attacker->getType() == BWAPI::UnitTypes::Protoss_Dark_Templar && unit->getType().isWorker())
{
return 12;
}
// highest priority is something that can attack us or aid in combat
if (type == BWAPI::UnitTypes::Terran_Bunker)
{
return 11;
}
else if (type == BWAPI::UnitTypes::Terran_Medic ||
(type.groundWeapon() != BWAPI::WeaponTypes::None && !type.isWorker()) ||
type == BWAPI::UnitTypes::Terran_Bunker ||
type == BWAPI::UnitTypes::Protoss_High_Templar ||
type == BWAPI::UnitTypes::Protoss_Reaver ||
(type.isWorker() && unitNearChokepoint(unit)))
{
return 10;
}
// next priority is worker
else if (type.isWorker())
{
return 9;
}
// next is special buildings
else if (type == BWAPI::UnitTypes::Zerg_Spawning_Pool)
{
return 5;
}
// next is special buildings
else if (type == BWAPI::UnitTypes::Protoss_Pylon)
{
return 5;
}
// next is buildings that cost gas
else if (type.gasPrice() > 0)
{
return 4;
}
else if (type.mineralPrice() > 0)
{
return 3;
}
// then everything else
else
{
return 1;
}
}
ActionID ActionTypeData::GetActionID(const BWAPI::UnitType & type)
{
const RaceID raceID = GetRaceID(type.getRace());
BOSS_ASSERT(raceID < Races::NUM_RACES, "Race ID invalid: %d %s", (int)raceID, type.getName().c_str());
for (ActionID a(0); a < ActionTypeData::GetNumActionTypes(raceID); ++a)
{
const ActionTypeData & data = GetActionTypeData(raceID, a);
if (data.isUnit() && data.getUnitType() == type)
{
return data.getActionID();
}
}
BOSS_ASSERT(false, "Could not find UnitType: %d %s", type.getID(), type.getName().c_str());
return 0;
}
TrainTest::TrainTest(BWAPI::UnitType unitType) : unitType(unitType),
producer(NULL),
startFrame(-1),
nextFrame(-1)
{
fail = false;
running = false;
producerType = unitType.whatBuilds().first;
BWAssertF(producerType!=UnitTypes::None,{fail=true;return;});