Mining_script_V2.4 D Plagioclase

//    Mining_script_V2.4 D Plagio
//
//  from botengine
//
//  This script mines ore from asteroids.
//  before running this script, make sure to prepare as follows:
//  +enter bookmark for mining site and bookmark for station in the configuration section below.
//  +in the Overview create a preset which includes asteroids and rats and enter the name of that preset in the configuration section below at 'OverviewPreset'. The bot will make sure this preset is loaded when it needs to use the overview.
//  +set Overview to sort by distance with the nearest entry at the top.
//  +in the Inventory select the 'List' view.
//  +set the UI language to english.
//  +use a ship with an ore hold.
//  +put some light drones into your ships' drone bay. The bot will make use of them to attack rats when HP are too low (configurable) or it gets jammed.
//  +enable the info panel 'System info'. The bot will use the button in there to access bookmarks and a    steroid belts.
//  +arrange windows to not occlude modules or info panels.
//  +in the ship UI, disable "Display Passive Modules" and disable "Display Empty Slots" and enable "Display Module Tooltips". The bot uses the module tooltips to automatically identify the properties of the modules.
//
//  for optional features (such as warp to safe on hostile in local) see the configuration section below.

//    activate shield booster taken from Terpla (TPMiningScript-2018-06-21v2)
//    cycle in the course of asteroid berries from beginners-ore-asteroid

//    other (ugly) improvements are :
//        using Micro Warp Drive/Afterburner
//        using Mining Crystal (optional)
//        adding option to exclude Ore Type (without change overview)
//        send drone in bay immediately after fight


using BotSharp.ToScript.Extension;
using MemoryStruct = Sanderling.Interface.MemoryStruct;
using Parse = Sanderling.Parse;

//  begin of configuration section ->

//  The bot uses the bookmarks from the menu which is opened from the button in the 'System info' panel.

//  Should the bot use bookmarks for mining site?
bool ShouldUseMiningBookmarks = true;

//  Bookmarks of places to mine. Add additional bookmarks separated by comma.
string[] SetMiningSiteBookmark = new[] {
    "Mining",
    };

string[] BaseOre = new[] {
    "Mercoxit", "Bistot", "Arkonor",
    "Crokite", "Spodumain", "Ochre",
    "Gneiss", "Hemorphite",
    //"Jaspet", "Kernite", "Omber",
    //"Pyroxeres",
    "Plagioclase",

    };

//   List of excluded base ore
string[] ExcludedBaseOre = new[] {
    "Ice","Scordite", "Veldspar","Hedbergite",
    "Omber","Pyroxeres","Kernite",
    };

string[] ModifierOrePreference = new[] {
    //"Concentrated Veldspar", "Dense Veldspar", "Stable Veldspar",
    //"Condensed Scordite", "Massive Scordite", "Glossy Scordite",
    //"Solid Pyroxeres", "Viscous Pyroxeres", "Opulent Pyroxeres",
    "Azure Plagioclase", "Rich Plagioclase", "Sparkling Plagioclase",
    //"Silvery Omber", "Golden Omber", "Platinoid Omber",
    //"Luminous Kernite", "Fiery Kernite", "Resplendant Kernite",
    //"Pure Jaspet", "Pristine Jaspet", "Immaculate Jaspet",
    //"Vivid Hemorphite", "Radiant Hemorphite", "Scintillating Hemorphite",
    "Vitric Hedbergite", "Glazed Hedbergite", "Lustrous Hedbergite",
    "Iridescent Gneiss", "Prismatic Gneiss", "Brilliant Gneiss",
    "Onyx Ochre", "Obsidian Ochre", "Jet Ochre",
    "Bright Spodumain", "Gleaming Spodumain", "Dazzling Spodumain",
    "Sharp Crokite", "Crystalline Crokite", "Pellucid Crokite",
    "Crimson Arkonor", "Prime Arkonor", "Flawless Arkonor",
    "Triclinic Bistot", "Monoclinic Bistot", "Cubic Bistot",
    "Magma Mercoxit", "Vitreous Mercoxit",
    };

//  Bookmark of location where ore should be unloaded.
string UnloadBookmark = "Depot";

//  Name of the container to unload to as shown in inventory.
string UnloadDestContainerName = "Item Hangar";

//  when this is set to true, the bot will try to unload when undocked.
bool UnloadInSpace = false;

//   when this is set to true, the bot will try to use mining crystal
bool UseMiningCrystal = false;

//   when this is set to true, the bot will try to use Afterburner or MicroWarp
bool UseAfterburner = false;


//  Bookmark of place to retreat to to prevent ship loss.
string RetreatBookmark = UnloadBookmark;

//  The bot loads this preset to the active tab.
string OverviewPreset = "AstroRats";

// activate shield hardener
var ActivateHardener = false;

//  bot will start fighting (and stop mining) when hitpoints are lower.
var DefenseEnterHitpointThresholdPercent = 85;
var DefenseExitHitpointThresholdPercent = 90;
var EmergencyWarpOutHitpointPercent = 30;

var FightAllRats = true;    //  when this is set to true, the bot will attack rats independent of shield hp.

var EnterOffloadOreHoldFillPercent = 95;    //  percentage of ore hold fill level at which to enter the offload process.

var RetreatOnNeutralOrHostileInLocal = false;   // warp to RetreatBookmark when a neutral or hostile is visible in local.

bool returnDronesToBayOnRetreat = true; // when set to true, bot will attempt to dock back the drones before retreating

//  <- end of configuration section

// ################################### Script  START ##########################################

Queue<string> visitedLocations = new Queue<string>();

Func<object> BotStopActivity = () => null;

Func<object> NextActivity = MainStep;

for(;;)
{
    MemoryUpdate();

    Host.Log(
        "ore hold fill: " + OreHoldFillPercent + "%" +
        ", mining range: " + MiningRange +
        ", mining modules (inactive): " + SetModuleMiner?.Length + "(" + SetModuleMinerInactive?.Length + ")" +
        ", shield.hp: " + ShieldHpPercent + "%" +
        ", retreat: " + RetreatReason +
        ", JLA: " + JammedLastAge +
        ", Rats: " + ListRatOverviewEntry?.Length +
        ", Asteroids: " + ListAsteroidOverviewEntry?.Length +
        ", Wrecks: " + ListWreckOverviewEntry?.Length +
        ", offload count: " + OffloadCount +
        ", Drones (Bay): " +    DronesInSpaceCount + "(" + DronesInBayCount + ")" +
        ", nextAct: " + NextActivity?.Method?.Name);

    CloseModalUIElement();

    if(0 < RetreatReason?.Length && !(Measurement?.IsDocked ?? false))
    {
        if (returnDronesToBayOnRetreat) {
            DroneEnsureInBay();
            InitiateDockToOrWarpToBookmark(RetreatBookmark);
        }

        if (!returnDronesToBayOnRetreat || (returnDronesToBayOnRetreat && 0 == DronesInSpaceCount)) {
            InitiateDockToOrWarpToBookmark(RetreatBookmark);
        }
        continue;
    }

    NextActivity = NextActivity?.Invoke() as Func<object>;

    if(BotStopActivity == NextActivity)
    {
        Host.Log("BotStop, no Next Activity?");
        break;
    }

    if(null == NextActivity)
    {
        NextActivity = MainStep;
    }

    Host.Delay(1111);
}

