Example #1
0
        static public SictAufgaabeParamZerleegungErgeebnis ZerleegeShipAktuelOpenInventoryCargoTyp(
            SictAutomatZuusctand AutomaatZuusctand,
            SictShipCargoTypSictEnum CargoTyp)
        {
            VonSensor.WindowInventoryPrimary ErgeebnisWindowShipInventory;
            VonSensor.Inventory ErgeebnisShipInventory;

            return(ZerleegeShipAktuelOpenInventoryCargoTyp(
                       AutomaatZuusctand,
                       CargoTyp,
                       out ErgeebnisWindowShipInventory,
                       out ErgeebnisShipInventory));
        }
Example #2
0
        /// <summary>
        /// Berecnet anhand der bisherige Entscaidunge zu Atome welce Atome bearbaitet werde sole.
        /// Berecnet zu Atom MengeObjekt.
        /// Berecnet zu Atom Entscaidung Erfolg.
        /// </summary>
        /// <param name="AutomaatZuusctand"></param>
        /// <param name="Strategikon"></param>
        /// <param name="StrategikonInstanz"></param>
        static public void StrategikonInRaumFortscritBerecne(
            SictAutomatZuusctand AutomaatZuusctand,
            SictMissionStrategikon Strategikon,
            SictMissionStrategikonInstanz StrategikonInstanz)
        {
            if (null == Strategikon)
            {
                return;
            }

            if (null == StrategikonInstanz)
            {
                return;
            }

            if (null == AutomaatZuusctand)
            {
                return;
            }

            var ZaitMili = AutomaatZuusctand.NuzerZaitMili;

            var OverviewUndTarget = (null == AutomaatZuusctand) ? null : AutomaatZuusctand.OverviewUndTarget;

            var MengeInRaumObjekt = (null == OverviewUndTarget) ? null : OverviewUndTarget.MengeOverViewObjekt;

            var RaumZuStrategikonAtomZwisceergeebnis = StrategikonInstanz.ZuStrategikonAtomZwisceergeebnis;

            var RaumMengeObjektCargoDurcsuuct = StrategikonInstanz.MengeObjektCargoDurcsuuct;

            var StrategikonRaumMengeZuBezaicnerAtom = Strategikon.RaumMengeZuBezaicnerAtom;

            if (null == StrategikonRaumMengeZuBezaicnerAtom)
            {
                return;
            }

            if (null != RaumZuStrategikonAtomZwisceergeebnis)
            {
                //	Berecnung noi zu beginende Atome

                foreach (var StrategikonRaumZuBezaicnerAtom in StrategikonRaumMengeZuBezaicnerAtom)
                {
                    var InStrategikonAtomBezaicner = StrategikonRaumZuBezaicnerAtom.Key;
                    var StrategikonRaumAtom        = StrategikonRaumZuBezaicnerAtom.Value;

                    if (null == StrategikonRaumAtom)
                    {
                        continue;
                    }

                    var BisherZwisceergeebnis = Optimat.Glob.TAD(RaumZuStrategikonAtomZwisceergeebnis, InStrategikonAtomBezaicner);

                    if (null != BisherZwisceergeebnis)
                    {
                        //	Abarbaitung diises Atom wurde beraits begone.
                        continue;
                    }

                    var BeginMengeBedingungKonjunktAtomBezaicerUndErfolgZait =
                        MengeBedingungAtomBezaicnerUndZaitErfült(StrategikonRaumAtom.MengeBedingungKonjunkt, RaumZuStrategikonAtomZwisceergeebnis);

                    var BeginMengeBedingungDisjunktAtomBezaicerUndErfolgZait =
                        MengeBedingungAtomBezaicnerUndZaitErfült(StrategikonRaumAtom.MengeBedingungDisjunkt, RaumZuStrategikonAtomZwisceergeebnis);

                    var BedingungKonjunktErfült =
                        (null == BeginMengeBedingungKonjunktAtomBezaicerUndErfolgZait)        ?       (bool?)null     :
                        BeginMengeBedingungKonjunktAtomBezaicerUndErfolgZait.All((BedingungKonjunktTail) => BedingungKonjunktTail.Value.HasValue);

                    var BedingungDisjunktErfült =
                        (null == BeginMengeBedingungDisjunktAtomBezaicerUndErfolgZait)        ?       (bool?)null     :
                        BeginMengeBedingungDisjunktAtomBezaicerUndErfolgZait.Any((BedingungKonjunktTail) => BedingungKonjunktTail.Value.HasValue);

                    if ((null == BedingungKonjunktErfült && null == BedingungDisjunktErfült) ||
                        true == BedingungKonjunktErfült || true == BedingungDisjunktErfült)
                    {
                        if (0 == StrategikonRaumZuBezaicnerAtom.Key)
                        {
                            //	Verzwaigung für Haltepunkt (Wurzel Atom werd aingescaltet)
                        }

                        var Zwisceergeebnis = new SictStrategikonInRaumAtomZwisceergeebnis(
                            ZaitMili,
                            BeginMengeBedingungKonjunktAtomBezaicerUndErfolgZait,
                            BeginMengeBedingungDisjunktAtomBezaicerUndErfolgZait);

                        RaumZuStrategikonAtomZwisceergeebnis[InStrategikonAtomBezaicner] = Zwisceergeebnis;
                    }
                }
            }

            if (null != RaumZuStrategikonAtomZwisceergeebnis)
            {
                //	Berecnung welce Atome beraits fertiggesctelt

                foreach (var AtomZwisceergeebnisMitBezaicner in RaumZuStrategikonAtomZwisceergeebnis)
                {
                    var InStrategikonAtomBezaicner = AtomZwisceergeebnisMitBezaicner.Key;
                    var AtomZwisceergeebnis        = AtomZwisceergeebnisMitBezaicner.Value;

                    /*
                     * 2014.03.28
                     *
                     * var InStrategikonAtomSctruktuur = Optimat.Glob.TAD(StrategikonRaumMengeZuBezaicnerAtom, InStrategikonAtomBezaicner);
                     * */
                    var InStrategikonAtomSctruktuur = ExtractFromOldAssembly.Bib3.Extension.FirstOrDefaultNullable(
                        StrategikonRaumMengeZuBezaicnerAtom,
                        (Kandidaat) => Kandidaat.Key == InStrategikonAtomBezaicner).Value;

                    if (null == AtomZwisceergeebnis)
                    {
                        continue;
                    }

                    var InStrategikonAtom = (null == InStrategikonAtomSctruktuur) ? null : InStrategikonAtomSctruktuur.Atom;

                    var MengeAtomZwiscenergeebnisInArbaitParalel = new List <SictStrategikonInRaumAtomZwisceergeebnis>();

                    if (null != InStrategikonAtomSctruktuur)
                    {
                        var MengeBedingungAtomBezaicner = new   List <int>();

                        var InStrategikonAtomSctruktuurMengeBedingungKonjunkt = InStrategikonAtomSctruktuur.MengeBedingungKonjunkt;
                        var InStrategikonAtomSctruktuurMengeBedingungDisjunkt = InStrategikonAtomSctruktuur.MengeBedingungDisjunkt;

                        if (null != InStrategikonAtomSctruktuurMengeBedingungKonjunkt)
                        {
                            MengeBedingungAtomBezaicner.AddRange(InStrategikonAtomSctruktuurMengeBedingungKonjunkt.Select((Bedingung) => Bedingung.Key));
                        }

                        if (null != InStrategikonAtomSctruktuurMengeBedingungDisjunkt)
                        {
                            MengeBedingungAtomBezaicner.AddRange(InStrategikonAtomSctruktuurMengeBedingungDisjunkt.Select((Bedingung) => Bedingung.Key));
                        }

                        foreach (var AtomParalelBezaicner in MengeBedingungAtomBezaicner)
                        {
                            if (AtomParalelBezaicner == AtomZwisceergeebnisMitBezaicner.Key)
                            {
                                //	Selbsct
                                continue;
                            }

                            var AtomParalelZwiscenergeebnis = Optimat.Glob.TAD(RaumZuStrategikonAtomZwisceergeebnis, AtomParalelBezaicner);

                            if (null == AtomParalelZwiscenergeebnis)
                            {
                                continue;
                            }

                            MengeAtomZwiscenergeebnisInArbaitParalel.Add(AtomParalelZwiscenergeebnis);
                        }
                    }

                    var MengeAtomZwiscenergeebnisInArbaitParalelErfolgTailVorMesungObjektGrupe =
                        MengeAtomZwiscenergeebnisInArbaitParalel
                        .Select((AtomParalelZwisceergeebnis) => AtomParalelZwisceergeebnis.ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait)
                        .ToArray();

                    /*
                     * Als Scranke für di Zait zu der zulezt geprüüft werd ob noc zu bearbaitende Objekte vorhande sind werden
                     * von alen Paralel bearbaitete Atome di Zaite entnome zu der jewails in Atom ErfolgTailVorMesungObjektGrupe festgesctelt wurde.
                     *
                     * Diis werd z.B. benöötigt in Mission in der ain Objekt desen Cargo durcsuuct were sol sictbar werd naacdeem aines der zu
                     * zersctöörende Objekte zersctöört wurde. Di Anwaisunge zum zersctööre sind in andere Atom enthalte als di Anwaisunge zum durcsuuce
                     * von Cargo. Über den Parameter MengeObjektGrupeMesungZaitScrankeMin werd di Zait des Erfolg aus ainem AtomZwisceergebnis dan als Scranke
                     * für ale Paralel ausgefüürte Atome übernome.
                     * */
                    Int64?MengeObjektGrupeMesungZaitScrankeMin = Bib3.Glob.Max(MengeAtomZwiscenergeebnisInArbaitParalelErfolgTailVorMesungObjektGrupe);

                    AtomZwisceergeebnis.Aktualisiire(
                        AutomaatZuusctand,
                        StrategikonInstanz,
                        InStrategikonAtom,
                        MengeObjektGrupeMesungZaitScrankeMin);
                }
            }
        }
