//BW Attack priority tree:

#define MemZero(x) memset(x, 0, sizeof(x))

// Priority enum
namespace Priority
{
 enum Enum
 {
   Highest,
   Higher,
   High,
   Low,
   Lower,
   Lowest,
   MAX
 };
};

// Some globals, probably "static" in the Unit class
int g_AtkPriorityCount[Priority::MAX]
Unit *g_AtkPriorityList[Priority::MAX][16];

int g_MinWpnRange;
int g_MinAcqRange;

// functions
int Unit::getAttackPriorityFor(Unit *pTarget);
void Unit::setAttackPriority(int priority);
Unit *Unit::getNewAttackTarget(); // <---- START HERE
Unit *Unit::getRandomAttackTarget();  // <---- START HERE for alternative function (both are called under different circumstances)
Unit *Unit::getTargetFromPriorityList(int priority);
Unit *getRandomTargetFromPriorityList(int priority);
bool Unit::isTargetActive(Unit *pTarget);

bool __fastcall getStandardAttackTargetCallback(Unit *pTarget, Unit *pThis);

// Functions not listed are intended to be obvious, and I converted many to use BWAPI-style members
// let me know if anything needs clarification


// Returns 0 (highest priority) to 5 (lowest priority)
int Unit::getAttackPriorityFor(Unit *pTarget)
{
 Unit *targ = pTarget;
 
 // get target replacement or do instant returns if any
 switch ( pTarget->getType() )
 {
 case UnitTypes::Enum::Terran_Bunker:
   if ( !pTarget->getLoadedUnits().empty() )
     targ = pTarget->getLoadedUnits().front();
   break;
 case UnitTypes::Enum::Zerg_Larva:
 case UnitTypes::Enum::Zerg_Egg:
 case UnitTypes::Enum::Zerg_Cocoon:
 case UnitTypes::Enum::Zerg_Lurker_Egg:
   return Priority::Lowest;
 default:
   break;
 }
 
 int iPriority;
 UnitType targType = targ->getType();
 
 if ( targType.isWorker() )
   iPriority = Priority::High;
 else if ( targ->canAttack(this, true) )
   iPriority = Priority::Highest;
 else if ( targ->canAttack() )
   iPriority = Priority::High;
 else if ( targType.isBuilding() )
   iPriority = Priority::Low;
 else
   iPriority = Priority::Lower;

 // decrease the priority if the unit is incomplete or if the target is a loaded bunker
 if ( !targ->isCompleted() || targ != pTarget )
   ++iPriority;
 
 // Unknown, possibly a flag telling that another unit just recently attacked it?
 if ( iPriority == Priority::Highest && (targ->statusFlags & UNKNOWN1) )
   iPriority = Priority::Higher;
   
 return iPriority;
}

// Sets the attack priority
void Unit::setAttackPriority(int priority)
{
 int priorityIndex = g_AtkPriorityCount[priority];
 if ( priorityIndex < 16 )
 {
   g_AtkPriorityList[priority][priorityIndex] = this;
   g_AtkPriorityCount[priority]++;
 }
}

// Obtain the new attack target (base function)
Unit *Unit::getNewAttackTarget()
{
 // Reset global data
 MemZero(g_AtkPriorityCount);
 
 // obtain target acquisition range
 int targAcquisition = this->getTargetAcquisitionRange();
 if ( this->isInBunker() )
   targAcquisition += 2;
 else if ( this->isAI() && this->getType().sightRange() > targAcquisition )
   targAcquisition = this->getType().sightRange();
   
 // Set some globals
 g_MinAcqRange = targAcquisition*32;
 g_MinAtkRange = this->getMinAttackRange();
 
 // Iterate all units in a box and call whatever callback for each one
 int range = (targAcquisition + 2)*32;
 Position p( this->getPosition() );
 Broodwar->iterateUnitsInRectangle_1(  p.x - range,
                                       p.y - range,
                                       p.x + range,
                                       p.y + range,
                                       getStandardAttackTargetCallback, this);

 // Get the highest priority value with at least one target entry
 int priority = Priority::Highest;
 while ( g_AtkPriorityCount[priority] == 0 )
 {
   ++priority;
   if ( priority >= Priority::MAX )
     return nullptr;
 }
 
 return this->getTargetFromPriorityList(priority);
}