//  seconds since ship was jammed.
long? JammedLastAge => Jammed ? 0 : (Host.GetTimeContinuousMilli() - JammedLastTime) / 1000;

int?     ShieldHpPercent => ShipUi?.HitpointsAndEnergy?.Shield / 10;

int? CapacitorPercent => ShipUi?.HitpointsAndEnergy?.Capacitor / 10;

bool    DefenseExit =>
    (Measurement?.IsDocked ?? false) ||
    !(0 < ListRatOverviewEntry?.Length) ||
    (DefenseExitHitpointThresholdPercent < ShieldHpPercent && !(JammedLastAge < 40) &&
    !(FightAllRats && 0 < ListRatOverviewEntry?.Length));

bool    DefenseEnter =>
    !DefenseExit    ||
    !(DefenseEnterHitpointThresholdPercent < ShieldHpPercent) || JammedLastAge < 10 || ListRatOverviewEntry?.Length < 0;

bool OreHoldFilledForOffload => Math.Max(0, Math.Min(100, EnterOffloadOreHoldFillPercent)) <= OreHoldFillPercent;

Int64?  JammedLastTime = null;
string RetreatReasonTemporary = null;
string RetreatReasonPermanent = null;
string RetreatReason => RetreatReasonPermanent ?? RetreatReasonTemporary;
int? LastCheckOreHoldFillPercent = null;

int OffloadCount = 0;

int RandomInt() => new Random((int)Host.GetTimeContinuousMilli()).Next();

T RandomElement<T>(IEnumerable<T> sequence)
{
    var array = (sequence as T[]) ?? sequence?.ToArray();

    if (!(0 < array?.Length))
        return default(T);

    return array[RandomInt() % array.Length];
}

Func<object>    MainStep()
{
    if(Measurement?.IsDocked ?? false)
    {
        InInventoryUnloadItems();

        if (0 < RetreatReasonPermanent?.Length)
            return BotStopActivity;

        if (0 < RetreatReason?.Length)
            return MainStep;

        Undock();
    }

    ToggleShieldBooster(ShieldHpPercent <90);

    if(DefenseEnter)
    {
        Host.Log("enter defense.");
        return DefenseStep;
    }

    EnsureOverviewTypeSelectionLoaded();

    EnsureWindowInventoryOpenOreHold();

    if(ReadyForManeuver)
    {

        if(OreHoldFilledForOffload){
            DroneEnsureInBay();
        }

        if(OreHoldFilledForOffload && 0 == DronesInSpaceCount){
            if(ReadyForManeuver)
                Host.Log("InitiateDockToOrWarpToBookmark(UnloadBookmark), Ore-Hold Full");
                InitiateDockToOrWarpToBookmark(UnloadBookmark);

            if (UnloadInSpace)
            {
                Host.Delay(4000);
                InInventoryUnloadItems();
            }

            return MainStep;
        }

        if(!(0 < ListAsteroidOverviewEntry?.Length))
            if(ShouldUseMiningBookmarks){
                Host.Log("InitiateWarpToRandomMiningBookmark()");
                InitiateWarpToRandomMiningBookmark();
            }else{
                Host.Log("InitiateWarpToMiningSite()");
                InitiateWarpToMiningSite();
            }
            //InitiateWarpToRandomMiningSite();
            //InitiateWarpToMiningSite();
    }

    ModuleMeasureAllTooltip();

    return InBeltMineStep;
}

void CloseModalUIElement()
{
    var ButtonClose =
        ModalUIElement?.ButtonText?.FirstOrDefault(button => (button?.Text).RegexMatchSuccessIgnoreCase("close|no|ok"));

    Sanderling.MouseClickLeft(ButtonClose);
}

void DroneLaunch()
{
    var ManeuverType = Measurement?.ShipUi?.Indication?.ManeuverType;
    if(!(ShipManeuverTypeEnum.Warp == ManeuverType  || ShipManeuverTypeEnum.Jump == ManeuverType)){
        if (!(3 < DronesInSpaceCount)){
            Host.Log("launch drones.");
            Sanderling.MouseClickRight(DronesInBayListEntry);
            Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("launch", RegexOptions.IgnoreCase));
        }
    }
}

void DroneEnsureInBay()
{
    if(0 == DronesInSpaceCount)
        return;

    DroneReturnToBay();

    Host.Delay(3000);
}

void DroneReturnToBay()
{
    Host.Log("return drones to bay.");
    Sanderling.MouseClickRight(DronesInSpaceListEntry);
    Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("return.*bay", RegexOptions.IgnoreCase));
    //Sanderling.KeyboardPressCombined(new[]{ VirtualKeyCode.SHIFT, VirtualKeyCode.VK_F});
}

Func<object>    DefenseStep()
{
    if(DefenseExit)
    {
        Host.Log("exit defense.");
        //DroneEnsureInBay();
        ToggelHardener(false);
        return null;
    }

    if(ActivateHardener)
        //ActivateHardenerExecute();
        ToggelHardener(true);

    DroneLaunch();

    EnsureOverviewTypeSelectionLoaded();

    var SetRatName =
        ListRatOverviewEntry?.Select(entry => Regex.Split(entry?.Name ?? "", @"\s+")?.FirstOrDefault())
        ?.Distinct()
        ?.ToArray();

    var SetRatTarget = Measurement?.Target?.Where(target =>
        SetRatName?.Any(ratName => target?.TextRow?.Any(row => row.RegexMatchSuccessIgnoreCase(ratName)) ?? false) ?? false);

    var RatTargetNext = SetRatTarget?.OrderBy(target => target?.DistanceMax ?? int.MaxValue)?.FirstOrDefault();

    if(null == RatTargetNext)
    {
        Host.Log("targeting rat!");
        Sanderling.MouseClickRight(ListRatOverviewEntry?.FirstOrDefault());
        Sanderling.MouseClickLeft(MenuEntryLockTarget);
    }
    else
    {
        Host.Log("rat targeted. sending drones.");
        Sanderling.MouseClickLeft(RatTargetNext);
        Sanderling.MouseClickRight(DronesInSpaceListEntry);
        //Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("engage", RegexOptions.IgnoreCase));
        Sanderling.KeyboardPress(VirtualKeyCode.VK_F);
    }

    return DefenseStep;
}

