public void BeginTargetAssignmentSeze(
            AusZaitraumMengeTargetAssignmentBerict BeginTargetAssignment)
        {
            if (null != this.BeginTargetAssignment)
            {
                return;
            }

            this.BeginTargetAssignment = BeginTargetAssignment;
        }
Beispiel #2
0
        void Aktualisiire(
            Int64 Zait,
            ShipUiModule ScnapscusWert,
            AutomaatZuusctandUndGeneric <int> ZuusazInfo)
        {
            TempDebugInspektAingangScnapscusLezteZait = Zait;

            var ModuleButtonHintGültigMitZait = default(SictWertMitZait <ModuleButtonHintInterpretiirt>);

            var Automaat = ZuusazInfo.Automaat;

            var ScnapscusModuleButtonHint = Automaat.ScnapscusLezteModuleButtonHint();

            var Sictbar = false;
            var Hilite  = false;
            var Aktiiv  = false;

            var ModuleReprInGbsFläce       = (null == ScnapscusWert) ? OrtogoonInt.Leer : ScnapscusWert.InGbsFläce;
            var ScnapscusRampRotatioonMili = (null == ScnapscusWert) ? null : ScnapscusWert.RampRotatioonMili;

            ListeRampRotatioonMiliZuZait.Enqueue(new SictWertMitZait <int?>(Zait, ScnapscusRampRotatioonMili));
            Bib3.Extension.ListeKürzeBegin(ListeRampRotatioonMiliZuZait, 8);

            var MenuKaskaadeLezte = Automaat.GbsMenuLezteInAstMitHerkunftAdrese(this.ScnapscusLezteGbsAstHerkunftAdrese);

            if (null != MenuKaskaadeLezte)
            {
                var MenuKaskaadeLezteMenuBegin = MenuKaskaadeLezte.ListeMenuScnapscusLezteMitBeginZaitBerecne().FirstOrDefaultNullable();

                if (null != MenuKaskaadeLezteMenuBegin.Wert)
                {
                    var EntryIndikatorModule =
                        MenuKaskaadeLezteMenuBegin.Wert.ListeEntry.FirstOrDefault((Kandidaat) =>
                                                                                  Regex.Match(Kandidaat.Bescriftung ?? "", "put\\s*(off|on)line", RegexOptions.IgnoreCase).Success ||
                                                                                  Regex.Match(Kandidaat.Bescriftung ?? "", "reload", RegexOptions.IgnoreCase).Success ||
                                                                                  Regex.Match(Kandidaat.Bescriftung ?? "", "unload", RegexOptions.IgnoreCase).Success);

                    var EntryIndikatorModuleKontra =
                        MenuKaskaadeLezteMenuBegin.Wert.ListeEntry.FirstOrDefault((Kandidaat) =>
                                                                                  Regex.Match(Kandidaat.Bescriftung ?? "", "camera", RegexOptions.IgnoreCase).Success ||
                                                                                  Regex.Match(Kandidaat.Bescriftung ?? "", "stargates", RegexOptions.IgnoreCase).Success);

                    if (!(MenuKaskaadeLezte == this.MenuLezte) &&
                        null != EntryIndikatorModule &&
                        null == EntryIndikatorModuleKontra)
                    {
                        var MengeDamageTypAmmoRegexPattern = SictKonfig.MengeDamageTypAmmoRegexPattern;

                        this.MenuLezte = MenuKaskaadeLezte;

                        this.MenuLezteScpezModuleButtonMitZait = new SictWertMitZait <SictMenuModuleButtonAuswert>(
                            MenuKaskaadeLezte.ScnapscusFrühesteZait ?? -1,
                            SictMenuModuleButtonAuswert.Konstrukt(
                                MenuKaskaadeLezte.ListeMenuScnapscusLezteMitBeginZaitBerecne().FirstOrDefaultNullable().Wert,
                                MengeDamageTypAmmoRegexPattern));
                    }
                }
            }

            if (!ModuleReprInGbsFläce.IsLeer)
            {
                var LaageLezte = ListeLaageLezteBerecne();

                if (!(LaageLezte == ModuleReprInGbsFläce.ZentrumLaage))
                {
                    ListeLaageZuZait.Add(new SictWertMitZait <Vektor2DInt>(Zait, ModuleReprInGbsFläce.ZentrumLaage));

                    Bib3.Extension.ListeKürzeBegin(ListeLaageZuZait, 4);
                }
            }

            try
            {
                {
                    //	dii aufruufende Funktioon verantwortet nict di Zugehörigkait des ModuleButtonHint zum Module, diise werd hiir sicergesctelt.
                    if (null == ScnapscusWert)
                    {
                        ScnapscusModuleButtonHint = null;
                    }
                    else
                    {
                        if (!(true == ScnapscusWert.SpriteHiliteSictbar))
                        {
                            ScnapscusModuleButtonHint = null;
                        }
                    }

                    if (null != ScnapscusModuleButtonHint)
                    {
                        if (!(true == ScnapscusModuleButtonHint.PasendZuModuleReprBerecne(ScnapscusWert)))
                        {
                            ScnapscusModuleButtonHint = null;
                        }
                    }
                }

                if (this.ScnapscusLezteModuleReprUndButtonHintMitZait.Zait < Zait)
                {
                    InternScnapscusVorLezteModuleReprUndButtonHintMitZait = this.ScnapscusLezteModuleReprUndButtonHintMitZait;
                }
                else
                {
                    if (Zait < this.ScnapscusLezteModuleReprUndButtonHintMitZait.Zait)
                    {
                        InternScnapscusVorLezteModuleReprUndButtonHintMitZait =
                            default(SictWertMitZait <KeyValuePair <ShipUiModule, ModuleButtonHintInterpretiirt> >);
                    }
                }

                this.ScnapscusLezteModuleReprUndButtonHintMitZait =
                    new SictWertMitZait <KeyValuePair <ShipUiModule, ModuleButtonHintInterpretiirt> >(Zait,
                                                                                                      new KeyValuePair <ShipUiModule, ModuleButtonHintInterpretiirt>(ScnapscusWert, ScnapscusModuleButtonHint));

                if (null != ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key)
                {
                    ChargeAnzaal = ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonQuantityInt;

                    AnnaameChargeAnzaalScrankeMaxScrankeMin = Bib3.Glob.Max(
                        AnnaameChargeAnzaalScrankeMaxScrankeMin, ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonQuantityInt);

                    Sictbar = Zait <= ScnapscusLezteModuleReprUndButtonHintMitZait.Zait;

                    if (Sictbar)
                    {
                        Hilite = true == ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.SpriteHiliteSictbar;

                        Aktiiv = true == ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.RampAktiiv;

                        {
                            //	Berecnung ob Module Aktiiv: es kan vorkome das mit Scnapscus zuufälige Werte geliifert werde oder das Ramp nit sictbar wail geraade nahe 0.
                            //	Daher Reegel Annaame Aktiiv:
                            //	(in lezte Scnapscus Ramp.RotatioonMili unglaic 0)	|| ((in VorLezte Scnapscus Ramp.RotatioonMili unglaic 0) && erwartete (extrapoliirte Ramp.RotatioonMili auserhalb Regioon Ramp ende))

                            //	ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.Ramp.RotatioonMili
                        }
                    }
                }

                if (null != ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key &&
                    null != InternScnapscusVorLezteModuleReprUndButtonHintMitZait.Wert.Key)
                {
                    var ModuleButtonTextureIdentNulbar = ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonIconTextureIdent;

                    if (ModuleButtonTextureIdentNulbar.HasValue)
                    {
                        var ModuleButtonTextureIdent = ModuleButtonTextureIdentNulbar.Value;

                        if (ModuleButtonTextureIdentNulbar == InternScnapscusVorLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonIconTextureIdent)
                        {
                            //	Berecnung aus Scnapscus zu überneemende ModuleButtonHint

                            if (null != ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Value &&
                                null != InternScnapscusVorLezteModuleReprUndButtonHintMitZait.Wert.Value)
                            {
                                if (ModuleButtonHintInterpretiirt.AusMengeScnapscusHinraicendGlaicwertigFürÜbernaame(
                                        ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Value,
                                        InternScnapscusVorLezteModuleReprUndButtonHintMitZait.Wert.Value))
                                {
                                    DictZuModuleButtonIconHintLezteMitZait[ModuleButtonTextureIdent] =
                                        new SictWertMitZait <ModuleButtonHintInterpretiirt>(
                                            ScnapscusLezteModuleReprUndButtonHintMitZait.Zait,
                                            ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Value);

                                    DictZuModuleButtonIconHintLezteMitZait.EntferneMengeAintraagSolangeAnzaalGrööserScranke(
                                        4, (IconIdentMitHintMitZait) => IconIdentMitHintMitZait.Value.Zait);
                                }
                            }
                        }

                        {
                            //	Berecnung aktuel gültige ModuleButtonHint

                            var ZuModuleButtonIconHintLezteMitZaitNulbar =
                                Optimat.Glob.TADNulbar(DictZuModuleButtonIconHintLezteMitZait, ModuleButtonTextureIdent);

                            if (ZuModuleButtonIconHintLezteMitZaitNulbar.HasValue)
                            {
                                if (null != ZuModuleButtonIconHintLezteMitZaitNulbar.Value.Wert)
                                {
                                    ModuleButtonHintGültigMitZait = ZuModuleButtonIconHintLezteMitZaitNulbar.Value;
                                }
                            }
                        }
                    }
                }

                if (null != ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key &&
                    null != InternScnapscusVorLezteModuleReprUndButtonHintMitZait.Wert.Key)
                {
                    {
                        //	!!!!	zu ergänze: entprele: nit nur lezte sondern auc vorvorlezte berüksictige
                        if ((InternScnapscusVorLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonQuantityInt ?? 0) <
                            ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonQuantityInt)
                        {
                            //	Quantity isc von Scnapscus zu Scnapscus gesctiige (-> Annaame Load/Reload hat sctatgefunde)

                            AnnaameChargeAnzaalScrankeMax = ScnapscusLezteModuleReprUndButtonHintMitZait.Wert.Key.ModuleButtonQuantityInt;
                        }
                    }
                }

                //	!!!!	zu ergänze:	AnnaameChargeAnzaalScrankeMax sol zurükgesezt werde wen Munitioonstyp wexelt diise abhängig von Munitionstyp

                {
                    /*
                     * 2014.09.13
                     *
                     * var ListeAktivitäätLezte = InternListeAktivitäät.LastOrDefaultNullable();
                     *
                     * var AktivitäätTransitioonListeScritAnzaalScrankeMin =
                     *      Math.Max(1,
                     *      Math.Min(this.ListeScnapscusZuZaitZuErhalteAnzaalScrankeMax ?? 0, this.AktivitäätTransitioonListeScritAnzaalScrankeMin));
                     *
                     * var BerecnungAktivitäätListeScnapscus =
                     *      Enumerable.Range(0, AktivitäätTransitioonListeScritAnzaalScrankeMin)
                     *      .Select((ScnapscusAlter) => this.AingangScnapscusMitAlterScritAnzaalBerecne(ScnapscusAlter))
                     *      .WhereNullable((Kandidaat) => Kandidaat.HasValue)
                     *      .SelectNullable((Kandidaat) => Kandidaat.Value)
                     *      .ToArrayNullable();
                     *
                     * if (AktivitäätTransitioonListeScritAnzaalScrankeMin <= BerecnungAktivitäätListeScnapscus.CountNullable())
                     * {
                     *      var BerecnungAktivitäätListeScnapscusBeginZait =
                     *              BerecnungAktivitäätListeScnapscus.Select((tScnapscus) => tScnapscus.Zait).Min();
                     *
                     *      var ListeScnapscusAktiiv =
                     *              BerecnungAktivitäätListeScnapscus.Select((tScnapscus) =>
                     *                      {
                     *                              if (null == tScnapscus.Wert.Key)
                     *                              {
                     *                                      return false;
                     *                              }
                     *
                     *                              return tScnapscus.Wert.Key.RampAktiiv ?? false;
                     *                      }).ToArray();
                     *
                     *      if (ListeScnapscusAktiiv.All((ScnapscusAktiiv) => ScnapscusAktiiv))
                     *      {
                     *              var AktivitäätObjektKonstrukt = true;
                     *
                     *              if (null != ListeAktivitäätLezte)
                     *              {
                     *                      if (!ListeAktivitäätLezte.EndeZait.HasValue)
                     *                      {
                     *                              AktivitäätObjektKonstrukt = false;
                     *                      }
                     *              }
                     *
                     *              if (AktivitäätObjektKonstrukt)
                     *              {
                     *                      var BeginMengeTarget = new List<SictTargetZuusctand>();
                     *
                     *                      var MengeTarget = ZuusazInfo.MengeTarget();
                     *
                     *                      if (null != MengeTarget)
                     *                      {
                     *                      }
                     *
                     *                      var Aktivitäät = new ModuleAktivitäätZaitraum(BerecnungAktivitäätListeScnapscusBeginZait, this, BeginMengeTarget.ToArrayFalsNitLeer());
                     *
                     *                      InternListeAktivitäät.Enqueue(Aktivitäät);
                     *              }
                     *      }
                     *
                     *      if (ListeScnapscusAktiiv.All((ScnapscusAktiiv) => !ScnapscusAktiiv))
                     *      {
                     *              if (null != ListeAktivitäätLezte)
                     *              {
                     *                      if (!ListeAktivitäätLezte.EndeZait.HasValue)
                     *                      {
                     *                              ListeAktivitäätLezte.EndeZait = BerecnungAktivitäätListeScnapscusBeginZait;
                     *                      }
                     *              }
                     *      }
                     * }
                     * */

                    var AktivitäätTransitioon =
                        InternListeAktivitäätFilterTransitioon.AingangScrit(
                            Zait, Aktiiv,
                            AktivitäätTransitioonListeScritAnzaalScrankeMin,
                            3);

                    var ListeAktivitäätLezte = InternListeAktivitäät.LastOrDefaultNullable();

                    var ListeAktivitäätLezteTransitioon = InternListeAktivitäätFilterTransitioon.ListeTransitioonLezteInfo();

                    //	AktivitäätTransitioon = ListeAktivitäätLezteTransitioon;

                    if (null != ListeAktivitäätLezte)
                    {
                        var ListeAktivitäätLezteBeginIndex            = Automaat.ZuNuzerZaitBerecneScritIndex(ListeAktivitäätLezte.BeginZait ?? -1);
                        var BeginTargetAssignmentScritIndexScrankeMin = ListeAktivitäätLezteBeginIndex - 1;
                        var BeginTargetAssignmentScritIndexScrankeMax = ListeAktivitäätLezteBeginIndex + 1;

                        if (null == ListeAktivitäätLezte.BeginTargetAssignment &&
                            BeginTargetAssignmentScritIndexScrankeMax <= Automaat.ScritLezteIndex)
                        {
                            Int64[] TargetAssignedFilterMengeTexturIdent = null;

                            /*
                             * 2014.09.22	Beobactung:
                             * T:\Günta\Projekt\Optimat.EveOnline\Test\Server.Berict\Berict.Nuzer\[ZAK=2014.09.22.22.04.43,NB=0].Anwendung.Berict:
                             * In Target verwendete Icon mit andere TexturIdent als in ModuleButtonHint enthaltene.
                             * In glaice Sizung wexelt oone Jump der TexturIdent aus ZaileTitel ind ModuleButtonHint.
                             *
                             * Andere Löösung wääre deen ModuleButtonHint für Miner noi zu mese wen kaine pasende Assignment in Target gefunde werde.
                             *
                             * if (null != ModuleButtonHintGültigMitZait.Wert)
                             * {
                             *      TargetAssignedFilterMengeTexturIdent = ModuleButtonHintGültigMitZait.Wert.TargetAssignedFilterMengeTexturIdent;
                             * }
                             * */

                            var BeginTargetAssignment = new AusZaitraumMengeTargetAssignmentBerict(
                                BeginTargetAssignmentScritIndexScrankeMin.Value,
                                BeginTargetAssignmentScritIndexScrankeMax.Value,
                                true,
                                TargetAssignedFilterMengeTexturIdent);

                            BeginTargetAssignment.Berecne(Automaat);

                            ListeAktivitäätLezte.BeginTargetAssignmentSeze(BeginTargetAssignment);
                        }
                    }

                    if (AktivitäätTransitioon.HasValue)
                    {
                        var ModuleTransitioonBeginZait = AktivitäätTransitioon.Value.ScritIdent;

                        if (null != ListeAktivitäätLezte)
                        {
                            if (!ListeAktivitäätLezte.EndeZait.HasValue)
                            {
                                ListeAktivitäätLezte.EndeZait = ModuleTransitioonBeginZait;
                            }
                        }

                        if (AktivitäätTransitioon.Value.ZiilWert)
                        {
                            //	Transitioon naac Aktiiv.

                            var Aktivitäät = new ModuleAktivitäätZaitraum(ModuleTransitioonBeginZait, this);

                            InternListeAktivitäät.Enqueue(Aktivitäät);
                        }
                        else
                        {
                        }
                    }

                    if (null != ListeAktivitäätLezte)
                    {
                        if (ScnapscusRampRotatioonMili.HasValue)
                        {
                            ListeAktivitäätLezte.AingangZuZaitRotatioonMili(Zait, ScnapscusRampRotatioonMili.Value);
                        }
                    }
                }
            }
            finally
            {
                SictbarLezteZait.AingangWert(Sictbar ? (Int64?)Zait : null);
                HiliteLezteZait.AingangWert(Hilite ? (Int64?)Zait : null);
                AktiivLezteZait.AingangWertZuZait(Zait, Aktiiv);

                {
                    var BisherModuleButtonHintGültigMitZait = this.ModuleButtonHintGültigMitZait;

                    if (!(ModuleButtonHintGültigMitZait.Wert == BisherModuleButtonHintGültigMitZait.Wert))
                    {
                        if (null != BisherModuleButtonHintGültigMitZait.Wert)
                        {
                            ModuleButtonHintVorherigMitZait =
                                new SictWertMitZait <SictWertMitZait <ModuleButtonHintInterpretiirt> >(
                                    Zait, BisherModuleButtonHintGültigMitZait);
                        }
                    }
                }

                this.ModuleButtonHintGültigMitZait = ModuleButtonHintGültigMitZait;

                InternListeAktivitäät.ListeKürzeBegin(4);
            }
        }