Example #3
0
        static public SictAufgaabeParamZerleegungErgeebnis ZerleegeShipAktuelOpenInventoryCargoTyp(
            SictAutomatZuusctand AutomaatZuusctand,
            SictShipCargoTypSictEnum CargoTyp,
            out VonSensor.WindowInventoryPrimary ErgeebnisWindowShipInventory,
            out VonSensor.Inventory ErgeebnisShipInventory)
        {
            bool ZerleegungVolsctändig = true;
            var  InternMengeAufgaabeKomponenteParam = new List <SictAufgaabeParam>();

            ErgeebnisWindowShipInventory = null;
            ErgeebnisShipInventory       = null;

            VonSensor.WindowInventoryPrimary ScnapscusShipWindowInventory = null;

            var Gbs = AutomaatZuusctand.Gbs();

            var AusScnapscusAuswertungZuusctand = AutomaatZuusctand.ListeScnapscusLezteAuswertungErgeebnisNaacSimu;

            var AusScnapcusMengeWindowInventory =
                (null == AusScnapscusAuswertungZuusctand) ? null : AusScnapscusAuswertungZuusctand.MengeWindowInventory;

            if (null != AusScnapcusMengeWindowInventory)
            {
                if (1 == AusScnapcusMengeWindowInventory.Length)
                {
                    var KandidaatAnforderungLeereCargoWindowInventory = AusScnapcusMengeWindowInventory.FirstOrDefault();

                    if (null != KandidaatAnforderungLeereCargoWindowInventory)
                    {
                        if (null != KandidaatAnforderungLeereCargoWindowInventory.LinxTreeEntryActiveShip)
                        {
                            ScnapscusShipWindowInventory = KandidaatAnforderungLeereCargoWindowInventory;
                        }
                    }
                }
            }

            var ScnapscusShipWindowInventoryLinxTreeEntryActiveShip =
                (null == ScnapscusShipWindowInventory) ? null : ScnapscusShipWindowInventory.LinxTreeEntryActiveShip;

            if (null == ScnapscusShipWindowInventory)
            {
                ZerleegungVolsctändig = false;

                var NeocomButtonInventory = AusScnapscusAuswertungZuusctand.NeocomButtonInventory;

                if (null == NeocomButtonInventory)
                {
                }
                else
                {
                    InternMengeAufgaabeKomponenteParam.Add(AufgaabeParamAndere.KonstruktMausPfaad(SictAufgaabeParamMausPfaad.KonstruktMausKlikLinx(NeocomButtonInventory)));
                }
            }
            else
            {
                var WindowInventoryZuusctand =
                    (null == Gbs) ? null :
                    Gbs.ZuHerkunftAdreseWindow(ScnapscusShipWindowInventory.Ident);

                if (null == ScnapscusShipWindowInventoryLinxTreeEntryActiveShip)
                {
                }
                else
                {
                    var ZuCargoTypTreeEntry =
                        ScnapscusShipWindowInventoryLinxTreeEntryActiveShip.TreeEntryBerecneAusCargoTyp(CargoTyp);

                    var ZuAuswaalReczMengeKandidaatLinxTreeEntry = ScnapscusShipWindowInventory.ZuAuswaalReczMengeKandidaatLinxTreeEntry;

                    if (null == ZuCargoTypTreeEntry)
                    {
                        //	Sicersctele das AnforderungLeereCargoWindowInventoryLinxTreeEntryActiveShip expanded.

                        if (0 < ExtractFromOldAssembly.Bib3.Extension.CountNullable(ScnapscusShipWindowInventoryLinxTreeEntryActiveShip.MengeChild))
                        {
                            //	ist beraits Expanded.
                        }
                        else
                        {
                            var ExpandCollapseToggleFläce = ScnapscusShipWindowInventoryLinxTreeEntryActiveShip.ExpandCollapseToggleFläce;

                            if (null == ExpandCollapseToggleFläce)
                            {
                            }
                            else
                            {
                                InternMengeAufgaabeKomponenteParam.Add(AufgaabeParamAndere.KonstruktMausPfaad(
                                                                           SictAufgaabeParamMausPfaad.KonstruktMausKlikLinx(ExpandCollapseToggleFläce)));
                            }
                        }
                    }
                    else
                    {
                        if (1 == ExtractFromOldAssembly.Bib3.Extension.CountNullable(ZuAuswaalReczMengeKandidaatLinxTreeEntry))
                        {
                            var ZuAuswaalReczLinxTreeEntry = ZuAuswaalReczMengeKandidaatLinxTreeEntry.FirstOrDefault();
                            var AuswaalReczInventory       = ScnapscusShipWindowInventory.AuswaalReczInventory;

                            if (ZuCargoTypTreeEntry == ZuAuswaalReczLinxTreeEntry &&
                                null != AuswaalReczInventory)
                            {
                                //	Erfolg.

                                ErgeebnisWindowShipInventory = ScnapscusShipWindowInventory;
                                ErgeebnisShipInventory       = AuswaalReczInventory;
                            }
                            else
                            {
                                InternMengeAufgaabeKomponenteParam.Add(AufgaabeParamAndere.KonstruktMausPfaad(
                                                                           SictAufgaabeParamMausPfaad.KonstruktMausKlikLinx(ZuCargoTypTreeEntry.TopContLabel)));
                            }
                        }
                    }
                }
            }

            return(new SictAufgaabeParamZerleegungErgeebnis(InternMengeAufgaabeKomponenteParam, ZerleegungVolsctändig));
        }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="AutomaatZuusctand"></param>
        /// <param name="StrategikonInstanz"></param>
        /// <param name="InStrategikonAtom"></param>
        /// <param name="MengeObjektGrupeMesungZaitScrankeMin">
        /// Früheste Zait zu der dii Mesung der Objekt Grupe zum ausscliise der Existenz noc zu bearbaitender Objekte begine darf.</param>
        public void Aktualisiire(
            SictAutomatZuusctand AutomaatZuusctand,
            SictMissionStrategikonInstanz StrategikonInstanz,
            SictMissionStrategikonInRaumAtom InStrategikonAtom,
            Int64?MengeObjektGrupeMesungZaitScrankeMin)
        {
            this.MengeObjektGrupeMesungZaitScrankeMin = MengeObjektGrupeMesungZaitScrankeMin;

            var AtomZwisceergeebnis = this;

            if (null == AutomaatZuusctand)
            {
                return;
            }

            if (null == StrategikonInstanz)
            {
                return;
            }

            var ZaitMili = AutomaatZuusctand.NuzerZaitMili;

            var RaumMengeObjektCargoDurcsuuct = StrategikonInstanz.MengeObjektCargoDurcsuuct;

            var OverviewUndTarget = (null == AutomaatZuusctand) ? null : AutomaatZuusctand.OverviewUndTarget;

            var MengeInRaumObjekt = (null == OverviewUndTarget) ? null : OverviewUndTarget.MengeOverViewObjekt;

            Int64?ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait = null;

            SictOverviewObjektGrupeEnum[] ZuMengeObjektGrupeMesungVolsctändigFeelend = null;
            var   AtomZwisceergeebnisErfolg = false;
            Int64?MesungMengeObjektGrupeZaitScrankeMinPlusBeruhigungszait = null;

            try
            {
                if (null == InStrategikonAtom)
                {
                    AtomZwisceergeebnisErfolg = true;
                    return;
                }

                if (null == MengeInRaumObjekt)
                {
                    return;
                }

                var InStrategikonAtomMengeObjektFilter = InStrategikonAtom.MengeObjektFilter;

                var InStrategikonAtomMengeObjektFilterGrupe =
                    (null == InStrategikonAtomMengeObjektFilter) ? null :
                    Bib3.Glob.ArrayAusListeFeldGeflact(
                        InStrategikonAtomMengeObjektFilter.Select((ObjektFilter) =>
                {
                    var BedingungTypeUndName = ObjektFilter.BedingungTypeUndName;

                    if (null == BedingungTypeUndName)
                    {
                        return(null);
                    }

                    return(BedingungTypeUndName.MengeGrupeZuDurcsuuce);
                })
                        .Where((Kandidaat) => null != Kandidaat))
                    .Distinct()
                    .ToArray();

                var MengeObjektGefiltert = MengeInRaumObjektGefiltert(MengeInRaumObjekt, InStrategikonAtomMengeObjektFilter);

                var MengeObjektGefiltertNocSictbar =
                    (null == MengeObjektGefiltert) ? null :
                    MengeObjektGefiltert.Where((OverViewObjekt) => ZaitMili <= OverViewObjekt.SictungLezteZait).ToArray();

                var BedingungObjektExistentErfült = false;

                SictOverViewObjektZuusctand[] MengeObjektCargoZuDurcsuuce = null;
                SictOverViewObjektZuusctand[] MengeObjektZuZersctööre     = null;
                KeyValuePair <SictOverViewObjektZuusctand, Int64>?ObjektAnzufliigeUndDistanceScranke = null;

                var FilterCargoZuDurcsuuce =
                    new Func <SictOverViewObjektZuusctand, bool>((InRaumObjekt) => SictMissionZuusctand.FilterCargoZuDurcsuuce(InRaumObjekt, RaumMengeObjektCargoDurcsuuct));

                if (!(true == InStrategikonAtom.BedingungObjektExistent) ||
                    !MengeObjektGefiltertNocSictbar.IsNullOrEmpty())
                {
                    BedingungObjektExistentErfült = true;
                }

                var InStrategikonAtomZuObjektDistanzAinzuscteleScrankeMax = InStrategikonAtom.ZuObjektDistanzAinzuscteleScrankeMax;

                if (null != MengeObjektGefiltert)
                {
                    if (true == InStrategikonAtom.ObjektDurcsuuceCargo)
                    {
                        MengeObjektCargoZuDurcsuuce = MengeObjektGefiltert.Where(FilterCargoZuDurcsuuce).ToArray();
                    }

                    if (true == InStrategikonAtom.ObjektZersctööre)
                    {
                        MengeObjektZuZersctööre = MengeObjektGefiltert;
                    }

                    if (InStrategikonAtomZuObjektDistanzAinzuscteleScrankeMax.HasValue)
                    {
                        var MengeObjektGefiltertDistanceNitPasend =
                            MengeObjektGefiltert.Where((InRaumObjekt) => !(InRaumObjekt.SictungLezteDistanceScrankeMaxScpezOverview <= InStrategikonAtomZuObjektDistanzAinzuscteleScrankeMax.Value)).ToArray();

                        if (0 < MengeObjektGefiltertDistanceNitPasend.Length)
                        {
                            ObjektAnzufliigeUndDistanceScranke = new KeyValuePair <SictOverViewObjektZuusctand, Int64>(
                                MengeObjektGefiltertDistanceNitPasend.FirstOrDefault(), InStrategikonAtomZuObjektDistanzAinzuscteleScrankeMax.Value);
                        }
                    }
                }

                var AtomZwisceergeebnisMengeAufgaabeObjektZuBearbaite = new List <SictAufgaabeParam>();

                if (ObjektAnzufliigeUndDistanceScranke.HasValue)
                {
                    if (null != ObjektAnzufliigeUndDistanceScranke.Value.Key)
                    {
                        AtomZwisceergeebnisMengeAufgaabeObjektZuBearbaite.Add(
                            AufgaabeParamAndere.AufgaabeDistanceAinzusctele(
                                ObjektAnzufliigeUndDistanceScranke.Value.Key, null, ObjektAnzufliigeUndDistanceScranke.Value.Value));
                    }
                }

                if (null != MengeObjektCargoZuDurcsuuce)
                {
                    AtomZwisceergeebnisMengeAufgaabeObjektZuBearbaite.AddRange(
                        MengeObjektCargoZuDurcsuuce.Select((InRaumObjekt) => AufgaabeParamAndere.AufgaabeAktioonCargoDurcsuuce(InRaumObjekt)));
                }

                if (null != MengeObjektZuZersctööre)
                {
                    AtomZwisceergeebnisMengeAufgaabeObjektZuBearbaite.AddRange(
                        MengeObjektZuZersctööre.Select((InRaumObjekt) => new AufgaabeParamDestrukt(InRaumObjekt)));
                }

                AtomZwisceergeebnis.MengeAufgaabeObjektZuBearbaite = AtomZwisceergeebnisMengeAufgaabeObjektZuBearbaite.ToArray();

                if (MengeObjektCargoZuDurcsuuce.IsNullOrEmpty())
                {
                    if (!AtomZwisceergeebnis.CargoDurcsuuceErfolgZait.HasValue)
                    {
                        AtomZwisceergeebnis.CargoDurcsuuceErfolgZait = ZaitMili;
                    }
                }
                else
                {
                    AtomZwisceergeebnis.CargoDurcsuuceErfolgZait = null;
                }

                if (MengeObjektZuZersctööre.IsNullOrEmpty())
                {
                    if (!AtomZwisceergeebnis.ZersctööreErfolgZait.HasValue)
                    {
                        AtomZwisceergeebnis.ZersctööreErfolgZait = ZaitMili;
                    }
                }
                else
                {
                    AtomZwisceergeebnis.ZersctööreErfolgZait = null;
                }

                if (ObjektAnzufliigeUndDistanceScranke.HasValue)
                {
                    AtomZwisceergeebnis.AnfliigeErfolgZait = null;
                }
                else
                {
                    if (!AtomZwisceergeebnis.AnfliigeErfolgZait.HasValue)
                    {
                        AtomZwisceergeebnis.AnfliigeErfolgZait = ZaitMili;
                    }
                }

                if (BedingungObjektExistentErfült)
                {
                    if (!AtomZwisceergeebnis.ObjektExistentErfolgZait.HasValue)
                    {
                        AtomZwisceergeebnis.ObjektExistentErfolgZait = ZaitMili;
                    }
                }
                else
                {
                    AtomZwisceergeebnis.ObjektExistentErfolgZait = null;
                }

                var ScritBedingungErfültBeruhigungszaitMili = InStrategikonAtom.ScritBedingungErfültBeruhigungszaitMili ?? 1000;

                var AtomZwisceergeebnisMengeScpezielErfültZaitNulbar = new Int64?[] {
                    AtomZwisceergeebnis.CargoDurcsuuceErfolgZait,
                    AtomZwisceergeebnis.ZersctööreErfolgZait,
                    AtomZwisceergeebnis.AnfliigeErfolgZait,
                    AtomZwisceergeebnis.ObjektExistentErfolgZait
                };

                if (AtomZwisceergeebnisMengeScpezielErfültZaitNulbar.Any((ScpezielErfültZaitNulbar) => !ScpezielErfültZaitNulbar.HasValue))
                {
                    //	Aine der Scpezialisiirte Aufgaabe isc noc nit erfült.
                    return;
                }

                ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait =
                    Bib3.Glob.Max(AtomZwisceergeebnisMengeScpezielErfültZaitNulbar) ?? 0;

                var MesungMengeObjektGrupeZaitScrankeMin =
                    Bib3.Glob.Max(ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait, MengeObjektGrupeMesungZaitScrankeMin) ?? 0;

                MesungMengeObjektGrupeZaitScrankeMinPlusBeruhigungszait =
                    MesungMengeObjektGrupeZaitScrankeMin + ScritBedingungErfültBeruhigungszaitMili;

                ZuMengeObjektGrupeMesungVolsctändigFeelend =
                    OverviewUndTarget.MengeObjektGrupeUntermengeOoneOverviewViewportFolgeVolsctändigNaacZait(
                        InStrategikonAtomMengeObjektFilterGrupe,
                        MesungMengeObjektGrupeZaitScrankeMin);

                if (!ZuMengeObjektGrupeMesungVolsctändigFeelend.IsNullOrEmpty())
                {
                    //	Verzwaigung Für Debug Haltepunkt
                }

                if (MesungMengeObjektGrupeZaitScrankeMinPlusBeruhigungszait < ZaitMili)
                {
                    /*
                     * 2014.06.12
                     *
                     * Korektur: Versciibe diise Blok naac finally um überscraibe des vorherige Wert mit null zu ermööglice fals try Blok scon vorher unterbroce werd.
                     *
                     * AtomZwisceergeebnis.MengeOverviewObjektGrupeMesungZuErsctele = ZuMengeObjektGrupeMesungVolsctändigFeelend;
                     *
                     * //	if (ZuMengeObjektGrupeMesungVolsctändigFeelend.Length < 1)
                     * if (Optimat.Glob.NullOderLeer(ZuMengeObjektGrupeMesungVolsctändigFeelend))
                     * {
                     *      AtomZwisceergeebnisErfolg = true;
                     * }
                     * */
                }
            }
            finally
            {
                AtomZwisceergeebnis.MengeOverviewObjektGrupeMesungZuErsctele = ZuMengeObjektGrupeMesungVolsctändigFeelend;

                /*
                 * 2014.07.10	Korektur: zuusäzlice Bedingung:
                 * MesungMengeObjektGrupeZaitScrankeMinPlusBeruhigungszait < ZaitMili
                 *
                 * //	if (ZuMengeObjektGrupeMesungVolsctändigFeelend.Length < 1)
                 * if (Optimat.Glob.NullOderLeer(ZuMengeObjektGrupeMesungVolsctändigFeelend))
                 * {
                 *      AtomZwisceergeebnisErfolg = true;
                 * }
                 * */

                if (MesungMengeObjektGrupeZaitScrankeMinPlusBeruhigungszait < ZaitMili)
                {
                    if (ZuMengeObjektGrupeMesungVolsctändigFeelend.IsNullOrEmpty())
                    {
                        AtomZwisceergeebnisErfolg = true;
                    }
                }

                AtomZwisceergeebnis.ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait =
                    ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait;

                if (ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait.HasValue)
                {
                    AtomZwisceergeebnis.ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZaitLezte = ErfolgTailVorMengeOverviewObjektGrupeMesungZuErscteleZait;
                }

                if (AtomZwisceergeebnisErfolg)
                {
                    AtomZwisceergeebnis.EntscaidungErfolgLezteZait = ZaitMili;
                }
                else
                {
                    AtomZwisceergeebnis.EntscaidungErfolgLezteZait = null;
                }

                AtomZwisceergeebnis.AktualisiireTailEntscaidungErfolgFrühesteZait();
            }
        }