Func<object> InBeltMineStep()
{
    var ConnectionLost = Measurement?.WindowOther?.FirstOrDefault()?.LabelText?.FirstOrDefault(text => (text?.Text.RegexMatchSuccessIgnoreCase("Connection") ?? false));
    if (ConnectionLost != null){
            Host.Log(" ***              Lost connection at : " + DateTime.Now.ToString(" HH:mm")+ " ***   " );
            Console.Beep(1047,150);
            Host.Delay(150);
            return BotStopActivity;
    } else {
        // Host.Log(" ***              Online: " + DateTime.Now.ToString(" HH:mm")+ " ***   " );
    }

    if (DefenseEnter){
        Host.Log("enter defense.");
        return DefenseStep;
    }

    EnsureWindowInventoryOpenOreHold();

    EnsureOverviewTypeSelectionLoaded();

    if(OreHoldFilledForOffload)
        return null;

    var moduleMinerInactive = SetModuleMinerInactive?.FirstOrDefault();

    // wenn die Miner -Laser arbeiten dann
    if (null == moduleMinerInactive)
    {
         // Wenn keine Drohnen gestartet
        if (!(0 < DronesInSpaceCount))
        {
            Host.Log("launch drones.");
            Sanderling.MouseClickRight(DronesInBayListEntry);
            Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("launch", RegexOptions.IgnoreCase));
            Host.Delay(2000);
            Sanderling.MouseClickRight(DronesInSpaceListEntry);
            Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("mine", RegexOptions.IgnoreCase));
        }

        var Speed = Sanderling?.MemoryMeasurementParsed?.Value?.ShipUi?.SpeedMilli;
        var asteroidOverviewEntryNextA = ListAsteroidOverviewEntry?.FirstOrDefault();
        if ( asteroidOverviewEntryNextA.DistanceMax < 8000 && Speed > 50000)
        {
            Sanderling.KeyboardPressCombined(new[]{ VirtualKeyCode.CONTROL, VirtualKeyCode.SPACE});
                Host.Log("STOP Ship 8000");
            }
        else
        {
            //Host.Log("Ship to Target "+ asteroidOverviewEntryNextA.DistanceMax);
        }

        //try to unlock drone targets
        var targetDroneInputFocus   =
            SetTargetDrone?.FirstOrDefault(target => target?.IsSelected ?? false);

        /*
        if(null == targetDroneInputFocus){
            Sanderling.MouseClickLeft(SetTargetDrone?.FirstOrDefault());

            //irgendwie so
            Sanderling.MouseClickRight(DronesInSpaceListEntry);
            Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("Mine", RegexOptions.IgnoreCase));



        }
        */

        /* // Try Salvage Wrecks
        if(0<ListWreckOverviewEntry?.Length){ //Wenn Wracks gefunden
            var WreckOverviewEntryNext = ListWreckOverviewEntry?.FirstOrDefault();
            Host.Log("next Wreck: (" + WreckOverviewEntryNext?.Name + " , distance: " + WreckOverviewEntryNext?.DistanceMax + ")");
            var WreckMaxDistance = 10000;
            var setTargetWreckInRange = SetWreck?.Where(target => target?.DistanceMax <= WreckMaxDistance)?.ToArray();
            Host.Log("targeted asteroids in range (without assignment): " + setTargetWreckInRange?.Length + ")");
            //Sanderling.MouseClickRight(DronesInSpaceListEntry);
            //Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("salvage", RegexOptions.IgnoreCase));
        }
        */

        Host.Delay(7000);

        return InBeltMineStep;
    }

    var setTargetAsteroidInRange    =
        SetTargetAsteroid?.Where(target => target?.DistanceMax <= MiningRange)?.ToArray();

    var setTargetAsteroidInRangeNotAssigned =
        setTargetAsteroidInRange?.Where(target => !(0 < target?.Assigned?.Length))?.ToArray();

    Host.Log("targeted asteroids in range (without assignment): " + setTargetAsteroidInRange?.Length + " (" + setTargetAsteroidInRangeNotAssigned?.Length + ")");

    if(0 < setTargetAsteroidInRangeNotAssigned?.Length)
    {
        if(UseAfterburner)
        {
            ToggleMicroWarpDrive(false);
            ToggleAfterBurner(false);
        }
        var targetAsteroidInputFocus    =
            setTargetAsteroidInRangeNotAssigned?.FirstOrDefault(target => target?.IsSelected ?? false);

        if(null == targetAsteroidInputFocus)
            Sanderling.MouseClickLeft(setTargetAsteroidInRangeNotAssigned?.FirstOrDefault());

        /*
        foreach (var moduleMinerIna in SetModuleMinerInactive)
        {
            if (UseMiningCrystal) {
                LoadMiningCrystalForTarget(moduleMinerIna, setTargetAsteroidInRangeNotAssigned?.FirstOrDefault());
                /*
                string[] targetTextRow = setTargetAsteroidInRangeNotAssigned?.FirstOrDefault()?.TextRow;
                if (targetTextRow != null && targetTextRow.Length > 0) {
                    string baseOre = BaseOreFromAsteroidName(String.Join(" ", targetTextRow));
                    if (!String.IsNullOrEmpty(baseOre)) {
                            LoadMiningCrystal(moduleMinerIna, baseOre);
                            Sanderling.MouseClickLeft(setTargetAsteroidInRangeNotAssigned?.FirstOrDefault());
                            Sanderling.MouseMove(moduleMinerIna);
                            Sanderling.WaitForMeasurement();
                    }
                }

            }

            ModuleToggle(moduleMinerIna);
        }
        */

        ModuleToggle(moduleMinerInactive);

        DroneLaunch();
        Host.Delay(5000);

        Sanderling.MouseClickRight(DronesInSpaceListEntry);
        Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("Mine", RegexOptions.IgnoreCase));

        //Stop ship if under 10000 meter from target
        var asteroidOverviewEntryNextA = ListAsteroidOverviewEntry?.FirstOrDefault();
        if(!(8000 < asteroidOverviewEntryNextA?.DistanceMin)){
            Sanderling.KeyboardPressCombined(new[]{ VirtualKeyCode.CONTROL, VirtualKeyCode.SPACE});
            Host.Log("STOP Ship  Approach 8000");
        }

        return InBeltMineStep;
    }

    var asteroidOverviewEntryNext = ListAsteroidOverviewEntry?.FirstOrDefault();
    var asteroidOverviewEntryNextNotTargeted = ListAsteroidOverviewEntry?.FirstOrDefault(entry => !((entry?.MeTargeted ?? false) || (entry?.MeTargeting ?? false)));

    Host.Log("next asteroid: (" + asteroidOverviewEntryNext?.Name + " , distance: " + asteroidOverviewEntryNext?.DistanceMax + ")" +
        ", next asteroid not targeted: (" + asteroidOverviewEntryNext?.Name + " , distance: " + asteroidOverviewEntryNext?.DistanceMax + ")");

    if(null == asteroidOverviewEntryNext)
    {
        Host.Log("no asteroid available");
        return null;
    }

    if(null == asteroidOverviewEntryNextNotTargeted)
    {
        Host.Log("all asteroids targeted");
        return null;
    }

    if (!(asteroidOverviewEntryNextNotTargeted.DistanceMax < MiningRange))
    {
        if(!(1000 < asteroidOverviewEntryNext?.DistanceMin))
        {
            Host.Log("distance between asteroids too large");
            return null;
        }

        Host.Log("out of range, approaching");
        Random rnd = new Random();
        if (!ApproachSomething || RandomInt() % 8 == 1)
            ClickMenuEntryOnMenuRoot(asteroidOverviewEntryNext, "approach");

        if (SetModuleMinerActive?.FirstOrDefault() == null && CapacitorPercent > 50 && UseAfterburner)
        {
            ToggleMicroWarpDrive(true);
            ToggleAfterBurner(true);
        }
    }
    else
    {
        Host.Log("initiate lock asteroid");
        ClickMenuEntryOnMenuRoot(asteroidOverviewEntryNextNotTargeted, "^lock");
    }

    return InBeltMineStep;
}