// ALTERNATIVE Obtain the new attack target
Unit *Unit::getRandomAttackTarget()
{
 // Reset global data
 MemZero(g_AtkPriorityCount);
 
 // Get target acquisition range
 int targAcquisition = this->getTargetAcquisitionRange();
 if ( this->isInBunker() )
   targAcquisition += 2;

 // Set some globals
 g_MinAcqRange = targAcquisition*32;
 g_MinAtkRange = 0;
 
 // Iterate all units in a box and call whatever callback for each one
 int range = (targAcquisition + 2)*32;
 Position p( this->getPosition() );
 Broodwar->iterateUnitsInRectangle_1(  p.x - range,
                                       p.y - range,
                                       p.x + range,
                                       p.y + range,
                                       getStandardAttackTargetCallback, this);
 
 // Get the highest priority value with at least one target entry
 int priority = Priority::Highest;
 while ( g_AtkPriorityCount[priority] == 0 )
 {
   ++priority;
   if ( priority >= Priority::MAX )
     return nullptr;
 }
 
 return getRandomTargetFromPriorityList(priority);
}

Unit *Unit::getTargetFromPriorityList(int priority)
{
 // Localize globals
 Unit **pList = g_AtkPriorityList[priority];
 int listCount = g_AtkPriorityCount[priority];
 
 // If there is only one element, there is nothing to compare to
 if ( listCount == 1 )
   return pList[0];
 
 // The "best" index
 int bestIndex = 0;
 
 // Special zerg scourge AI
 if ( this->isAI() && this->getType() == UnitTypes::Zerg_Scourge )
 {
   // Get the highest HP+Shields unit
   int bestHP = pList[0]->getHitPoints() + pList[0]->getShields();
   for ( int i = 1; i < listCount; ++i )
   {
     int newHP = pList[i]->getHitPoints() + pList[i]->getShields();
     if ( newHP > bestHP )
     {
       bestHP = newHP;
       bestIndex = i;
     }
   }
 }
 else  // anything else
 {
   // Get the closest unit
   int bestDist = this->getPosition().getDistance( pList[0]->getPosition() );
   for ( int i = 1; i < listCount; ++i )
   {
     int newDist = this->getPosition().getDistance( pList[0]->getPosition() );
     if ( newDist < bestDist )
     {
       bestDist = newDist;
       bestIndex = i;
     }
   }
 }
 return pList[bestIndex];
}

Unit *getRandomTargetFromPriorityList(int priority)
{
 // Localize globals
 Unit **pList = g_AtkPriorityList[priority];
 int listCount = g_AtkPriorityCount[priority];
 
 // If there is only one element, then we don't need any more calculation
 if ( listCount == 1 )
   return pList[0];
   
 return pList[ rand() % listCount ]; //pList[ Broodwar->getRand(RANDDBG::TARGET) % listCount ];
}

bool Unit::isTargetActive(Unit *pTarget)
{
 if (  this->getPlayer().getType() != PlayerTypes::Computer ||
       this->isInAir() ||
       this->isTargetInWeaponRange(pTarget) )
   return false;

 return (pTarget->statusFlags & UNKNOWN1) != 0;
}

bool __fastcall getStandardAttackTargetCallback(Unit *pTarget, Unit *pThis)
{
 if ( pTarget == pThis ) // exclude if both are the same
   return false;

 if ( !pTarget->isVisibleTo( pThis->getPlayer() ) )  // exclude if invisible
   return false;
 
 if ( !pThis->canAttack(pTarget, true) ) // exclude if not attackable
   return false;
 
 if ( !pTarget->isEnemyOf( pThis->getPlayer() ) )  // exclude if not an enemy
   return false;
   
 if ( g_MinWpnRange > 0 && pThis->isTargetInRange(g_MinWpnRange, pTarget) )  // exclude if within global min weapon range
   return false;
   
 if ( !pThis->isTargetInRange(g_MinAcqRange, pTarget) )  // exclude if not in global acquisition range
   return false;
 
 // Get the subunit, if none exists then just use pThis
 Unit *unit = pThis->getSubunit();
 if ( unit == nullptr )
   unit = pThis;
   
 // Not sure
 if ( !(unit->statusFlags & IsAUnit_Unknown) )
 {
   // Discard units outside of the attack angle
   if ( !unit->isTargetInAttackAngle(pTarget->getPosition(), unit->getType().groundWeapon()) )
     return false;
   unit = pThis;
 }

 // Set the global attack priority if target was not attacked??
 if ( !unit->isTargetActive(pTarget) )
   pTarget->setAttackPriority( unit->getAttackPriorityFor(pTarget) );

 return false;
}