Example #5
0
        public void Aktualisiire(
            SictAutomatZuusctand AutomaatZuusctand,
            VonSensorikMesung AusScnapscusAuswertungZuusctand)
        {
            if (null == AutomaatZuusctand)
            {
                return;
            }

            var AgregatioonAusTransitionInfo = this.AgregatioonAusTransitionInfo;

            var ZaitMili = AutomaatZuusctand.NuzerZaitMili;

            var OverviewUndTarget = AutomaatZuusctand.OverviewUndTarget;

            /*
             * 2015.03.12
             *
             * Ersaz durc ToCustomBotSnapshot
             *      var GbsBaum = AutomaatZuusctand.VonNuzerMeldungZuusctandTailGbsBaum;
             * */

            var GbsBaum = AutomaatZuusctand.ListeScnapscusLezteAuswertungErgeebnisNaacSimu;

            var MengeWindow = this.MengeWindow;
            var ListeAbovemainMessageAuswertMitZait = this.ListeAbovemainMessageAuswertMitZait;

            var ScnapscusWindowOverview = (null == AusScnapscusAuswertungZuusctand) ? null : AusScnapscusAuswertungZuusctand.WindowOverview;

            var NeocomClockZaitKalenderModuloTaagStringUndMinMax = (null == AusScnapscusAuswertungZuusctand) ? null :
                                                                   AusScnapscusAuswertungZuusctand.NeocomClockZaitKalenderModuloTaagMinMax;

            var ScnapscusWindowOverviewZaileInputFookusExklusiiv = (null == ScnapscusWindowOverview) ? null : ScnapscusWindowOverview.ZaileMitInputFookusExklusiiv();

            var ScnapscusMengeWindow = (null == AusScnapscusAuswertungZuusctand) ? null :
                                       AusScnapscusAuswertungZuusctand.MengeWindowBerecne();

            var ScnapscusMengeWindowSictbar =
                ExtractFromOldAssembly.Bib3.Extension.WhereNullable(ScnapscusMengeWindow, (Kandidaat) => null == Kandidaat ? false : (true == Kandidaat.Sictbar))
                .ToArrayNullable();

            var ScnapscusMengeMenu = (null == AusScnapscusAuswertungZuusctand) ? null : AusScnapscusAuswertungZuusctand.MengeMenu;

            if (null == AgregatioonAusTransitionInfo)
            {
                this.AgregatioonAusTransitionInfo = AgregatioonAusTransitionInfo = new SictGbsAgregatioonAusTransitionInfo();
            }

            AgregatioonAusTransitionInfo.Agregiire(AutomaatZuusctand);

            if (null == MengeWindow)
            {
                this.MengeWindow = MengeWindow = new List <SictGbsWindowZuusctand>();
            }

            if (NeocomClockZaitKalenderModuloTaagStringUndMinMax.HasValue)
            {
                this.NeocomClockZaitModuloTaagMinMax = NeocomClockZaitKalenderModuloTaagStringUndMinMax.Value;
            }

            var ListeAusGbsAbovemainMessageMitZait = AutomaatZuusctand.ListeAusGbsAbovemainMessageMitZait();

            var ListeAusGbsAbovemainMessageMitZaitLezte =
                (null == ListeAusGbsAbovemainMessageMitZait) ? null : ListeAusGbsAbovemainMessageMitZait.LastOrDefault();

            if (null != AusScnapscusAuswertungZuusctand)
            {
                if (null != AusScnapscusAuswertungZuusctand.InfoPanelLocationInfo)
                {
                    InfoPanelLocationInfoSictbarLezteZaitMili = ZaitMili;
                }

                if (null != AusScnapscusAuswertungZuusctand.InfoPanelRoute)
                {
                    InfoPanelRouteSictbarLezteZaitMili = ZaitMili;
                }

                if (null != AusScnapscusAuswertungZuusctand.InfoPanelMissions)
                {
                    InfoPanelMissionsSictbarLezteZaitMili = ZaitMili;
                }
            }

            SictGbsWindowZuusctand.ZuZaitAingangMengeObjektScnapscus(
                ZaitMili,
                ScnapscusMengeWindowSictbar,
                MengeWindow,
                false,
                AgregatioonAusTransitionInfo);

            {
                //	Window entferne welce zu lange nit meer geöfnet sind.
                MengeWindow.RemoveAll((Kandidaat) => !Kandidaat.InLezteScnapscusSictbar());
            }

            {
                var MengeWindowGrupe = MengeWindow.GroupBy((Kandidaat) => Kandidaat.GbsAstHerkunftAdrese).ToArray();

                if (MengeWindowGrupe.Any((Grupe) => 1 < Grupe.Count()))
                {
                    //	Temp für Debug Verzwaigung
                }
            }

            {
                //	Berecnung	ListeAbovemainMessageAuswertMitZait

                if (null != ListeAusGbsAbovemainMessageMitZaitLezte)
                {
                    var ListeAusGbsAbovemainMessageLezte = ListeAusGbsAbovemainMessageMitZaitLezte.Wert;

                    var ListeAusGbsAbovemainMessageLezteText = ListeAusGbsAbovemainMessageLezte.LabelText;

                    if (null != ListeAusGbsAbovemainMessageLezteText)
                    {
                        if (null != ListeAusGbsAbovemainMessageLezte)
                        {
                            if (null == ListeAbovemainMessageAuswertMitZait)
                            {
                                this.ListeAbovemainMessageAuswertMitZait = ListeAbovemainMessageAuswertMitZait =
                                    new List <SictVerlaufBeginUndEndeRef <SictMessageStringAuswert> >();
                            }

                            SictVerlaufBeginUndEndeRef <SictMessageStringAuswert> AbovemainMessageAuswertMitZait =
                                ListeAbovemainMessageAuswertMitZait
                                .LastOrDefault((Kandidaat) => Kandidaat.BeginZait == ListeAusGbsAbovemainMessageMitZaitLezte.BeginZait);

                            if (null == AbovemainMessageAuswertMitZait)
                            {
                                var AbovemainMessageAuswert = new SictMessageStringAuswert(ListeAusGbsAbovemainMessageLezteText);

                                AbovemainMessageAuswertMitZait = new SictVerlaufBeginUndEndeRef <SictMessageStringAuswert>(
                                    ListeAusGbsAbovemainMessageMitZaitLezte.BeginZait,
                                    ListeAusGbsAbovemainMessageMitZaitLezte.EndeZait,
                                    AbovemainMessageAuswert);

                                AbovemainMessageAuswert.Berecne();

                                ListeAbovemainMessageAuswertMitZait.Add(AbovemainMessageAuswertMitZait);

                                if (AbovemainMessageAuswert.ClusterShutdownZaitDistanz.HasValue)
                                {
                                    AbovemainMessageClusterShutdownLezte = AbovemainMessageAuswertMitZait;
                                }
                            }
                        }
                    }
                }
            }

            ListeAbovemainMessageDronesLezteAuswertMitZait =
                ListeAbovemainMessageAuswertMitZait
                .LastOrDefaultNullable((Kandidaat) =>
                                       null == Kandidaat.Wert ? false :
                                       (Kandidaat.Wert.DroneBandwithAvailableMili.HasValue ||
                                        Kandidaat.Wert.DroneCommandRange.HasValue ||
                                        Kandidaat.Wert.DroneControlCountScrankeMax.HasValue));

            ListeAbovemainMessageDronesLezteAlter =
                ZaitMili - (null == ListeAbovemainMessageDronesLezteAuswertMitZait ? (Int64?)null : (ListeAbovemainMessageDronesLezteAuswertMitZait.EndeZait ?? ZaitMili));

            if (null != ListeAbovemainMessageAuswertMitZait)
            {
                foreach (var AbovemainMessageAuswertMitZait in ListeAbovemainMessageAuswertMitZait.Reversed().Take(4))
                {
                    if (AbovemainMessageAuswertMitZait.EndeZait.HasValue)
                    {
                        continue;
                    }

                    var AbovemainMessageMitZait =
                        ExtractFromOldAssembly.Bib3.Extension.FirstOrDefaultNullable(
                            ListeAusGbsAbovemainMessageMitZait,
                            (Kandidaat) => Kandidaat.BeginZait == AbovemainMessageAuswertMitZait.BeginZait);

                    if (null == AbovemainMessageMitZait)
                    {
                        AbovemainMessageAuswertMitZait.EndeZait = ZaitMili;
                    }
                    else
                    {
                        AbovemainMessageAuswertMitZait.EndeZait = AbovemainMessageMitZait.EndeZait;
                    }
                }

                {
                    //	Naacricte welce älter sind als Viir minuute entferne

                    var ListeAbovemainMessageAuswertMitZaitZuErhalteZaitScranke = ZaitMili - 1000 * 60 * 4;

                    ListeAbovemainMessageAuswertMitZait
                    .RemoveAll((Kandidaat) => Kandidaat.BeginZait < ListeAbovemainMessageAuswertMitZaitZuErhalteZaitScranke);
                }
            }

            {
                //	Berecnung ListeGbsMenu

                //	Menge Menu werd geordnet für den Fal das in aine Scnapscus meerere Menu auftauce
                //	2014.02.27	Beobactung: lezte Menu erhält 0=InGbsZIndex -> noieste isc am waiteste vorne (okludiirt andere)

                var ScnapscusListeMenu =
                    (null == ScnapscusMengeMenu) ? null :
                    ScnapscusMengeMenu

                    /*
                     * 2015.09.01
                     * Änderung InGbsBaumAstIndex: Übernaame von noie Sensor InTreeIndex: Element occludes other Elements with lower Value.
                     *
                     * .OrderByDescending((ScnapscusMenu) => ScnapscusMenu.InGbsBaumAstIndex ?? -1)
                     */
                    .OrderBy((ScnapscusMenu) => ScnapscusMenu.InGbsBaumAstIndex ?? -1)
                    .ToArray();

                var ScnapscusListeMenuFrüüheste =
                    ExtractFromOldAssembly.Bib3.Extension.FirstOrDefaultNullable(ScnapscusListeMenu);

                var ScnapscusListeMenuFrüühesteListeEntry =
                    (null == ScnapscusListeMenuFrüüheste) ? null :
                    ScnapscusListeMenuFrüüheste.ListeEntry;

                var MenuKaskaadeLezte = ExtractFromOldAssembly.Bib3.Extension.LastOrDefaultNullable(ListeMenuKaskaade);

                if (null == ScnapscusListeMenuFrüühesteListeEntry)
                {
                    if (null != MenuKaskaadeLezte)
                    {
                        MenuKaskaadeLezte.AingangScnapscusLeer(ZaitMili);
                    }

                    MenuKaskaadeLezte = null;
                }
                else
                {
                    GbsElement MenuWurzelAnnaameInitiaal = null;

                    var MengeAufgaabeZuusctand = AutomaatZuusctand.MengeAufgaabeZuusctand;

                    var ScritLezteWirkungMengeAufgaabePfaadZuBlatMitGrupePrioNaame =
                        AutomaatZuusctand.ScritLezteWirkungMengeAufgaabePfaadZuBlatMitGrupePrioNaame
                        .ToArrayNullable();

                    if (null != ScritLezteWirkungMengeAufgaabePfaadZuBlatMitGrupePrioNaame)
                    {
                        foreach (var ScritLezteWirkungAufgaabePfaadZuBlatMitGrupePrioNaame in ScritLezteWirkungMengeAufgaabePfaadZuBlatMitGrupePrioNaame)
                        {
                            if (null == ScritLezteWirkungAufgaabePfaadZuBlatMitGrupePrioNaame.Key)
                            {
                                continue;
                            }

                            foreach (var AufgaabeAst in ScritLezteWirkungAufgaabePfaadZuBlatMitGrupePrioNaame.Key)
                            {
                                var AufgaabeAstAufgaabeParam = AufgaabeAst.AufgaabeParam as AufgaabeParamAndere;

                                if (null == AufgaabeAstAufgaabeParam)
                                {
                                    continue;
                                }

                                var AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt = AufgaabeAstAufgaabeParam.MenuWurzelGbsObjekt;

                                if (null == AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt)
                                {
                                    continue;
                                }

                                var AufgaabeAstAufgaabeParamMenuWurzelGbsObjektIdentNulbar = (Int64?)AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt.Ident;

                                if (!AufgaabeAstAufgaabeParamMenuWurzelGbsObjektIdentNulbar.HasValue)
                                {
                                    continue;
                                }

                                var AufgaabeAstAufgaabeParamMenuWurzelGbsObjektIdent = AufgaabeAstAufgaabeParamMenuWurzelGbsObjektIdentNulbar.Value;

                                var AufgaabeAstAufgaabeParamMenuWurzelGbsObjektFläce = AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt.InGbsFläce;

                                if (null == AufgaabeAstAufgaabeParamMenuWurzelGbsObjektFläce)
                                {
                                    continue;
                                }

                                var AufgaabeAstAufgaabeParamMenuWurzelGbsObjektFläceVergröösertFürTestÜberscnaidung =
                                    AufgaabeAstAufgaabeParamMenuWurzelGbsObjektFläce.Vergröösert(40, 10);

                                var ScnapscusAufgaabeMenuWurzelTarget      = AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt as ShipUiTarget;
                                var ScnapscusAufgaabeMenuWurzelOverviewRow =
                                    (GbsElement)(AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt as VonSensor.OverviewZaile);

                                bool AnnaameMenuPasendZuAusAufgaabeMenuWurzel = true;

                                var ScnapscusLezteMenuWurzelGbsObjektTarget =
                                    AusScnapscusAuswertungZuusctand.TargetEnthaltendGbsAstBerecne(AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt);

                                var ScnapscusLezteMenuWurzelGbsObjektOverviewRow = (null == ScnapscusWindowOverview) ? null :
                                                                                   ScnapscusWindowOverview.OverviewRowEnthaltendGbsAstBerecne(AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt);

                                {
                                    /*
                                     * 2014.04.22	Beobactung Probleem:
                                     * In vorherige Scrit für OverviewZaile geöfnete Menu werd waiterverwendet als Menu welces für ain in Inventory angezaigte Objekt ersctelt werde solte.
                                     * In Folge werd der falsce Cargo Container Abandoned.
                                     *
                                     * Daher Ainfüürung zuusäzlice Bedingung:
                                     * Menu früheste Fläce mus überscnaide mit MenuWurzelGbsObjektAbbild.Fläce
                                     * */

                                    //	Bedingung: Fläce von ScnapscusAufgaabeMenuWurzelTarget und Menu müsen sic scnaide

                                    if (OrtogoonInt.Scnitfläce(
                                            AufgaabeAstAufgaabeParamMenuWurzelGbsObjektFläceVergröösertFürTestÜberscnaidung,
                                            ScnapscusListeMenuFrüüheste.InGbsFläce).IsLeer)
                                    {
                                        AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                    }
                                }

                                {
                                    /*
                                     * 2014.04.22	Beobactung Probleem:
                                     * In vorherige Scrit für OverviewZaile geöfnete Menu werd waiterverwendet als Menu welces für ain in Inventory angezaigte Objekt ersctelt werde solte.
                                     * In Folge werd der falsce Cargo Container Abandoned.
                                     *
                                     * Daher 2014.04.29 Ainfüürung zuusäzlice Bedingung:
                                     * Fals MenuWurzelGbsObjekt in aine Window enthalte isc mus diises das vorderste Window sain.
                                     * */

                                    if (null == GbsBaum ||
                                        null == MengeWindow)
                                    {
                                        AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                    }
                                    else
                                    {
                                        SictGbsWindowZuusctand MenuWurzelGbsObjektWindow = null;

                                        foreach (var KandidaatGbsWindow in MengeWindow)
                                        {
                                            var GbsWindowHerkunftAdrese = KandidaatGbsWindow.GbsAstHerkunftAdrese;

                                            if (!GbsWindowHerkunftAdrese.HasValue)
                                            {
                                                continue;
                                            }

                                            var GbsWindowAst = GbsBaum.SuuceFlacMengeGbsAstFrühesteMitIdent(GbsWindowHerkunftAdrese.Value);

                                            if (null == GbsWindowAst)
                                            {
                                                continue;
                                            }

                                            if (null != GbsWindowAst.SuuceFlacMengeGbsAstFrühesteMitIdent(AufgaabeAstAufgaabeParamMenuWurzelGbsObjektIdent))
                                            {
                                                MenuWurzelGbsObjektWindow = KandidaatGbsWindow;
                                            }
                                        }

                                        if (null != MenuWurzelGbsObjektWindow)
                                        {
                                            /*
                                             * 2015.09.01
                                             * Änderung InGbsBaumAstIndex: Übernaame von noie Sensor InTreeIndex: Element occludes other Elements with lower Value.
                                             *                                              if (MengeWindow.Any((GbsWindow) => GbsWindow.ZIndex.HasValue && GbsWindow.ZIndex < (MenuWurzelGbsObjektWindow.ZIndex ?? int.MaxValue)))
                                             */
                                            if (MengeWindow.Any((GbsWindow) => GbsWindow.ZIndex.HasValue && GbsWindow.ZIndex > (MenuWurzelGbsObjektWindow.ZIndex ?? int.MaxValue)))
                                            {
                                                //	Ain anderes Window befindet sic waiter vorne als das Window welces MenuWurzelGbsObjekt enthalt.
                                                AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                            }
                                        }
                                    }
                                }

                                if (null != ScnapscusAufgaabeMenuWurzelTarget)
                                {
                                    if (null == ScnapscusLezteMenuWurzelGbsObjektTarget)
                                    {
                                        AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                    }
                                    else
                                    {
                                        if (null == ScnapscusAufgaabeMenuWurzelTarget.InGbsFläce ||
                                            null == ScnapscusLezteMenuWurzelGbsObjektTarget.InGbsFläce)
                                        {
                                            AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                        }
                                        else
                                        {
                                            var BeweegungSctreke =
                                                ScnapscusLezteMenuWurzelGbsObjektTarget.InGbsFläce.ZentrumLaage -
                                                ScnapscusAufgaabeMenuWurzelTarget.InGbsFläce.ZentrumLaage;

                                            if (!(BeweegungSctreke.Betraag < 4))
                                            {
                                                //	Target solte zwisce deen zwai Scnapscus nit beweegt haabe.
                                                AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                            }
                                        }

                                        var KandidaatMenuEntryIndikatorTarget = ScnapscusListeMenuFrüühesteListeEntry.MenuEntryTargetUnLock();

                                        if (null == KandidaatMenuEntryIndikatorTarget)
                                        {
                                            AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                        }
                                    }
                                }

                                if (null != ScnapscusAufgaabeMenuWurzelOverviewRow)
                                {
                                    if (null == ScnapscusLezteMenuWurzelGbsObjektOverviewRow)
                                    {
                                        AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                    }
                                    else
                                    {
                                        if (!(ObjektMitIdentInt64.Identisc(ScnapscusLezteMenuWurzelGbsObjektOverviewRow, ScnapscusWindowOverviewZaileInputFookusExklusiiv)))
                                        {
                                            AnnaameMenuPasendZuAusAufgaabeMenuWurzel = false;
                                        }
                                    }
                                }

                                if (!AnnaameMenuPasendZuAusAufgaabeMenuWurzel)
                                {
                                    continue;
                                }

                                MenuWurzelAnnaameInitiaal = AufgaabeAstAufgaabeParamMenuWurzelGbsObjekt;
                            }
                        }
                    }

                    Action MenuKaskaadeKonstrukt = delegate()
                    {
                        MenuKaskaadeLezte = new SictGbsMenuKaskaadeZuusctand(
                            ZaitMili,
                            ScritLezteWirkungMengeAufgaabePfaadZuBlatMitGrupePrioNaame,
                            MenuWurzelAnnaameInitiaal,
                            ScnapscusListeMenu);
                        ListeMenuKaskaade.Enqueue(MenuKaskaadeLezte);
                    };

                    if (null == MenuKaskaadeLezte)
                    {
                        /*
                         * 2015.01.16
                         *
                         * MenuKaskaadeLezte = new SictGbsMenuKaskaadeZuusctand(ZaitMili, MenuWurzelAnnaameInitiaal, ScnapscusListeMenu);
                         * ListeMenuKaskaade.Enqueue(MenuKaskaadeLezte);
                         * */
                        MenuKaskaadeKonstrukt();
                    }
                    else
                    {
                        if (!MenuKaskaadeLezte.AingangScnapscus(ZaitMili, ScnapscusListeMenu))
                        {
                            /*
                             * 2015.01.16
                             *
                             * MenuKaskaadeLezte = new SictGbsMenuKaskaadeZuusctand(ZaitMili, MenuWurzelAnnaameInitiaal, ScnapscusListeMenu);
                             * ListeMenuKaskaade.Enqueue(MenuKaskaadeLezte);
                             * */
                            MenuKaskaadeKonstrukt();
                        }
                    }
                }

                ListeMenuKaskaade.ListeKürzeBegin(30);

                var ListeMenu =
                    (null == MenuKaskaadeLezte) ? null :
                    MenuKaskaadeLezte.ListeMenu;

                var AusButtonListSurroundingsMenu =
                    ExtractFromOldAssembly.Bib3.Extension.FirstOrDefaultNullable(
                        ListeMenu, ButtonListSurroundingsMenuPrädikaatTailSctaatisc);

                if (null != AusButtonListSurroundingsMenu)
                {
                    if (1 < AusButtonListSurroundingsMenu.ListeScnapscusZuZaitAingangBisherAnzaal)
                    {
                        //	Übernaame ersct bai meer als ain Scnapscus da eventuel in früühescte Scnapscus noc nit ale Entry enthalte
                        AusButtonListSurroundingsMenuLezteMitBeginZait = AusButtonListSurroundingsMenu.SictWertMitZaitBerecneFürBeginZait <SictGbsMenuZuusctand>();
                    }
                }
            }
        }