Sanderling.Parse.IMemoryMeasurement Measurement =>
    Sanderling?.MemoryMeasurementParsed?.Value;

IWindow ModalUIElement =>
    Measurement?.EnumerateReferencedUIElementTransitive()?.OfType<IWindow>()?.Where(window => window?.isModal ?? false)
    ?.OrderByDescending(window => window?.InTreeIndex ?? int.MinValue)
    ?.FirstOrDefault();

IEnumerable<Parse.IMenu> Menu => Measurement?.Menu;

Parse.IShipUi ShipUi => Measurement?.ShipUi;

bool Jammed => ShipUi?.EWarElement?.Any(EwarElement => (EwarElement?.EWarType).RegexMatchSuccess("electronic")) ?? false;

Sanderling.Interface.MemoryStruct.IMenuEntry MenuEntryLockTarget =>
    Menu?.FirstOrDefault()?.Entry?.FirstOrDefault(entry => entry.Text.RegexMatchSuccessIgnoreCase("^lock"));

Sanderling.Parse.IWindowOverview    WindowOverview  =>
    Measurement?.WindowOverview?.FirstOrDefault();

Sanderling.Parse.IWindowInventory   WindowInventory =>
    Measurement?.WindowInventory?.FirstOrDefault();

IWindowDroneView    WindowDrones    =>
    Measurement?.WindowDroneView?.FirstOrDefault();

ITreeViewEntry InventoryActiveShipOreHold =>
    WindowInventory?.ActiveShipEntry?.TreeEntryFromCargoSpaceType(ShipCargoSpaceTypeEnum.OreHold);

IInventoryCapacityGauge OreHoldCapacityMilli =>
    (InventoryActiveShipOreHold?.IsSelected ?? false) ? WindowInventory?.SelectedRightInventoryCapacityMilli : null;

int? OreHoldFillPercent => (int?)((OreHoldCapacityMilli?.Used * 100) / OreHoldCapacityMilli?.Max);

Tab OverviewPresetTabActive =>
    WindowOverview?.PresetTab
    ?.OrderByDescending(tab => tab?.LabelColorOpacityMilli ?? 0)
    ?.FirstOrDefault();

string OverviewTypeSelectionName =>
    WindowOverview?.Caption?.RegexMatchIfSuccess(@"\(([^\)]*)\)")?.Groups?[1]?.Value;

Parse.IOverviewEntry[] ListRatOverviewEntry => WindowOverview?.ListView?.Entry?.Where(entry =>
        (entry?.MainIconIsRed ?? false) && (entry?.IsAttackingMe ?? false))
        ?.OrderBy(entry => entry?.DistanceMax ?? int.MaxValue)
        ?.ToArray();

Parse.IOverviewEntry[] ListAsteroidOverviewEntry =>
    WindowOverview?.ListView?.Entry
    ?.Where(entry => null != OreTypeFromAsteroidName(entry?.Name) && !IsExcludedBaseOre(entry?.Name))
    ?.OrderBy(entry => entry.DistanceMax ?? int.MaxValue)
    ?.ToArray();

Parse.IOverviewEntry[] ListWreckOverviewEntry =>
    WindowOverview?.ListView?.Entry
    ?.Where(entry => null != WreckName(entry?.Name))
    ?.OrderBy(entry => entry.DistanceMax ?? int.MaxValue)
    ?.ToArray();

DroneViewEntryGroup DronesInBayListEntry =>
    WindowDrones?.ListView?.Entry?.OfType<DroneViewEntryGroup>()?.FirstOrDefault(Entry => null != Entry?.Caption?.Text?.RegexMatchIfSuccess(@"Drones in bay", RegexOptions.IgnoreCase));

DroneViewEntryGroup DronesInSpaceListEntry =>
    WindowDrones?.ListView?.Entry?.OfType<DroneViewEntryGroup>()?.FirstOrDefault(Entry => null != Entry?.Caption?.Text?.RegexMatchIfSuccess(@"Drones in Local Space", RegexOptions.IgnoreCase));

int?    DronesInSpaceCount => DronesInSpaceListEntry?.Caption?.Text?.AsDroneLabel()?.Status?.TryParseInt();
int?    DronesInBayCount => DronesInBayListEntry?.Caption?.Text?.AsDroneLabel()?.Status?.TryParseInt();

bool ReadyForManeuverNot =>
    Measurement?.ShipUi?.Indication?.LabelText?.Any(indicationLabel =>
        (indicationLabel?.Text).RegexMatchSuccessIgnoreCase("warp|docking")) ?? false;

