コード例 #1
0
        bool AufgaabeHinraicendGlaicwertigFürFortsazFürAufgaabeParamUndBeginZaitHinraicendJung(
            SictAufgaabeZuusctand KandidaatAufgaabe,
            SictAufgaabeParam AufgaabeParam,
            Int64?BeginZaitScrankeMin = null)
        {
            if (null == KandidaatAufgaabe)
            {
                return(false);
            }

            if (BeginZaitScrankeMin.HasValue)
            {
                if (!(BeginZaitScrankeMin <= KandidaatAufgaabe.BeginZait))
                {
                    return(false);
                }
            }

            var AufgaabeErfolgUnterbrecungZait = KandidaatAufgaabe.ErfolgUnterbrecungZait;

            if (AufgaabeErfolgUnterbrecungZait.HasValue)
            {
                return(false);
            }

            var KandidaatAufgaabeParam = KandidaatAufgaabe.AufgaabeParam;

            if (!SictAufgaabeParam.HinraicendGlaicwertigFürFortsaz(KandidaatAufgaabeParam, AufgaabeParam))
            {
                return(false);
            }

            return(true);
        }
コード例 #2
0
        bool AufgaabeErfolgraicUmgeseztFürAufgaabeParam(
            SictAufgaabeZuusctand Aufgaabe,
            SictAufgaabeParam AufgaabeParam)
        {
            if (null == Aufgaabe)
            {
                return(false);
            }

            var AufgaabeErfolgZait             = Aufgaabe.ErfolgZait;
            var AufgaabeErfolgUnterbrecungZait = Aufgaabe.ErfolgUnterbrecungZait;

            if (!AufgaabeErfolgZait.HasValue)
            {
                return(false);
            }

            if (AufgaabeErfolgUnterbrecungZait.HasValue)
            {
                return(false);
            }

            if (!AufgaabeHinraicendGlaicwertigFürFortsazFürAufgaabeParamUndBeginZaitHinraicendJung(Aufgaabe, AufgaabeParam))
            {
                return(false);
            }

            return(true);
        }
コード例 #3
0
        public void ListeAufgaabeModuleBeleegtFüügeAin(
            SictAufgaabeZuusctand Aufgaabe)
        {
            if (null == Aufgaabe)
            {
                return;
            }

            var AufgaabeParam = Aufgaabe.AufgaabeParam      as      AufgaabeParamAndere;

            if (null == AufgaabeParam)
            {
                return;
            }

            var Module =
                AufgaabeParam.ModuleScalteUm ??
                AufgaabeParam.ModuleScalteAin ??
                AufgaabeParam.ModuleScalteAus;

            if (null == Module)
            {
                return;
            }

            InternListeAufgaabeModuleBeleegt.Add(new KeyValuePair <SictAufgaabeZuusctand, SictShipUiModuleReprZuusctand>(Aufgaabe, Module));
        }
コード例 #4
0
        public void WindowMinimizeBeleegtAufgaabeSeze(SictAufgaabeZuusctand WindowMinimizeBeleegtAufgaabe)
        {
            if (null != this.WindowMinimizeBeleegtAufgaabe)
            {
                return;
            }

            this.WindowMinimizeBeleegtAufgaabe = WindowMinimizeBeleegtAufgaabe;
        }
コード例 #5
0
        public void MausBeleegtAufgaabeSeze(SictAufgaabeZuusctand MausBeleegtAufgaabe)
        {
            if (null != this.MausBeleegtAufgaabe)
            {
                return;
            }

            this.MausBeleegtAufgaabe = MausBeleegtAufgaabe;
        }
コード例 #6
0
        public void OverViewTabBeleegtAufgaabeSeze(SictAufgaabeZuusctand OverViewTabBeleegtAufgaabe)
        {
            if (null != this.OverViewTabBeleegtAufgaabe)
            {
                return;
            }

            this.OverViewTabBeleegtAufgaabe = OverViewTabBeleegtAufgaabe;
        }
