order AIForceField (int player, unit aiUnit, unitgroup scanGroup, fixed scanRange, marker m) {
    order ord;
    order enemyOrd;
    unitgroup enemyGroup;
    unitgroup friendlyGroup;
    unitfilter filter;
    unit enemyUnit;
    unit friendlyUnit;
    unit possibleTargetUnit;
    unit bestTargetUnit = null;
    point myPos = UnitGetPosition(aiUnit);
    fixed myFacing = UnitGetFacing(aiUnit);
    point forceFieldTarget;
    int forceFieldMaxRadius = 5;
    int priorityFound = 10;
    bool emergencyCast = false;

    // Loop control
    int enemyCount = 0;
    int friendlyCount = 0;

    // Enemy test values
    int enemyVit = 0;
    point enemyPos;
    fixed enemyFacing = 0;

    // Friendly test values
    int friendlyVit = 0;
    fixed friendlyFacing = 0;

    // Do not proceed if the order is invalid for some reason
    ord = AICreateOrder(player, c_AB_ForceField, 0);
    if (!UnitOrderIsValid(aiUnit, ord)) {
        return ord;
    }

    // Is there a threat in the area
    enemyGroup = UnitGroupFilterThreat(scanGroup, aiUnit, null, 0);
    enemyCount = UnitGroupCount(enemyGroup, c_unitCountAlive);
    if (enemyCount <= 0) {
        return ord;
    }

    // Assess life and energy
    // A good energy buffer is 50 energy left over.  100 energy is needed to cast in any battle
    // If our life is less than 50%, use the energy buffer.
    if (UnitGetPropertyInt(aiUnit, c_unitPropEnergy, c_unitPropCurrent) <= 100) {
        if (UnitGetPropertyInt(aiUnit, c_unitPropLifePercent, c_unitPropCurrent) <= 50) {
            emergencyCast = true;
        }
    }

    // Setup a friendly filter
    filter = UnitFilter(0,0,0,0);
    UnitFilterSetState(filter, c_targetFilterSelf,                      c_unitFilterRequired);
    UnitFilterSetState(filter, c_targetFilterAlly,                      c_unitFilterRequired);

    UnitFilterSetState(filter, c_targetFilterUncommandable,             c_unitFilterExcluded);
    UnitFilterSetState(filter, c_targetFilterWorker,                    c_unitFilterExcluded);
    UnitFilterSetState(filter, c_targetFilterUnderConstruction,         c_unitFilterExcluded);
    UnitFilterSetState(filter, c_targetFilterStructure,                 c_unitFilterExcluded);

    // *** Scan the area for the following, set priority unit when found ***
    // Priority 1: A friendly unit close to death, who has a melee enemy close by
    // Priority 2: An enemy unit close to death, who has a friendly unit close by
    // Priority 3: A friendly ranged unit who has a melee enemy close by
    // Priority 4: Enemy near me
    // Priority 5: Any Enemy close to death, facing away from me
    //
    // Scan enemies
    while (enemyCount > 0) {
        enemyUnit = UnitGroupUnit(enemyGroup, enemyCount);
        enemyCount = enemyCount - 1;

        // Get enemy data
        enemyVit = UnitGetPropertyInt(enemyUnit, c_unitPropLifePercent, c_unitPropCurrent);
        enemyFacing = UnitGetFacing(enemyUnit);
        enemyPos = UnitGetPosition(enemyUnit);
        enemyOrd = UnitOrder(enemyUnit, 0);
    
        friendlyGroup = UnitGroup(null, c_playerAny, RegionCircle(enemyPos, forceFieldMaxRadius), filter, 0);
        friendlyCount = UnitGroupCount(friendlyGroup, c_unitCountAll);

        // Scan friends near enemyUnit
        while (friendlyCount > 0) {
            friendlyUnit = UnitGroupUnit(friendlyGroup, friendlyCount);
            friendlyCount = friendlyCount - 1;
            // Get friendly data
            friendlyVit = UnitGetPropertyInt(friendlyUnit, c_unitPropLifePercent, c_unitPropCurrent);

            if (UnitMarkerCount(friendlyUnit, m) > 0) {
                continue;
            }
            // Test Priority Target 4 first, if we are in a state of saving ourself
            if (emergencyCast) {
                if (PointsInRange(myPos, enemyPos, forceFieldMaxRadius)) {
                    priorityFound = 1;
                    bestTargetUnit = friendlyUnit;
                    break;
                }
            }
            // Test Priority Target 1
            else if (friendlyVit < 25) {
                priorityFound = 1;
                bestTargetUnit = friendlyUnit;
                break;
            }
            // Test Priority Target 2
            else if (priorityFound > 2 && enemyVit < 25) { // && Test for non-ranged only
                priorityFound = 2;
                possibleTargetUnit = enemyUnit;
            }
            // Test Priority Target 3
            else if (false) { //priorityFound > 3
                // Not really able to test for this yet
                // Need to determine if the unit in question has a ranged weapon
            }
            // Test Priority Target 4
            else if (priorityFound > 4 && PointsInRange(myPos, enemyPos, forceFieldMaxRadius)) {
                priorityFound = 4;
                possibleTargetUnit = enemyUnit;
            }
            // Test Priority Target 5
            else if (priorityFound > 5 && enemyVit < 25 && enemyFacing - myFacing < 90) {
                priorityFound = 5;
                possibleTargetUnit = enemyUnit;
            }
            // More tests here
        }

        if (bestTargetUnit) {
            break;
        }
    }

    if (bestTargetUnit != null) {
        if (possibleTargetUnit) {
            bestTargetUnit = possibleTargetUnit;
        }
    }

    // Do some other things here, like if we are targetting a retreating enemy (priority 5)
    // adjust the target offset a bit ahead of the unit based on facing.
    // We would want this for priority 3 as well when that is valid.

    forceFieldTarget = UnitGetPosition(bestTargetUnit);

    if (!forceFieldTarget) {
        return null;
    }
    OrderSetTargetPoint(ord, forceFieldTarget);

    return ord;
}

//--------------------------------------------------------------------------------------------------​
//  AI Get Full Make Time
//--------------------------------------------------------------------------------------------------​
int AIGetFullMakeTime (int player, string objType) {

    // override any special cases here

    return AIDefaultGetFullMakeTime(player, objType);
}