bool ApproachSomething =>
    Measurement?.ShipUi?.Indication?.LabelText?.Any(indicationLabel =>
        (indicationLabel?.Text).RegexMatchSuccessIgnoreCase("approaching")) ?? false;

bool ReadyForManeuver => !ReadyForManeuverNot && !(Measurement?.IsDocked ?? true);

//check if target is Asteroid
Sanderling.Parse.IShipUiTarget[] SetTargetAsteroid =>
    Measurement?.Target?.Where(target =>
        target?.TextRow?.Any(textRow => textRow.RegexMatchSuccessIgnoreCase("asteroid")) ?? false)?.ToArray();

//check if target is Wreck
Sanderling.Parse.IShipUiTarget[] SetWreck =>
    Measurement?.Target?.Where(target =>
        target?.TextRow?.Any(textRow => textRow.RegexMatchSuccessIgnoreCase("wreck")) ?? false)?.ToArray();

//check if target is own drone
Sanderling.Parse.IShipUiTarget[] SetTargetDrone =>
    Measurement?.Target?.Where(target =>
        target?.TextRow?.Any(textRow => textRow.RegexMatchSuccessIgnoreCase("hornet|hobgoblin|wasp|vespa")) ?? false)?.ToArray();

Sanderling.Interface.MemoryStruct.IListEntry    WindowInventoryItem =>
    WindowInventory?.SelectedRightInventory?.ListView?.Entry?.FirstOrDefault();

Sanderling.Accumulation.IShipUiModule[] SetModuleMiner =>
    Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.Where(module => module?.TooltipLast?.Value?.IsMiner ?? false)?.ToArray();

Sanderling.Accumulation.IShipUiModule[] SetModuleMinerInactive   =>
    SetModuleMiner?.Where(module => !(module?.RampActive ?? false))?.ToArray();

Sanderling.Accumulation.IShipUiModule[] SetModuleMinerActive     =>
    SetModuleMiner?.Where(module => (module?.RampActive ?? false))?.ToArray();

int?    MiningRange => SetModuleMiner?.Select(module =>
    module?.TooltipLast?.Value?.RangeOptimal ?? module?.TooltipLast?.Value?.RangeMax ?? module?.TooltipLast?.Value?.RangeWithin ?? 0)?.DefaultIfEmpty(0)?.Min();;

WindowChatChannel chatLocal =>
     Sanderling.MemoryMeasurementParsed?.Value?.WindowChatChannel
     ?.FirstOrDefault(windowChat => windowChat?.Caption?.RegexMatchSuccessIgnoreCase("local") ?? false);

//    assuming that own character is always visible in local
bool hostileOrNeutralsInLocal => 1 != chatLocal?.ParticipantView?.Entry?.Count(IsNeutralOrEnemy);

//  extract the ore type from the name as seen in overview. "Asteroid (Plagioclase)"
string OreTypeFromAsteroidName(string AsteroidName) =>
    AsteroidName.ValueFromRegexMatchGroupAtIndex(@"Asteroid \(([^\)]+)", 0);

//  extract Name of Wreck as seen in Overview
string WreckName(string Name)   =>
    Name.ValueFromRegexMatchGroupAtIndex(@"((Wreck))", 0);

string BaseOreFromAsteroidName(string asteroidName)
{
    return Array.Find<string>(BaseOre, (Predicate<string>)delegate (string s)
    {
        return asteroidName.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1;
    });
}

bool IsExcludedBaseOre(string asteroidName) {
    return Array.Exists<string>(ExcludedBaseOre, (Predicate<string>)delegate (string s)
    {
        return asteroidName.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1;
    });
}

void ClickMenuEntryOnMenuRoot(IUIElement MenuRoot, string MenuEntryRegexPattern)
{
    Sanderling.MouseClickRight(MenuRoot);

    var Menu = Measurement?.Menu?.FirstOrDefault();

    var MenuEntry = Menu?.EntryFirstMatchingRegexPattern(MenuEntryRegexPattern, RegexOptions.IgnoreCase);

    Sanderling.MouseClickLeft(MenuEntry);
}

void EnsureWindowInventoryOpen()
{
    if (null != WindowInventory)
        return;

    Host.Log("open Inventory.");
    Sanderling.MouseClickLeft(Measurement?.Neocom?.InventoryButton);
}

void EnsureWindowInventoryOpenOreHold()
{
    EnsureWindowInventoryOpen();

    var inventoryActiveShip = WindowInventory?.ActiveShipEntry;

    if(InventoryActiveShipOreHold == null && !(inventoryActiveShip?.IsExpanded ?? false))
        Sanderling.MouseClickLeft(inventoryActiveShip?.ExpandToggleButton);

    if(!(InventoryActiveShipOreHold?.IsSelected ?? false))
        Sanderling.MouseClickLeft(InventoryActiveShipOreHold);
}

//  sample label text: Intensive Reprocessing Array <color=#66FFFFFF>1,123 m</color>
string InventoryContainerLabelRegexPatternFromContainerName(string containerName) =>
    @"^\s*" + Regex.Escape(containerName) + @"\s*($|\<)";

void InInventoryUnloadItems() => InInventoryUnloadItemsTo(UnloadDestContainerName);

void InInventoryUnloadItemsTo(string DestinationContainerName)
{
    Host.Log("unload items to '" + DestinationContainerName + "'.");

    EnsureWindowInventoryOpenOreHold();

    for (;;)
    {
        var oreHoldListItem = WindowInventory?.SelectedRightInventory?.ListView?.Entry?.ToArray();

        var oreHoldItem = oreHoldListItem?.FirstOrDefault();

        if(null == oreHoldItem)
        {
            Host.Log("done unload items");
            break;    //    0 items in OreHold
        }

        if(1 < oreHoldListItem?.Length)
            ClickMenuEntryOnMenuRoot(oreHoldItem, @"select\s*all");

        var DestinationContainerLabelRegexPattern =
            InventoryContainerLabelRegexPatternFromContainerName(DestinationContainerName);

        var DestinationContainer =
            WindowInventory?.LeftTreeListEntry?.SelectMany(entry => new[] { entry }.Concat(entry.EnumerateChildNodeTransitive()))
            ?.FirstOrDefault(entry => entry?.Text?.RegexMatchSuccessIgnoreCase(DestinationContainerLabelRegexPattern) ?? false);

        if (null == DestinationContainer)
            Host.Log("error: Inventory entry labeled '" + DestinationContainerName + "' not found");

        Sanderling.MouseDragAndDrop(oreHoldItem, DestinationContainer);
    }
}

