Пример #1
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);
                }
            }
        }
Пример #2
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();
            }
        }