コード例 #7
0
        public void TargetBeleegtAufgaabeSeze(SictAufgaabeZuusctand TargetBeleegtAufgaabe)
        {
            if (null != this.TargetBeleegtAufgaabe)
            {
                return;
            }

            this.TargetBeleegtAufgaabe = TargetBeleegtAufgaabe;
        }
コード例 #8
0
        public void FürVerdrängteAufgaabeZuWarteSeze(SictAufgaabeZuusctand FürVerdrängteAufgaabeZuWarte)
        {
            if (null != this.FürVerdrängteAufgaabeZuWarte)
            {
                return;
            }

            this.FürVerdrängteAufgaabeZuWarte = FürVerdrängteAufgaabeZuWarte;
        }
コード例 #9
0
        public bool     AufgaabeEnthalteInAufgaabePfaad(
            SictAufgaabeZuusctand Aufgaabe,
            IEnumerable <SictAufgaabeZuusctand> AufgaabePfaad)
        {
            if (null == AufgaabePfaad)
            {
                return(false);
            }

            return(AufgaabePfaad.Contains(Aufgaabe));
        }
コード例 #10
0
        public void ListeAufgaabeReegelungDistanceFüügeAin(
            SictAufgaabeZuusctand Aufgaabe,
            Int64?ScpiilraumRest)
        {
            if (null == Aufgaabe)
            {
                return;
            }

            InternListeAufgaabeReegelungDistanceMitScpiilraumRest.Add(
                new KeyValuePair <SictAufgaabeZuusctand, Int64?>(Aufgaabe, ScpiilraumRest));
        }
コード例 #11
0
        public SictAufgaabeParamZerleegungErgeebnis AufgaabeBerecneAktueleTailaufgaabe(
            SictAufgaabeZuusctand Aufgaabe,
            SictAufgaabeKombiZuusctand KombiZuusctand)
        {
            var AufgaabeParam = (null == Aufgaabe) ? null : Aufgaabe.AufgaabeParam;

            if (null == AufgaabeParam)
            {
                return(default(SictAufgaabeParamZerleegungErgeebnis));
            }

            return(AufgaabeParam.Zerleege(this, KombiZuusctand));
        }
コード例 #12
0
        static public void AusListeAufgaabeBerecneAnzaalUndScpiilraumRest(
            IEnumerable <KeyValuePair <SictAufgaabeZuusctand, Int64?> > ListeAufgaabeReegelungDistanceMitScpiilraumRest,
            SictAufgaabeZuusctand Aufgaabe,
            out int AufgaabeAnzaal,
            out Int64?ScpiilraumRest)
        {
            AufgaabeAnzaal = 0;
            ScpiilraumRest = null;

            if (null == ListeAufgaabeReegelungDistanceMitScpiilraumRest)
            {
                return;
            }

            foreach (var AufgaabeZuBerüksictigeUndScpiilraumRest in ListeAufgaabeReegelungDistanceMitScpiilraumRest)
            {
                var AufgaabeZuBerüksictige = AufgaabeZuBerüksictigeUndScpiilraumRest.Key;

                if (null != AufgaabeZuBerüksictige &&
                    null != Aufgaabe)
                {
                    if (AufgaabeZuBerüksictige == Aufgaabe)
                    {
                        continue;
                    }

                    var MengeKomponente = AufgaabeZuBerüksictige.MengeKomponenteTransitiivBerecne();

                    if (null != MengeKomponente)
                    {
                        if (MengeKomponente.Contains(Aufgaabe))
                        {
                            //	Aufgaabe isc in bescrankende Ast enthalte daaher werd diiser nit als für Aufgaabe bescrankend gewertet.
                            continue;
                        }
                    }
                }

                ++AufgaabeAnzaal;
                ScpiilraumRest = Bib3.Glob.Min(ScpiilraumRest, AufgaabeZuBerüksictigeUndScpiilraumRest.Value);
            }
        }