var ConnectionLost = Measurement?.WindowOther?.FirstOrDefault()?.LabelText?.FirstOrDefault(text => (text?.Text.RegexMatchSuccessIgnoreCase("Connection") ?? false));
if (ConnectionLost != null)
{
        Host.Log("               Lost connection at : " + DateTime.Now.ToString(" HH:mm")+ "" );
        Console.Beep(1047,150);
        Host.Delay(150);
        Console.Beep(1047,150);
        Host.Delay(150);
        return BotStopActivity;
}
bool InitiateWarpToRandomMiningSite()   =>
    InitiateDockToOrWarpToBookmark(RandomElement(SetMiningSiteBookmark));

bool InitiateWarpToRandomMiningBookmark() =>
    InitiateDockToOrWarpToLocationInSolarSystemMenu(RandomElement(SetMiningSiteBookmark));

bool InitiateWarpToMiningSite() =>
    InitiateDockToOrWarpToLocationInSolarSystemMenu("Asteroid Belts", PickNextMiningSiteFromSystemMenu);

bool InitiateDockToOffload()    =>
    InitiateDockToOrWarpToLocationInSolarSystemMenu(UnloadBookmark, PickPlaceToOffloadfFromSystemMenu);

//bool InitiateWarpToRetreat()  =>  InitiateDockToOrWarpToLocationInSolarSystemMenu("stations");

MemoryStruct.IMenuEntry PickNextMiningSiteFromSystemMenu(IReadOnlyList<MemoryStruct.IMenuEntry> availableMenuEntries)
{
    Host.Log("I am seeing " + availableMenuEntries?.Count.ToString() + " mining sites to choose from.");

    var nextSite =
        availableMenuEntries
        ?.OrderBy(menuEntry => visitedLocations.ToList().IndexOf(menuEntry?.Text))
        ?.FirstOrDefault();

    Host.Log("I pick '" + nextSite?.Text + "' as next mining site, based on the intent to rotate through the mining sites and recorded previous locations.");
    return nextSite;
}

MemoryStruct.IMenuEntry PickPlaceToOffloadfFromSystemMenu(IReadOnlyList<MemoryStruct.IMenuEntry> availableMenuEntries)
{
    Host.Log("I am seeing " + availableMenuEntries?.Count.ToString() + " stations to choose from for offloading ore.");

    var availableMenuEntriesTexts =
        availableMenuEntries
        ?.Select(menuEntry => menuEntry.Text)
        ?.ToList();

    foreach(var visitedLocation in visitedLocations.Reverse())
    {
        var visitedLocationMenuEntry =
            availableMenuEntries?.FirstOrDefault(menuEntry =>
                StationFromSystemInfoPanelEqualsStationFromSystemMenu(visitedLocation, menuEntry?.Text));

        if(visitedLocationMenuEntry == null)
            continue;

        Host.Log("I pick '" + visitedLocationMenuEntry?.Text + "' as destination, because this is the last one visited.");
        return visitedLocationMenuEntry;
    }

    var dockMenuEntry = availableMenuEntries?.Where(x => x?.Text?.Contains("Dock") ?? false)?.FirstOrDefault();
    var destination = dockMenuEntry ?? availableMenuEntries?.FirstOrDefault();

    Host.Log("I pick '" + destination?.Text + "' as destination, because I do not remember having visited any of the available stations.");
    return destination;
}

bool InitiateDockToOrWarpToLocationInSolarSystemMenu(
    string submenuLabel,
    Func<IReadOnlyList<MemoryStruct.IMenuEntry>, MemoryStruct.IMenuEntry> pickPreferredDestination = null)
{
    Host.Log("Attempt to initiate dock to or warp to menu entry in submenu '" + submenuLabel + "'");

    DroneEnsureInBay();

    var listSurroundingsButton = Measurement?.InfoPanelCurrentSystem?.ListSurroundingsButton;

    Sanderling.MouseClickRight(listSurroundingsButton);

    var submenuEntry = Measurement?.Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("^" + submenuLabel + "$", RegexOptions.IgnoreCase);

    if(null == submenuEntry)
    {
        Host.Log("Submenu '" + submenuLabel + "' not found in the solar system menu.");
        return true;
    }

    Sanderling.MouseClickLeft(submenuEntry);

    var submenu = Measurement?.Menu?.ElementAtOrDefault(1);

    var destinationMenuEntry = pickPreferredDestination?.Invoke(submenu?.Entry?.ToList()) ?? submenu?.Entry?.FirstOrDefault();

    if(destinationMenuEntry == null)
    {
        Host.Log("Failed to open submenu '" + submenuLabel + "' in the solar system menu.");
        return true;
    }

    Sanderling.MouseClickLeft(destinationMenuEntry);

    var actionsMenu = Measurement?.Menu?.ElementAtOrDefault(2);

    if(destinationMenuEntry == null)
    {
        Host.Log("Failed to open actions menu for '" + destinationMenuEntry.Text + "' in the solar system menu.");
        return true;
    }

    var dockMenuEntry = actionsMenu?.EntryFirstMatchingRegexPattern("dock", RegexOptions.IgnoreCase);
    var warpMenuEntry = actionsMenu?.EntryFirstMatchingRegexPattern(@"warp.*within.*m", RegexOptions.IgnoreCase);
    var approachEntry = actionsMenu?.EntryFirstMatchingRegexPattern(@"approach", RegexOptions.IgnoreCase);

    var maneuverMenuEntry = dockMenuEntry ?? warpMenuEntry;

    if (null != maneuverMenuEntry)
    {
        Host.Log("initiating '" + maneuverMenuEntry.Text + "' on '" + destinationMenuEntry?.Text + "'");
        Sanderling.MouseClickLeft(maneuverMenuEntry);
        return false;
    }

    if (null != approachEntry)
    {
        Host.Log("found menu entry '" + approachEntry.Text + "'. Assuming we are already there.");
        return false;
    }

    Host.Log("no suitable menu entry found on '" + destinationMenuEntry?.Text + "'");
    return true;
}

