//
// Check
//
// Check execution position
//
Bool OffMapObj::Check(const Vector &pos)
{
// Check traction
if (OffMapType()->GetCheckTraction())
{
// Convert to cells
U32 x = WorldCtrl::MetresToCellX(pos.x);
U32 z = WorldCtrl::MetresToCellZ(pos.z);
if (!PathSearch::CanMoveToCell(UnitType()->GetTractionIndex(Claim::LAYER_LOWER), x, z))
{
return (FALSE);
}
}
// Must be on a team that can see the location
if (GetTeam())
{
if (GetTeam()->IsAI())
{
return (TRUE);
}
if (Sight::Visible(WorldCtrl::MetresToCellX(pos.x), WorldCtrl::MetresToCellZ(pos.z), GetTeam()))
{
// No disruptors in the area
return (UnitObjType::FindDisruptor(GetTeam(), pos) == NULL);
}
}
return (FALSE);
}
TrainingParameterSchedule<T>::TrainingParameterSchedule(const Dictionary& dictionary)
{
m_unit = UnitType(dictionary[unitKey].Value<size_t>());
m_epochSize = dictionary[epochSizeKey].Value<size_t>();
Dictionary schedule = dictionary[scheduleKey].Value<Dictionary>();
for (const auto& kv : schedule)
{
m_schedule[std::stoll(kv.first)] = kv.second.Value<T>();
}
}
//--------------------------------------------- GET BOTTOM -------------------------------------------------
int UnitImpl::getBottom() const
{
return self->positionY + UnitType(self->type).dimensionDown();
}
//--------------------------------------------- GET TOP ----------------------------------------------------
int UnitImpl::getTop() const
{
return self->positionY - UnitType(self->type).dimensionUp();
}
//--------------------------------------------- GET RIGHT --------------------------------------------------
int UnitImpl::getRight() const
{
return self->positionX + UnitType(self->type).dimensionRight();
}
//--------------------------------------------- GET LEFT ---------------------------------------------------
int UnitImpl::getLeft() const
{
return self->positionX - UnitType(self->type).dimensionLeft();
}
//--------------------------------------------- GET TYPE ---------------------------------------------------
UnitType UnitImpl::getType() const
{
return UnitType(self->type);
}
//--------------------------------------------- GET BUILD TYPE ---------------------------------------------
UnitType UnitImpl::getBuildType() const
{
return UnitType(self->buildType);
}
void UnitImpl::updateInternalData()
{
BW::CUnit *o = getOriginalRawData;
if ( !o )
return;
int selfPlayerID = BroodwarImpl.server.getPlayerID(Broodwar->self());
self->replayID = BWAPI::BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation) ? BW::UnitTarget(o).getTarget() : 0;
if (isAlive)
{
_getPlayer = BroodwarImpl._getPlayer(getOriginalRawData->playerID); //_getPlayer
//------------------------------------------------------------------------------------------------------
//isVisible
for ( int i = 0; i < 9; ++i )
{
if ( i == selfPlayerID )
continue;
PlayerImpl* player = static_cast<PlayerImpl*>(Broodwar->getPlayer(i));
if ( !o->sprite || !player )
self->isVisible[i] = false;
else if (!BroodwarImpl.isReplay() && !BWAPI::BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation))
self->isVisible[i] = false;
else if ( _getPlayer == player )
self->isVisible[i] = true;
else if ( player->isNeutral() )
self->isVisible[i] = o->sprite->visibilityFlags > 0;
else
self->isVisible[i] = (o->sprite->visibilityFlags & (1 << player->getIndex())) != 0;
}
if (selfPlayerID >= 0)
{
if ( !o->sprite )
{
self->isVisible[selfPlayerID] = false;
self->isDetected = false;
}
else if (_getPlayer == BWAPI::BroodwarImpl.self())
{
self->isVisible[selfPlayerID] = true;
self->isDetected = true;
}
else if (o->unitType == UnitTypes::Spell_Scanner_Sweep)
{
self->isVisible[selfPlayerID] = isScannerVisible(o->position);
self->isDetected = true;
}
else
{
self->isVisible[selfPlayerID] = (o->sprite->visibilityFlags & (1 << BroodwarImpl.BWAPIPlayer->getIndex())) != 0;
if (o->statusFlag(BW::StatusFlags::RequiresDetection))
{
self->isVisible[selfPlayerID] &= ((o->visibilityStatus == -1) ||
((o->visibilityStatus & (1 << BroodwarImpl.BWAPIPlayer->getIndex())) != 0) ||
o->movementFlag(BW::MovementFlags::Moving | BW::MovementFlags::Accelerating) ||
o->orderID == Orders::Move ||
o->groundWeaponCooldown > 0 ||
o->airWeaponCooldown > 0 ||
!o->statusFlag(BW::StatusFlags::Burrowed) );
}
bool canDetect = !o->statusFlag(BW::StatusFlags::RequiresDetection) ||
o->visibilityStatus == -1 ||
((o->visibilityStatus & (1 << BroodwarImpl.BWAPIPlayer->getIndex())) != 0);
self->isDetected = self->isVisible[selfPlayerID] & canDetect;
}
}
else
{
self->isDetected = false;
for(unsigned int i = 0; i < 9; ++i)
{
if (self->isVisible[i])
{
self->isDetected = true;
break;
}
}
}
//------------------------------------------------------------------------------------------------------
//_getType
_getType = UnitType(o->unitType);
if ( _getType.isMineralField() )
_getType = UnitTypes::Resource_Mineral_Field;
getBuildQueueSlot = o->buildQueueSlot; //getBuildQueueSlot
for ( unsigned int i = 0; i < 5; ++i )
getBuildQueue[i] = BWAPI::UnitType(o->buildQueue[i]); //getBuildQueue
if (_getType.isBuilding())
{
if (o->orderID == Orders::ZergBirth ||
o->orderID == Orders::ZergBuildingMorph ||
o->orderID == Orders::ZergUnitMorph ||
o->orderID == Orders::Enum::IncompleteMorphing )
{
//if we have a morphing building, set unit type to the build type (what it is morphing to)
if ( getBuildQueue[(getBuildQueueSlot % 5)] != UnitTypes::None )
_getType = getBuildQueue[(getBuildQueueSlot % 5)];
}
}
//------------------------------------------------------------------------------------------------------
//_getTransport
_getTransport = nullptr;
if (_getType == UnitTypes::Protoss_Interceptor ||
_getType == UnitTypes::Protoss_Scarab ||
_getType == UnitTypes::Terran_Vulture_Spider_Mine)
{
if (o->fighter.inHanger == false ||
o->statusFlag(BW::StatusFlags::InTransport | BW::StatusFlags::InBuilding) )
_getTransport = UnitImpl::BWUnitToBWAPIUnit(o->fighter.parent);
}
else if (o->statusFlag(BW::StatusFlags::InTransport | BW::StatusFlags::InBuilding) )
_getTransport = UnitImpl::BWUnitToBWAPIUnit(o->connectedUnit);
//------------------------------------------------------------------------------------------------------
//_getPosition
_getPosition = BWAPI::Position(_getTransport ? static_cast<UnitImpl*>(_getTransport)->getOriginalRawData->position : o->position);
_getHitPoints = (int)std::ceil(o->hitPoints / 256.0); //_getHitPoints
//------------------------------------------------------------------------------------------------------
//_getResources
_getResources = 0;
if ( _getType.isResourceContainer() )
_getResources = o->resource.resourceCount;
hasEmptyBuildQueue = getBuildQueueSlot < 5 ? (getBuildQueue[getBuildQueueSlot] == UnitTypes::None) : false; //hasEmptyBuildQueue
_isCompleted = o->statusFlag(BW::StatusFlags::Completed); //_isCompleted
}
else // not alive
{
//------------------------------------------------------------------------------------------------------
//isVisible
MemZero(self->isVisible);
self->isDetected = false;
_getPlayer = nullptr; //_getPlayer
_getType = UnitTypes::Unknown; //_getType
_getTransport = nullptr; //_getTransport
_getPosition = Positions::Unknown; //_getPosition
_getHitPoints = 0; //_getHitPoints
_getResources = 0; //_getResources
getBuildQueueSlot = 0; //getBuildQueueSlot
for ( unsigned int i = 0; i < 5; ++i )
getBuildQueue[i] = UnitTypes::None; //getBuildQueue
hasEmptyBuildQueue = true; //hasEmptyBuildQueue
_isCompleted = false; //_isCompleted
}
}
NS_IMETHODIMP
DOMSVGLength::GetUnitType(uint16_t* aUnit)
{
*aUnit = UnitType();
return NS_OK;
}