コード例 #13
0
        public bool AufgaabeReegelungDistanceFürAufgaabeFraigaabeBerecne(
            SictAufgaabeZuusctand Aufgaabe)
        {
            int   AufgaabeAnzaal;
            Int64?ScpiilraumRest;

            AusListeAufgaabeBerecneAnzaalUndScpiilraumRest(
                InternListeAufgaabeReegelungDistanceMitScpiilraumRest,
                Aufgaabe,
                out AufgaabeAnzaal,
                out ScpiilraumRest);

            if (ListeAufgaabeReegelungDistanceAnzaalScrankeMax <= AufgaabeAnzaal)
            {
                return(false);
            }

            if (ScpiilraumRest < 1111)
            {
                return(false);
            }

            return(true);
        }
コード例 #14
0
        override public void AufgaabeScrit(
            Int64 Zait,
            SictAufgaabeZuusctand Aufgaabe,
            Bib3.SictIdentInt64Fabrik AufgaabeIdentFabrik,
            SictAufgaabeKombiZuusctand KombiZuusctand)
        {
            if (null == Aufgaabe)
            {
                return;
            }

            var AufgaabeParam = Aufgaabe.AufgaabeParam;

            var AufgaabeBisherMengeKomponente = Aufgaabe.MengeKomponenteBerecne();

            var AufgaabeParamZerleegungErgeebnis = AufgaabeBerecneAktueleTailaufgaabe(Aufgaabe, KombiZuusctand);

            var ReegelungDistanceScpiilraumRest = AufgaabeParamZerleegungErgeebnis.ReegelungDistanceScpiilraumRest;

            var MengeAufgaabeKomponenteParam = AufgaabeParamZerleegungErgeebnis.ListeKomponenteAufgaabeParam;
            var ZerleegungVolsctändig        = AufgaabeParamZerleegungErgeebnis.ZerleegungVolsctändig;

            if (ReegelungDistanceScpiilraumRest.HasValue)
            {
                KombiZuusctand.ListeAufgaabeReegelungDistanceFüügeAin(Aufgaabe, ReegelungDistanceScpiilraumRest);
            }

            var MengeAufgaabeKomponenteAktiiv = new List <SictAufgaabeZuusctand>();

            if (MengeAufgaabeKomponenteParam.IsNullOrEmpty())
            {
            }
            else
            {
                foreach (var AufgaabeKomponenteParam in MengeAufgaabeKomponenteParam)
                {
                    if (null == AufgaabeKomponenteParam)
                    {
                        continue;
                    }

                    var AufgaabeKomponente =
                        (null == AufgaabeBisherMengeKomponente) ? null :
                        AufgaabeBisherMengeKomponente
                        .FirstOrDefault((Kandidaat) => AufgaabeHinraicendGlaicwertigFürFortsazFürAufgaabeParamUndBeginZaitHinraicendJung(
                                            Kandidaat,
                                            AufgaabeKomponenteParam,
                                            Zait - 10000));

                    if (MengeAufgaabeKomponenteAktiiv.Contains(AufgaabeKomponente))
                    {
                        throw new ApplicationException("Vermuutlic Feeler in AufgaabeHinraicendGlaicwertigFürFortsazFürAufgaabeParam");
                    }

                    if (null == AufgaabeKomponente)
                    {
                        AufgaabeKomponente = new SictAufgaabeZuusctand(AufgaabeIdentFabrik.IdentBerecne(), AufgaabeKomponenteParam, null, Zait);
                    }

                    MengeAufgaabeKomponenteAktiiv.Add(AufgaabeKomponente);
                }
            }

            Aufgaabe.ZerleegungErgeebnisLezteZuZaitSeze(new SictWertMitZait <SictAufgaabeScritZerleegungErgeebnis>(
                                                            Zait,
                                                            new SictAufgaabeScritZerleegungErgeebnis(MengeAufgaabeKomponenteAktiiv.ToArray(), ZerleegungVolsctändig)));
        }