bool InitiateDockToOrWarpToBookmark(string bookmarkOrFolder)
{
    Host.Log("dock to or warp to bookmark or random bookmark in folder: '" + bookmarkOrFolder + "'");

    DroneEnsureInBay();

    var listSurroundingsButton = Measurement?.InfoPanelCurrentSystem?.ListSurroundingsButton;

    Sanderling.MouseClickRight(listSurroundingsButton);

    var bookmarkMenuEntry = Measurement?.Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("^" + bookmarkOrFolder + "$", RegexOptions.IgnoreCase);

    if(null == bookmarkMenuEntry)
    {
        Host.Log("menu entry not found for bookmark or folder: '" + bookmarkOrFolder + "'");
        return true;
    }

    var currentLevelMenuEntry = bookmarkMenuEntry;

    for (var menuLevel = 1; ; ++menuLevel)
    {
        Sanderling.MouseClickLeft(currentLevelMenuEntry);

        var menu = Measurement?.Menu?.ElementAtOrDefault(menuLevel);
        var dockMenuEntry = menu?.EntryFirstMatchingRegexPattern("dock", RegexOptions.IgnoreCase);
        var warpMenuEntry = menu?.EntryFirstMatchingRegexPattern(@"warp.*within\s*0", RegexOptions.IgnoreCase);
        var approachEntry = menu?.EntryFirstMatchingRegexPattern(@"approach", RegexOptions.IgnoreCase);

        var maneuverMenuEntry = dockMenuEntry ?? warpMenuEntry;

        if (null != maneuverMenuEntry)
        {
            Host.Log("initiating '" + maneuverMenuEntry.Text + "' on entry '" + currentLevelMenuEntry?.Text + "'");
            Sanderling.MouseClickLeft(maneuverMenuEntry);
            return false;
        }

        if (null != approachEntry)
        {
            Host.Log("found menu entry '" + approachEntry.Text + "'. Assuming we are already there.");
            return false;
        }

        var setBookmarkOrFolderMenuEntry =
            menu?.Entry;    //  assume that each entry on the current menu level is a bookmark or a bookmark folder.

        var nextLevelMenuEntry = RandomElement(setBookmarkOrFolderMenuEntry);

        if(null == nextLevelMenuEntry)
        {
            Host.Log("no suitable menu entry found");
            return true;
        }

        currentLevelMenuEntry = nextLevelMenuEntry;
    }
}

void Undock()
{
    while(Measurement?.IsDocked ?? true)
    {
        Sanderling.MouseClickLeft(Measurement?.WindowStation?.FirstOrDefault()?.UndockButton);
        Host.Log("waiting for undocking to complete.");
        Host.Delay(7000);
    }

    Host.Delay(1000);
    Sanderling.InvalidateMeasurement();
}

void ModuleMeasureAllTooltip()
{
    Host.Log("measure tooltips of all modules.");

    for (;;)
    {
        var NextModule = Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.FirstOrDefault(m => null == m?.TooltipLast);

        if(null == NextModule)
        {
            Host.Log("found all Moduls.");
            break;
        }

        Host.Log("measure module."+ NextModule);
        //  take multiple measurements of module tooltip to reduce risk to keep bad read tooltip.
        Sanderling.MouseMove(NextModule);
        Sanderling.WaitForMeasurement();
        Sanderling.MouseMove(NextModule);
        Sanderling.WaitForMeasurement();
    }
}

/*
void ActivateHardenerExecute()
{
    var SubsetModuleHardener =
        Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.Where(module => module?.TooltipLast?.Value?.IsHardener ?? false);

    var SubsetModuleToToggle =
        SubsetModuleHardener?.Where(module => !(module?.RampActive ?? false));

    foreach (var Module in SubsetModuleToToggle.EmptyIfNull())
        ModuleToggle(Module);
}
*/

// Hardener
Sanderling.Accumulation.IShipUiModule[] SetModuleHardener =>
    Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.Where(module => module?.TooltipLast?.Value?.IsHardener ?? false)?.ToArray();

void ToggelHardener(bool turnOn = true){
    var Hardener = SetModuleHardener?.FirstOrDefault();

    if((Hardener?.RampActive ?? false) !=turnOn)
    {
        Host.Log("toggle Hardener "+ turnOn);
        ModuleToggle(Hardener);
    }
}

// get all shield boosters in one array
Sanderling.Accumulation.IShipUiModule[] SetModuleShieldBoosters => Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.Where(module => module?.TooltipLast?.Value?.IsShieldBooster ?? false)?.ToArray();

// if true then we should turn on shield booster if false - turn off
void ToggleShieldBooster(bool turnOn = true)
{
    var shieldBooster = SetModuleShieldBoosters?.FirstOrDefault();
    if((shieldBooster?.RampActive ?? false) !=turnOn)
    {
        Host.Log("toggle Shield Booster "+ turnOn);
        ModuleToggle(shieldBooster);
    }
}
// get all micro warp drive in one array
Sanderling.Accumulation.IShipUiModule[] SetModuleMicroWarpDrive => Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.Where(module => module?.TooltipLast?.Value?.IsMicroWarpDrive ?? false)?.ToArray();

// if true then we should turn on MicorBurn; if false - turn off
void ToggleMicroWarpDrive(bool turnOn = true)
{
    var microWarp = SetModuleMicroWarpDrive?.FirstOrDefault();
    if((microWarp?.RampActive ?? false) !=turnOn)
    {
        Host.Log("toggle Micro Warp Drive "+ turnOn);
        ModuleToggle(microWarp);
    }
}

// afterburner
Sanderling.Accumulation.IShipUiModule[] SetModuleAfterBurnerDrive =>Sanderling.MemoryMeasurementAccu?.Value?.ShipUiModule?.Where(module => module?.TooltipLast?.Value?.IsAfterburner ?? false)?.ToArray();

void ToggleAfterBurner(bool turnOn = true)
{
    var afterBurner = SetModuleAfterBurnerDrive?.FirstOrDefault();
    if((afterBurner?.RampActive ?? false) !=turnOn)
    {
        Host.Log("toggle AfterBurner "+ turnOn);
        ModuleToggle(afterBurner);
    }
}

// Mining Crystal
void LoadMiningCrystal(Sanderling.Accumulation.IShipUiModule Module, string baseOre)
{
    Sanderling.MouseClickRight(Module);
    var menuCrystal = Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern(baseOre +".*mining.*crystal", RegexOptions.IgnoreCase);
    if (menuCrystal != null)
        Sanderling.MouseClickLeft(menuCrystal);
}

void LoadMiningCrystalForTarget(Sanderling.Accumulation.IShipUiModule module, Sanderling.Parse.IShipUiTarget target)
{
    string[] targetTextRow = target?.TextRow;
    if (targetTextRow != null && targetTextRow.Length > 0) {
        string baseOre = BaseOreFromAsteroidName(String.Join(" ", targetTextRow));
        if (!String.IsNullOrEmpty(baseOre)) {
            Sanderling.MouseMove(module);
            Sanderling.WaitForMeasurement();
            var foundCrystal = module?.TooltipLast?.Value?.LabelText?.FirstOrDefault(entry => entry.Text.RegexMatchSuccessIgnoreCase("Mining Crystal"));
            //IEnumerable<Sanderling.Interface.MemoryStruct.UIElementText> foundLabels = module?.TooltipLast?.Value?.LabelText?.Text.Where(lbl => lbl.Text.Contains("Mining Crystal"));

            if (foundCrystal != null && foundCrystal.Text.Contains(baseOre))
                return;

            Sanderling.MouseClickRight(module);
            var menuCrystal = Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern(baseOre +".*mining.*crystal", RegexOptions.IgnoreCase);

            if (menuCrystal != null)
                Sanderling.MouseClickLeft(menuCrystal);
            else if (foundCrystal != null)
                Sanderling.MouseClickLeft( Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("unload to cargo", RegexOptions.IgnoreCase));
            else
                Sanderling.MouseClickLeft(target);
        }
    }
}

void ModuleToggle(Sanderling.Accumulation.IShipUiModule Module)
{
    var ToggleKey = Module?.TooltipLast?.Value?.ToggleKey;

    Host.Log("toggle module using " + (null == ToggleKey ? "mouse" : Module?.TooltipLast?.Value?.ToggleKeyTextLabel?.Text));

    if(null == ToggleKey)
        Sanderling.MouseClickLeft(Module);
    else
        Sanderling.KeyboardPressCombined(ToggleKey);
}

void EnsureOverviewTypeSelectionLoaded()
{
    if(null == OverviewPresetTabActive || null == WindowOverview || null == OverviewPreset)
        return;

    if(string.Equals(OverviewTypeSelectionName, OverviewPreset, StringComparison.OrdinalIgnoreCase))
        return;

    Host.Log("loading preset '" + OverviewPreset + "' to overview (current selection is '" + OverviewTypeSelectionName + "').");
    Sanderling.MouseClickRight(OverviewPresetTabActive);
    Sanderling.MouseClickLeft(Menu?.FirstOrDefault()?.EntryFirstMatchingRegexPattern("load.*preset", RegexOptions.IgnoreCase));
    var PresetMenuEntry = Menu?.ElementAtOrDefault(1)?.EntryFirstMatchingRegexPattern(@"^\s*" + Regex.Escape(OverviewPreset) + @"\s*$", RegexOptions.IgnoreCase);

    if(null == PresetMenuEntry)
    {
        Host.Log("error: menu entry '" + OverviewPreset + "' not found");
        return;
    }

    Sanderling.MouseClickLeft(PresetMenuEntry);
}

void MemoryUpdate()
{
    RetreatUpdate();
    JammedLastTimeUpdate();
    UpdateLocationRecord();
    OffloadCountUpdate();
}

/*
2018-03 Observation: Station name containing reference to moon appears different between system menu and system info panel.
In the info panel 'Moon 17' was used while in the system menu it was 'M17'.
*/
public bool StationFromSystemInfoPanelEqualsStationFromSystemMenu(
    string stationNameInCurrentSystemInfoPanel,
    string stationNameInSystemMenu)
{
    //  Copied from https://github.com/botengine-de/Optimat.EO/blob/6c19e8f36e30d5468e94d627eb16dcb78bb47d12/src/Optimat.EveOnline.Bot/Sonst/AgentUndMission.Aktualisiire.cs#L1888-L1893

    var representationPattern =
        Regex.Replace(
        stationNameInCurrentSystemInfoPanel,
        "Moon\\s*",
        "M([\\w]*\\s*)",
        RegexOptions.IgnoreCase);

    return
        stationNameInSystemMenu.RegexMatchSuccessIgnoreCase(representationPattern);
}

void JammedLastTimeUpdate()
{
    if(Jammed)
        JammedLastTime  = Host.GetTimeContinuousMilli();
}

bool MeasurementEmergencyWarpOutEnter =>
    !(Measurement?.IsDocked ?? false) && !(EmergencyWarpOutHitpointPercent < ShieldHpPercent);

void RetreatUpdate()
{
    RetreatReasonTemporary = (RetreatOnNeutralOrHostileInLocal && hostileOrNeutralsInLocal) ? "hostile or neutral in local" : null;

    if (!MeasurementEmergencyWarpOutEnter)
        return;

    //  measure multiple times to avoid being scared off by noise from a single measurement.
    Sanderling.InvalidateMeasurement();

    if (!MeasurementEmergencyWarpOutEnter)
        return;

    RetreatReasonPermanent = "shield hp";
}

void OffloadCountUpdate()
{
    var OreHoldFillPercentSynced    = OreHoldFillPercent;

    if(!OreHoldFillPercentSynced.HasValue)
        return;

    if(0 == OreHoldFillPercentSynced && OreHoldFillPercentSynced < LastCheckOreHoldFillPercent)
        ++OffloadCount;

    LastCheckOreHoldFillPercent = OreHoldFillPercentSynced;
}

void UpdateLocationRecord()
{
    //  I am not interested in locations which are only close during warp.
    if (Measurement?.ShipUi?.Indication?.ManeuverType == ShipManeuverTypeEnum.Warp)
        return;

    // Purpose of recording locations is to prioritize our next destination when warping to mining site or docking to station.
    // For this purpose, I will compare the recorded locations with the menu entries in the system menu.
    // Therefore I want the format of the recorded location to be the same as it appears in the menu entries in the system menu.

    var currentSystemLocationLabelText =
        Measurement?.InfoPanelCurrentSystem?.ExpandedContent?.LabelText
        ?.OrderByCenterVerticalDown()?.FirstOrDefault()?.Text;

    if (currentSystemLocationLabelText == null)
        return;

    // 2018-03 observed label text: <url=showinfo:15//40088644 alt='Nearest'>Amsen V - Asteroid Belt 1</url>

    var currentLocationName = RegexExtension.RemoveXmlTag(currentSystemLocationLabelText)?.Trim();

    var lastRecordedLocation = visitedLocations.LastOrDefault();

    if (lastRecordedLocation == currentLocationName)
        return;

    visitedLocations.Enqueue(currentLocationName);
    Host.Log("Recorded transition from location '" + lastRecordedLocation + "' to location '" + currentLocationName + "'");

    if (100 < visitedLocations.Count)
        visitedLocations.Dequeue();
}

bool IsNeutralOrEnemy(IChatParticipantEntry participantEntry) =>
   !(participantEntry?.FlagIcon?.Any(flagIcon =>
     new[] { "good standing", "excellent standing", "Pilot is in your (fleet|corporation)", }
     .Any(goodStandingText =>
        flagIcon?.HintText?.RegexMatchSuccessIgnoreCase(goodStandingText) ?? false)) ?? false);