public void ZerleegungErgeebnisLezteZuZaitSeze(
SictWertMitZait <SictAufgaabeScritZerleegungErgeebnis> ZerleegungErgeebnisLezteZuZait)
{
this.ZerleegungErgeebnisLezteZuZait = ZerleegungErgeebnisLezteZuZait;
var MengeKomponenteAktiiv = (null == ZerleegungErgeebnisLezteZuZait.Wert) ? null : ZerleegungErgeebnisLezteZuZait.Wert.MengeKomponente;
if (null != MengeKomponenteAktiiv)
{
var MengeKomponente = this.MengeKomponente;
foreach (var Komponente in MengeKomponenteAktiiv)
{
if (null == Komponente)
{
continue;
}
if (null == MengeKomponente)
{
this.MengeKomponente = MengeKomponente = new List <SictAufgaabeZuusctand>();
}
if (!MengeKomponente.Contains(Komponente))
{
MengeKomponente.Add(Komponente);
}
}
}
}
void ToScriptMessageSerialized(string MessageSerialized)
{
if (null == ScriptInterface)
{
return;
}
var ZaitMili = Bib3.Glob.StopwatchZaitMiliSictInt();
var Aktioon = new Action(() =>
{
lock (Lock)
{
try
{
ScriptInterface.ToScriptMessageSerialized(MessageSerialized);
FromScriptMessageLezte = new SictWertMitZait <string>(ZaitMili, ScriptInterface.FromScriptMessageSerialized());
}
catch (System.Exception Exception)
{
ScriptExceptionLezte = new SictWertMitZait <System.Exception>(ZaitMili, Exception);
}
}
});
var Task = new Task(Aktioon);
Task.Start();
while (!Task.IsCompleted)
{
System.Threading.Thread.Sleep(4);
}
}
public GbsListGroupedZuusctand(
SictWertMitZait <VonSensor.ScnapscusListGrouped> ScnapscusListMitZait)
:
this(
ScnapscusListMitZait.Zait,
(null == ScnapscusListMitZait.Wert) ? null : ScnapscusListMitZait.Wert)
{
}
void InternAingangScnapscus(
Int64 Zait,
ObjektIdentScnapscusType ObjektIdentScnapscus,
SictZuusazInfoScnapscusType ZuusazInfoScnapscus)
{
if (!ScnapscusFrühesteZait.HasValue)
{
if (object.Equals(default(ObjektIdentScnapscusType), ObjektIdentScnapscus))
{
// Für Konstruktor oone Übergaabe Scnapscus Abbruc.
return;
}
ScnapscusFrühesteZait = Zait;
}
if (object.Equals(default(ObjektIdentScnapscusType), ObjektIdentScnapscus))
{
if (!ScnapscusLeerFrühesteZait.HasValue)
{
ScnapscusLeerFrühesteZait = Zait;
}
}
SictScnapscusAlsFortsazZuuläsig.AingangScnapscusAlsFortsaz(ObjektIdentScnapscus);
var ScnapscusZuZait = new SictWertMitZait <KeyValuePair <ObjektIdentScnapscusType, SictZuusazInfoScnapscusType> >(
Zait,
new KeyValuePair <ObjektIdentScnapscusType, SictZuusazInfoScnapscusType>(ObjektIdentScnapscus,
ZuusazInfoErhalteInListeScnapscus ? ZuusazInfoScnapscus : default(SictZuusazInfoScnapscusType)));
var ScnapscusZuZaitMitIndex =
new SictWertMitZait <KeyValuePair <int, KeyValuePair <ObjektIdentScnapscusType, SictZuusazInfoScnapscusType> > >(
Zait,
new KeyValuePair <int, KeyValuePair <ObjektIdentScnapscusType, SictZuusazInfoScnapscusType> >(
ListeScnapscusZuZaitAingangBisherAnzaal + 1,
new KeyValuePair <ObjektIdentScnapscusType, SictZuusazInfoScnapscusType>(
ObjektIdentScnapscus,
ZuusazInfoErhalteInListeScnapscus ? ZuusazInfoScnapscus : default(SictZuusazInfoScnapscusType))));
ListeScnapscusZuZait.Enqueue(ScnapscusZuZait);
if (!(object.Equals(default(ObjektIdentScnapscusType), ObjektIdentScnapscus)))
{
AingangUnglaicDefaultZuZaitMitIndexLezte = ScnapscusZuZaitMitIndex;
}
ListeScnapscusZuZaitAingangBisherAnzaal = ScnapscusZuZaitMitIndex.Wert.Key;
var ListeScnapscusZuZaitZuErhalteAnzaalScrankeMax = this.ListeScnapscusZuZaitZuErhalteAnzaalScrankeMax;
if (ListeScnapscusZuZaitZuErhalteAnzaalScrankeMax.HasValue)
{
Bib3.Extension.ListeKürzeBegin(ListeScnapscusZuZait, ListeScnapscusZuZaitZuErhalteAnzaalScrankeMax.Value);
}
NaacAingangScnapscus(Zait, ObjektIdentScnapscus, ZuusazInfoScnapscus);
}
public SictGbsWindowZuusctand(
SictWertMitZait <VonSensor.Window> ScnapscusWindowMitZait)
:
this(
ScnapscusWindowMitZait.Zait,
(null == ScnapscusWindowMitZait.Wert) ? null : ScnapscusWindowMitZait.Wert)
{
// Aktualisiire(ScnapscusWindowMitZait.Zait, ScnapscusWindowMitZait.Wert);
}
public DiferenzZwisceScnapscus(
SictWertMitZait <int> Scnapscus0,
SictWertMitZait <int> Scnapscus1,
Int64 GescwindigkaitMikro)
{
this.Scnapscus0 = Scnapscus0;
this.Scnapscus1 = Scnapscus1;
this.GescwindigkaitMikro = GescwindigkaitMikro;
}
public void EndeSeze(SictWertMitZait <TEndeEraignis> Ende)
{
if (this.Ende.HasValue)
{
return;
}
this.Ende = Ende;
}
static public bool ZaileIscAusgewäält(
SictWertMitZait <VonSensor.OverviewZaile>?OverviewZaileMitZaitNulbar)
{
if (!OverviewZaileMitZaitNulbar.HasValue)
{
return(false);
}
return(OverviewZaileMitZaitNulbar.Value.Wert.HatInputFookus());
}
public DiferenzZwisceScnapscus(
SictWertMitZait <int> Scnapscus0,
SictWertMitZait <int> Scnapscus1)
:
this(
Scnapscus0,
Scnapscus1,
((Scnapscus1.Wert - Scnapscus0.Wert).SictUmgebrocen(-400, 600) * 1000000) / (Scnapscus1.Zait - Scnapscus0.Zait))
{
}
public SictTargetZuusctand(
SictWertMitZait <ShipUiTarget> TargetReprMitZait,
SictZuInRaumObjektReprScnapscusZuusazinfo ZuusazInfo)
:
base(
TargetReprMitZait.Zait,
TargetReprMitZait.Wert,
ZuusazInfo)
{
}
override public Int64?NuzerAlterMili <T>(SictWertMitZait <T>?WertMitZaitNuzer)
{
if (!WertMitZaitNuzer.HasValue)
{
return(null);
}
var AlterMili = NuzerZaitMili - WertMitZaitNuzer.Value.Zait;
return(AlterMili);
}
public SictVersuucFitLoadErgeebnis(
string FittingBezaicner,
SictWertMitZait <bool>?EntscaidungErfolg = null,
bool?MeldungFeelsclaag = null,
VonSensor.MessageBox ErgeebnisMessageBox = null)
{
this.FittingBezaicner = FittingBezaicner;
this.EntscaidungErfolg = EntscaidungErfolg;
this.MeldungFeelsclaag = MeldungFeelsclaag;
this.ErgeebnisMessageBox = ErgeebnisMessageBox;
}
public bool AingangReprMitZait(
SictWertMitZait <ShipUiTarget> TargetReprMitZait,
SictZuInRaumObjektReprScnapscusZuusazinfo ZuusazInfo = null)
{
if (null == TargetReprMitZait.Wert)
{
base.AingangScnapscusLeer(TargetReprMitZait.Zait, ZuusazInfo);
return(false);
}
else
{
return(base.AingangScnapscus(TargetReprMitZait.Zait, TargetReprMitZait.Wert, ZuusazInfo));
}
}
override protected void NaacAingangScnapscus(
Int64 ScnapscusZait,
VonSensor.WindowAgentDialogue ScnapscusWert)
{
SictWertMitZait <VonSensor.WindowAgentDialogue>?WindowAgentDialogueZuZaitFürÜbernaameMissionInfo = null;
try
{
{
/*
* 2014.05.13
*
* var ScnapscusLezte = ListeScnapscusZuZait.LastOrDefault();
* var ScnapscusVorLezte = ListeScnapscusZuZait.ElementAtOrDefault(ListeScnapscusZuZait.Count() - 2);
* */
var ScnapscusLezteNulbar = AingangScnapscusTailObjektIdentMitZaitLezteBerecne();
var ScnapscusVorLezteNulbar = AingangScnapscusTailObjektIdentMitZaitVorLezteBerecne();
if (ScnapscusLezteNulbar.HasValue && ScnapscusVorLezteNulbar.HasValue)
{
var ScnapscusLezte = ScnapscusLezteNulbar.Value;
var ScnapscusVorLezte = ScnapscusVorLezteNulbar.Value;
var ScnapscusLezteWindow = ScnapscusLezte.Wert;
var ScnapscusVorLezteWindow = ScnapscusVorLezte.Wert;
if (null != ScnapscusLezteWindow && null != ScnapscusVorLezteWindow)
{
if (HinraicendGlaicwertigFürÜbernaameMissionInfo(ScnapscusLezteWindow, ScnapscusVorLezteWindow))
{
WindowAgentDialogueZuZaitFürÜbernaameMissionInfo = ScnapscusLezteNulbar;
}
}
}
}
}
finally
{
this.WindowAgentDialogueZuZaitFürÜbernaameMissionInfo = WindowAgentDialogueZuZaitFürÜbernaameMissionInfo;
}
}
override public SictWertMitZait <SictDataiIdentUndSuuceHinwais> ZuNuzerZaitMiliWindowClientRasterSuuceHinwaisNääxte(
Int64 NuzerZaitMili)
{
var BisherBeste = default(SictWertMitZait <SictDataiIdentUndSuuceHinwais>);
if (null != DictVonNuzerZaitMiliWindowClientRasterSuuceHinwais)
{
foreach (var VonNuzerZaitMiliWindowClientRasterSuuceHinwais in DictVonNuzerZaitMiliWindowClientRasterSuuceHinwais)
{
var Distanz = VonNuzerZaitMiliWindowClientRasterSuuceHinwais.Key - NuzerZaitMili;
var BisherBesteDistanz = BisherBeste.Zait - NuzerZaitMili;
if (Math.Abs(Distanz) < Math.Abs(BisherBesteDistanz))
{
BisherBeste = new SictWertMitZait <SictDataiIdentUndSuuceHinwais>(VonNuzerZaitMiliWindowClientRasterSuuceHinwais.Key, VonNuzerZaitMiliWindowClientRasterSuuceHinwais.Value);
}
}
}
return(BisherBeste);
}
protected void TimerElapsedLockedInRaameBerict()
{
this.Dispatcher.Invoke(new Action(TimerElapsedDispatched), new object[0]);
var BeginZaitMikro = Bib3.Glob.StopwatchZaitMikroSictInt();
var BeginZaitMili = BeginZaitMikro / 1000;
try
{
var CustomBotServer = this.CustomBotServer;
/*
* 16.04.15
* This is probably the place to call licensensing communication dispatch.
*
* LicenseClientKümereRateBescranke.Call();
*/
GetMeasurementIfDue();
SensorKümereRateBescranke.Call();
if (null != CustomBotServer)
{
CustomBotServer.NaacBotScnapscus = SensorSnapshotLastAgrClassic;
}
AktualisiireAutomat();
var EveOnlnSensoBeginZaitMikro = Bib3.Glob.StopwatchZaitMikroSictInt();
var EveOnlnWirkungKümereBeginZaitMikro = Bib3.Glob.StopwatchZaitMikroSictInt();
EveOnlnWirkungKümere();
}
catch (System.Exception Exception)
{
TimerElapsedLockedInRaameBerictExceptionLezte = new SictWertMitZait <System.Exception>(BeginZaitMili, Exception);
}
}
/// <summary>
/// Unterstüzt den Aufbau ainer Folge nuur durc Scrole naac unte.
/// </summary>
/// <param name="WindowOverviewNoiMitZait"></param>
public void AingangNääxte(SictWertMitZait <VonSensor.WindowOverView> WindowOverviewNoiMitZait)
{
var WindowOverviewNoi = WindowOverviewNoiMitZait.Wert;
if (null == WindowOverviewNoi)
{
return;
}
if (true == Fertig)
{
return;
}
var ScnapscusZaitDistanzScrankeMax = 5000;
var FolgeDauerScrankeMax = 30000;
var WindowOverviewNoiAusTabListeZaile = WindowOverviewNoi.AusTabListeZaileOrdnetNaacLaage;
var WindowOverviewNoiTypeSelectionName = WindowOverviewNoi.OverviewPresetIdent;
var WindowOverviewNoiScroll = WindowOverviewNoi.Scroll;
if (null == WindowOverviewNoiTypeSelectionName ||
null == WindowOverviewNoiScroll)
{
goto FolgeBeEnde;
}
if (null == WindowOverviewNoiAusTabListeZaile &&
!(true == WindowOverviewNoi.MeldungMengeZaileLeer))
{
goto FolgeBeEnde;
}
var WindowOverviewNoiAusTabListeZaileFiltert =
ExtractFromOldAssembly.Bib3.Extension.WhereNullable(
WindowOverviewNoiAusTabListeZaile,
(Kandidaat) => Kandidaat.DistanceMax.HasValue)
.ToArrayNullable();
var WindowOverviewNoiAusTabListeZaileFiltertFrüheste =
ExtractFromOldAssembly.Bib3.Extension.FirstOrDefaultNullable(WindowOverviewNoiAusTabListeZaileFiltert);
var EndeObjekt =
ExtractFromOldAssembly.Bib3.Extension.LastOrDefaultNullable(
WindowOverviewNoiAusTabListeZaileFiltert,
(Zaile) => Zaile.DistanceMin.HasValue);
try
{
if (!BeginZait.HasValue)
{
BeginZait = WindowOverviewNoiMitZait.Zait;
BeginScrollHandleFläceGrenzeOobnAntailAnGesamtMili = WindowOverviewNoiScroll.ScrollHandleFläceGrenzeOobnAntailAnGesamtMili;
if (null != WindowOverviewNoiAusTabListeZaileFiltertFrüheste)
{
BeginObjektDistance = WindowOverviewNoiAusTabListeZaileFiltertFrüheste.DistanceMax;
}
OverviewPresetName = WindowOverviewNoiTypeSelectionName;
return;
}
var FolgeDauer = WindowOverviewNoiMitZait.Zait - BeginZait;
if (FolgeDauerScrankeMax < FolgeDauer)
{
goto FolgeBeEnde;
}
var WindowOverviewVorherigMitZait = this.WindowOverviewVorherigMitZait;
var WindowOverviewVorherig = WindowOverviewVorherigMitZait.Wert;
if (null == WindowOverviewVorherig)
{
goto FolgeBeEnde;
}
if (WindowOverviewNoiMitZait.Zait <= WindowOverviewVorherigMitZait.Zait)
{
// Noier Scnapscus hat Zaitpunkt vor vorherigem Scnapscus.
goto FolgeBeEnde;
}
if (ScnapscusZaitDistanzScrankeMax < WindowOverviewNoiMitZait.Zait - WindowOverviewVorherigMitZait.Zait)
{
// Zaitraum zwisce noier Scnapscus und vorheriger Scnapscus isc zu lang.
goto FolgeBeEnde;
}
var WindowOverviewVorherigScroll = WindowOverviewVorherig.Scroll;
if (null == WindowOverviewVorherigScroll)
{
goto FolgeBeEnde;
}
if (!(string.Equals(OverviewPresetName, WindowOverviewNoiTypeSelectionName)))
{
goto FolgeBeEnde;
}
var WindowOverviewNoiScrollHandleFläce = WindowOverviewNoiScroll.ScrollHandleFläce;
var WindowOverviewVorherigScrollHandleFläce = WindowOverviewVorherigScroll.ScrollHandleFläce;
var WindowOverviewVorherigMeldungMengeZaileLeer = WindowOverviewVorherig.MeldungMengeZaileLeer;
if ((null == WindowOverviewNoiScrollHandleFläce &&
null == WindowOverviewVorherigScrollHandleFläce) ||
(true == WindowOverviewVorherigMeldungMengeZaileLeer &&
true == WindowOverviewNoi.MeldungMengeZaileLeer))
{
// In diisem Fal kan davon ausgegange werde das das Scrole nit mööglic da ale Zaile in deen Viewport pase.
// Es werden Viewport aus mindestes Scnapscus benöötigt. Daher BeginZait = WindowOverviewVorherigMitZait.Zait;
BeginZait = WindowOverviewVorherigMitZait.Zait;
BeginScrollHandleFläceGrenzeOobnAntailAnGesamtMili = 0;
VolsctändigTailInGrid = true;
goto FolgeBeEnde;
}
if (!(true == WindowOverviewNoiMitZait.Wert.ZaileSindSortiirtNaacDistanceAufsctaigend))
{
goto FolgeBeEnde;
}
if (null == WindowOverviewNoiAusTabListeZaileFiltert)
{
goto FolgeBeEnde;
}
if (WindowOverviewNoiAusTabListeZaileFiltert.Length < 4)
{
// Für hinraicende Überlapung müse mindestens viir Zaile sictbar sain.
goto FolgeBeEnde;
}
// Überlapung mit vorherigem Viewport berecne.
var WindowOverviewVorherigScrollClipperFläce = WindowOverviewVorherigScroll.ClipperFläce;
var WindowOverviewNoiScrollClipperFläce = WindowOverviewNoiScroll.ClipperFläce;
if (null == WindowOverviewVorherigScrollClipperFläce ||
null == WindowOverviewNoiScrollClipperFläce)
{
goto FolgeBeEnde;
}
var WindowOverviewVorherigInhaltGrööse = WindowOverviewVorherigScrollClipperFläce.Value.Grööse.B * 1000 / WindowOverviewVorherigScroll.ScrollHandleAntailAnGesamtMili;
var WindowOverviewNoiInhaltGrööse = WindowOverviewNoiScrollClipperFläce.Value.Grööse.B * 1000 / WindowOverviewVorherigScroll.ScrollHandleAntailAnGesamtMili;
var WindowOverviewVorherigViewportGrenzeUnte =
WindowOverviewVorherigScroll.ScrollHandleFläceGrenzeUntnAntailAnGesamtMili * WindowOverviewVorherigInhaltGrööse / 1000;
var WindowOverviewNoiViewportGrenzeOobe =
WindowOverviewNoiScroll.ScrollHandleFläceGrenzeOobnAntailAnGesamtMili * WindowOverviewNoiInhaltGrööse / 1000;
var ÜberlappungInBildpunkte = WindowOverviewVorherigViewportGrenzeUnte - WindowOverviewNoiViewportGrenzeOobe;
if (!(88 < ÜberlappungInBildpunkte))
{
// Unzuraicende Überlapung zwisce Viewport
goto FolgeBeEnde;
}
EndeObjektDistance = (null == EndeObjekt) ? null : EndeObjekt.DistanceMin;
EndeScrollHandleFläceGrenzeUntnAntailAnGesamtMili = WindowOverviewNoiScroll.ScrollHandleFläceGrenzeUntnAntailAnGesamtMili;
var FolgeBeginHinraicendNaheAnOberkanteFürAnnaameVolsctändig =
BeginScrollHandleFläceGrenzeOobnAntailAnGesamtMili < 3;
if (1e+6 < EndeObjektDistance &&
FolgeBeginHinraicendNaheAnOberkanteFürAnnaameVolsctändig)
{
VolsctändigTailInGrid = true;
}
if (998 < WindowOverviewNoiScroll.ScrollHandleFläceGrenzeUntnAntailAnGesamtMili)
{
// Wail der Automaat den Punkt zum Scrole noc nit genau trift werd hiir am Rand vorersct auf e paar tausendstel verzictet.
EndeZait = WindowOverviewNoiMitZait.Zait;
if (FolgeBeginHinraicendNaheAnOberkanteFürAnnaameVolsctändig)
{
VolsctändigTailInGrid = true;
return;
}
}
if (!(WindowOverviewVorherigScroll.ScrollHandleFläceGrenzeOobnAntailAnGesamtMili <
WindowOverviewNoiScroll.ScrollHandleFläceGrenzeOobnAntailAnGesamtMili))
{
// Oberkante des noie Viewport liigt nit tiifer als di Ooberkante des vorherige Viewport.
goto FolgeBeEnde;
}
return;
}
finally
{
this.WindowOverviewVorherigMitZait = WindowOverviewNoiMitZait;
}
FolgeBeEnde:
EndeZait = WindowOverviewNoiMitZait.Zait;
return;
}
public SictOverviewPresetFolgeViewport(SictWertMitZait <VonSensor.WindowOverView> WindowOverviewMitZait)
{
AingangNääxte(WindowOverviewMitZait);
}
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);
}
}
/// <summary>
/// Extrahiirt Info aus AutomaatZuusctand und scpaicert diise naac Dict.
/// </summary>
/// <param name="AutomaatZuusctand"></param>
void ZuAutomaatZuusctandVonZaitMiliAblaitungScpaicere(
SictWertMitZait <Optimat.ScpezEveOnln.SictAutomatZuusctand> AutomaatZuusctand)
{
if (null == AutomaatZuusctand.Wert)
{
return;
}
var ReferenzZait = AutomaatZuusctand.Wert.NuzerZaitMili;
var ScnapscusAuswertungErgeebnis = AutomaatZuusctand.Wert.ListeScnapscusLezteAuswertungErgeebnisNaacSimu;
var ListeZuZaitVonNuzerMeldungNaacProcessWirkung = AutomaatZuusctand.Wert.ListeZuZaitVonNuzerMeldungNaacProcessWirkung;
if (null != ListeZuZaitVonNuzerMeldungNaacProcessWirkung)
{
base.VonNuzerMeldungNaacProcessWirkungFüügeAin(
ListeZuZaitVonNuzerMeldungNaacProcessWirkung
.Select((Element) => Element.Wert));
}
var FittingUndShipZuusctand = AutomaatZuusctand.Wert.FittingUndShipZuusctand;
/*
* 2014.10.15
*
* var OptimatScritAktuel = AutomaatZuusctand.Wert.OptimatScritAktuel;
*
* var OptimatScritVonProcessLeese =
* (null == OptimatScritAktuel) ? null :
* OptimatScritAktuel.VonZiilProcessLeeseSictAuswert ?? OptimatScritAktuel.VonZiilProcessLeese;
*
* var OptimatScritVonProcessLeeseBeginZaitNulbar = (null == OptimatScritVonProcessLeese) ? null : OptimatScritVonProcessLeese.BeginZait;
*
* if (!OptimatScritVonProcessLeeseBeginZaitNulbar.HasValue)
* {
* // Oone zaitlice Ainordnung werd nix gescpaicert.
* return;
* }
*
* var OptimatScritVonProcessLeeseBeginZait = OptimatScritVonProcessLeeseBeginZaitNulbar.Value;
* */
var OptimatScritAktuel = new SictOptimatScrit(AutomaatZuusctand.Wert.NuzerZaitMili, null);
var OptimatScritAbbild = SictOptimatScrit.OptimatScritSictFürBerict(OptimatScritAktuel, false);
OptimatScritAbbild.AnwendungZaitMili = OptimatScritAbbild.AnwendungZaitMili ?? AutomaatZuusctand.Wert.NuzerZaitMili;
/*
* 2014.10.15
*
* if (null != OptimatScritAktuel)
* {
* if (null != OptimatScritVonProcessLeese)
* {
* var VonProcessLeeseBeginZaitMili = OptimatScritVonProcessLeese.BeginZaitMili;
*
* if (VonProcessLeeseBeginZaitMili.HasValue)
* {
* DictZuNuzerZaitMiliAnwendungZaitMili[VonProcessLeeseBeginZaitMili.Value] = AutomaatZuusctand.Zait;
* }
* }
* }
* */
if (null != OptimatScritAktuel)
{
DictZuNuzerZaitMiliAnwendungZaitMili[ReferenzZait] = AutomaatZuusctand.Zait;
}
if (null != OptimatScritAbbild)
{
OptimatScritAbbild.AnwendungSizungIdent = AutomaatZuusctand.Wert.AnwendungSizungIdent;
var AutomaatZuusctandMengeZuClrTypeMengeInstanceAnzaal =
Bib3.RefNezDiferenz.SictRefNezDiferenz.ZuRefNezMengeClrTypeInstanceAnzaalBerecne(
new object[] { AutomaatZuusctand.Wert },
Optimat.ScpezEveOnln.SictAutomat.ZuusctandSictDiferenzSictParam.TypeBehandlungRictliinieMitScatescpaicer);
/*
* 2015.09.06
*
* OptimatScritAbbild.AutomaatZuusctandMengeZuClrTypeMengeInstanceAnzaal =
* AutomaatZuusctandMengeZuClrTypeMengeInstanceAnzaal.ToArrayNullable();
*/
var ScritNaacNuzerBerictAutomaatZuusctand = OptimatScritAbbild.NaacNuzerBerictAutomaatZuusctand;
if (null == ScritNaacNuzerBerictAutomaatZuusctand)
{
// OptimatScritAbbild.NaacNuzerBerictAutomaatZuusctand = ScritNaacNuzerBerictAutomaatZuusctand = new SictNaacNuzerBerictAutomaatZuusctand();
OptimatScritAbbild.NaacNuzerBerictAutomaatZuusctand = ScritNaacNuzerBerictAutomaatZuusctand = AutomaatZuusctand.Wert.NaacNuzerMeldungZuusctand;
}
}
lock (Lock)
{
DictZuAutomaatZaitMiliOptimatScrit[ReferenzZait] = OptimatScritAbbild;
}
base.ZuScritInfoFüügeAin(OptimatScritAbbild);
var AgentUndMissionInfo = AutomaatZuusctand.Wert.AgentUndMission;
if (null != AgentUndMissionInfo)
{
var MengeMission = AgentUndMissionInfo.MengeMission;
if (null != MengeMission)
{
foreach (var Mission in MengeMission)
{
if (null == Mission)
{
continue;
}
{
// Temp Verzwaigung Debug
if (Mission.EndeZaitMili().HasValue)
{
}
}
var MissionBezaicnerNulbar = Mission.Ident();
if (!MissionBezaicnerNulbar.HasValue)
{
continue;
}
var MissionBezaicner = MissionBezaicnerNulbar.Value;
var BisherMissionMitZait = Optimat.Glob.TAD(DictVonMissionBezaicnerMissionZuusctandLezte, MissionBezaicner);
var BisherMissionErhalte = false;
if (null != BisherMissionMitZait.Wert)
{
BisherMissionErhalte = AutomaatZuusctand.Zait < BisherMissionMitZait.Zait;
}
if (BisherMissionErhalte)
{
continue;
}
DictVonMissionBezaicnerMissionZuusctandLezte[MissionBezaicner] =
new SictWertMitZait <SictMissionZuusctand>(
AutomaatZuusctand.Zait, Mission);
}
}
}
}
override protected void NaacAingangScnapscus(
Int64 Zait,
VonSensor.OverviewZaile ScnapscusWert,
SictZuInRaumObjektReprScnapscusZuusazinfo ZuusazInfo)
{
var MengeZuEWarTypeTextureIdent = (null == ZuusazInfo) ? null : ZuusazInfo.MengeZuEWarTypeTextureIdent;
var OverviewPresetFolgeViewportFertigLezte = (null == ZuusazInfo) ? null : ZuusazInfo.OverviewPresetFolgeViewportFertigLezte;
var ScnapscusOverviewZaileMitZait = new SictWertMitZait <VonSensor.OverviewZaile>(Zait, ScnapscusWert);
var BisherOverviewZaileSictbarMitZaitLezte = this.OverviewZaileSictbarMitZaitLezte;
if (BisherOverviewZaileSictbarMitZaitLezte.HasValue)
{
if (BisherOverviewZaileSictbarMitZaitLezte.Value.Zait < Zait)
{
OverviewZaileSictbarMitZaitVorLezte = BisherOverviewZaileSictbarMitZaitLezte;
}
else
{
}
}
if (null != ScnapscusOverviewZaileMitZait.Wert)
{
OverviewZaileSictbarMitZaitLezte = ScnapscusOverviewZaileMitZait;
}
this.ScnapscusVorLezteOverviewTypeSelectionName = ScnapscusLezteOverviewTypeSelectionName;
this.ScnapscusLezteOverviewTypeSelectionName = ZuusazInfo.OverviewTypeSelectionName;
/*
* 2015.09.03 Änderung:
* Vorzuug berecnung SaitSictbarkaitLezteListeScritAnzaal.
*/
if (null == ScnapscusOverviewZaileMitZait.Wert)
{
++SaitSictbarkaitLezteListeScritAnzaal;
}
else
{
SaitSictbarkaitLezteListeScritAnzaal = 0;
}
AusListeScnapscusOverviewZaileBerecneAbgelaitete();
if (null == ScnapscusOverviewZaileMitZait.Wert)
{
/*
* 2015.09.03 Änderung:
* Vorzuug berecnung SaitSictbarkaitLezteListeScritAnzaal.
++SaitSictbarkaitLezteListeScritAnzaal;
*/
}
else
{
SaitSictbarkaitLezteListeScritAnzaal = 0;
var ScnapscusOverviewZaileAusOverviewZaile = ScnapscusOverviewZaileMitZait.Wert;
if (null != ScnapscusOverviewZaileAusOverviewZaile)
{
var setEWar =
Bib3.Extension.WhereNotNullSelectValue(
ScnapscusOverviewZaileAusOverviewZaile?.RightIcon?.Select(rightIcon => OverviewExtension.EWarTypeFromOverviewEntryRightIcon(rightIcon)))
?.ToArray();
var DictZuEWarTypeWirkungLezteZait = this.DictZuEWarTypeWirkungLezteZait;
foreach (var ewar in setEWar.EmptyIfNull())
{
if (null == DictZuEWarTypeWirkungLezteZait)
{
DictZuEWarTypeWirkungLezteZait = new Dictionary <EWarTypeEnum, Int64>();
}
DictZuEWarTypeWirkungLezteZait[ewar] = ScnapscusOverviewZaileMitZait.Zait;
}
this.DictZuEWarTypeWirkungLezteZait = DictZuEWarTypeWirkungLezteZait;
}
}
var DictZuOverviewPresetSictungLezteZait = this.DictZuOverviewPresetSictungLezteZait;
if (0 < SaitSictbarkaitLezteListeScritAnzaal)
{
if (null != OverviewPresetFolgeViewportFertigLezte && null != DictZuOverviewPresetSictungLezteZait)
{
var OverviewPresetFolgeViewportFertigLezteEndeObjektDistance = OverviewPresetFolgeViewportFertigLezte.EndeObjektDistance;
var MengeFolgeViewportAusscliisend = new List <SictOverviewPresetFolgeViewport>();
if (DictZuOverviewPresetSictungLezteZait.Any((Kandidaat) =>
string.Equals(Kandidaat.Key, OverviewPresetFolgeViewportFertigLezte.OverviewPresetName, StringComparison.InvariantCultureIgnoreCase)) &&
OverviewPresetFolgeViewportFertigLezte.BeginScrollHandleFläceGrenzeOobnAntailAnGesamtMili < 3 &&
OverviewPresetFolgeViewportFertigLezteEndeObjektDistance.HasValue)
{
AusViewportFolgeLezteDistanceScrankeMin = new SictWertMitZait <Int64>(
OverviewPresetFolgeViewportFertigLezte.BeginZait ?? -1,
OverviewPresetFolgeViewportFertigLezteEndeObjektDistance.Value);
}
}
}
else
{
AusViewportFolgeLezteDistanceScrankeMin = null;
}
{
// Des hiir sctimt nit, hiir werd noc nit ausgesclose das Objekt durc Scrole oder Wexel Tab sictbar gemact werde könt.
ScritLezteSictbarAusgesclose = 1 == SaitSictbarkaitLezteListeScritAnzaal;
}
base.NaacAingangScnapscus(Zait, ScnapscusWert, ZuusazInfo);
}
public void Berecne(ISictAutomatZuusctand AutomaatZuusctand)
{
var MengeZuTargetMesungSurveyScanListEntryUndErzMenge =
new List <KeyValuePair <SictTargetZuusctand, SictWertMitZait <KeyValuePair <GbsListGroupedEntryZuusctand, Int64> > > >();
try
{
if (null == AutomaatZuusctand)
{
return;
}
var MengeZuListEntryTargetPerDistance = AutomaatZuusctand.MengeZuListEntryTargetAinscrankungPerDistance();
var OverviewUndTarget = AutomaatZuusctand.OverviewUndTarget;
var Gbs = AutomaatZuusctand.Gbs;
if (null == OverviewUndTarget)
{
return;
}
if (null == Gbs)
{
return;
}
WindowSurveyScanView = Gbs.WindowSurveyScanView();
MengeTargetNocSictbar = OverviewUndTarget.MengeTargetNocSictbar.ToArrayNullable();
if (null == WindowSurveyScanView)
{
return;
}
var WindowSurveyScanViewList = WindowSurveyScanView.ListHaupt;
if (null == WindowSurveyScanViewList)
{
return;
}
var WindowSurveyScanViewListListeEntry = WindowSurveyScanViewList.ListeEntry();
if (null == MengeTargetNocSictbar)
{
return;
}
foreach (var TargetNocSictbar in MengeTargetNocSictbar)
{
SictWertMitZait <GbsListGroupedEntryZuusctand> ZuZaitSurveyScanEntry = default(SictWertMitZait <GbsListGroupedEntryZuusctand>);
{
var ZuTargetIndikatorLezte =
ListeIndikatorZuTargetSurveyScanListEntry
.LastOrDefaultNullable((Kandidaat) => Kandidaat.Wert.Key == TargetNocSictbar);
/*
* 2014.09.25
*
* if (null == ZuTargetIndikatorLezte.Wert.Key)
* {
* continue;
* }
*
* var SurveyScanEntry = ZuTargetIndikatorLezte.Wert.Value;
* */
if (null != ZuTargetIndikatorLezte.Wert.Key)
{
ZuZaitSurveyScanEntry = new SictWertMitZait <GbsListGroupedEntryZuusctand>(ZuTargetIndikatorLezte.Zait, ZuTargetIndikatorLezte.Wert.Value);
}
}
if (null != MengeZuListEntryTargetPerDistance)
{
var TailmengeListEntryAingescranktDurcDistance =
WindowSurveyScanViewListListeEntry
.WhereNullable((KandidaatListEntry) =>
{
var ZuListEntryInfoAinscrankungDistance =
MengeZuListEntryTargetPerDistance.FirstOrDefault((KandidaatZuListEntryInfoAinscrankungDistance) =>
KandidaatZuListEntryInfoAinscrankungDistance.ListEntry == KandidaatListEntry);
if (null == ZuListEntryInfoAinscrankungDistance)
{
// Ainscrankung zu diise ListEntry noc nit berecnet.
return(true);
}
return(ZuListEntryInfoAinscrankungDistance.MengeInRaumObjekt.ContainsNullable((TargetNocSictbar)));
})
.ToArrayNullable();
if (1 == TailmengeListEntryAingescranktDurcDistance.CountNullable())
{
var SurveyScanEntry = TailmengeListEntryAingescranktDurcDistance.First();
ZuZaitSurveyScanEntry =
new SictWertMitZait <GbsListGroupedEntryZuusctand>(SurveyScanEntry.ScnapscusFrühesteZait ?? -1, SurveyScanEntry);
}
}
if (null == ZuZaitSurveyScanEntry.Wert)
{
continue;
}
if (!(WindowSurveyScanView.ScnapscusFrühesteZait <= ZuZaitSurveyScanEntry.Wert.AingangUnglaicDefaultLezteZait))
{
continue;
}
var Quantity = ZuZaitSurveyScanEntry.Wert.Quantity;
if (!Quantity.HasValue)
{
continue;
}
MengeZuTargetMesungSurveyScanListEntryUndErzMenge.Add(
new KeyValuePair <SictTargetZuusctand, SictWertMitZait <KeyValuePair <GbsListGroupedEntryZuusctand, Int64> > >(
TargetNocSictbar,
new SictWertMitZait <KeyValuePair <GbsListGroupedEntryZuusctand, Int64> >(
ZuZaitSurveyScanEntry.Zait,
new KeyValuePair <GbsListGroupedEntryZuusctand, Int64>(ZuZaitSurveyScanEntry.Wert, Quantity.Value))));
}
}
finally
{
this.MengeZuTargetMesungSurveyScanListEntryUndErzMenge = MengeZuTargetMesungSurveyScanListEntryUndErzMenge.ToArray();
}
}
protected bool ZuScritInfoFüügeAin(
SictOptimatScrit OptimatScrit)
{
if (null == OptimatScrit)
{
return(false);
}
var NaacProcessListeWirkung = OptimatScrit.NaacProcessListeWirkung;
if (null != NaacProcessListeWirkung)
{
VonNuzerMeldungNaacProcessWirkungFüügeAin(NaacProcessListeWirkung);
}
var OptimatScritNuzerZait = OptimatScrit.NuzerZait;
var ScritAutomaatZuusctand = OptimatScrit.NaacNuzerBerictAutomaatZuusctand as SictVonOptimatMeldungZuusctand;
var BisherAnwendungSizungIdent = this.AnwendungSizungIdent;
var OptimatScritAnwendungSizungIdent = OptimatScrit.AnwendungSizungIdent;
if (null == BisherAnwendungSizungIdent)
{
this.AnwendungSizungIdent = OptimatScritAnwendungSizungIdent;
}
else
{
if (!Bib3.Glob.SequenceEqualPerObjectEquals(BisherAnwendungSizungIdent, OptimatScritAnwendungSizungIdent))
{
return(false);
}
}
lock (Lock)
{
if (null == OptimatScrit.ProcessWindowClientRasterIdentUndSuuceHinwais)
{
var ProcessWindowClientRasterIdentUndSuuceHinwais = this.ZuNuzerZaitMiliWindowClientRasterSuuceHinwaisBerecne(OptimatScritNuzerZait);
OptimatScrit.ProcessWindowClientRasterIdentUndSuuceHinwais = ProcessWindowClientRasterIdentUndSuuceHinwais;
if (null == ProcessWindowClientRasterIdentUndSuuceHinwais)
{
ListeZaitpunktOptimatScritOoneWindowClientRasterIdent.Add(OptimatScritNuzerZait);
}
}
{
bool ListeNaacProcessWirkungGeändert;
bool ListeNaacProcessWirkungVolsctändig;
var OptimatScritListeNaacProcessWirkung = FürOptimatScritListeNaacProcessWirkungBerecne(
OptimatScrit,
out ListeNaacProcessWirkungGeändert,
out ListeNaacProcessWirkungVolsctändig);
if (ListeNaacProcessWirkungGeändert)
{
OptimatScrit.NaacProcessListeWirkung = OptimatScritListeNaacProcessWirkung;
// ZuScritInfoFüügeAin(OptimatScrit);
}
if (!ListeNaacProcessWirkungVolsctändig)
{
ListeZaitpunktOptimatScritOoneNaacProcessWirkung.Add(OptimatScritNuzerZait);
}
}
var ScritAnwendungZaitMiliNulbar = OptimatScrit.AnwendungZaitMili;
if (ScritAnwendungZaitMiliNulbar.HasValue)
{
DictZuNuzerZaitMiliAnwendungZaitMili[OptimatScritNuzerZait] = ScritAnwendungZaitMiliNulbar.Value;
}
Optimat.Glob.InListeOrdnetFüügeAin(
ListeZuVonProcessLeeseBeginZaitScritInfo,
(t) => t.Key,
new KeyValuePair <Int64, SictOptimatScrit>(
OptimatScritNuzerZait, OptimatScrit), OptimatScritNuzerZait);
BerictBeginNuzerZaitMili = Bib3.Glob.Min(BerictBeginNuzerZaitMili, OptimatScritNuzerZait);
BerictEndeNuzerZaitMili = Bib3.Glob.Max(BerictEndeNuzerZaitMili, OptimatScritNuzerZait);
if (null != ScritAutomaatZuusctand)
{
var MengeMission = ScritAutomaatZuusctand.MengeMission;
if (null != MengeMission)
{
foreach (var Mission in MengeMission)
{
if (null == Mission)
{
continue;
}
var MissionBezaicnerNulbar = (Int64?)Mission.Ident;
if (!MissionBezaicnerNulbar.HasValue)
{
continue;
}
var MissionBezaicner = MissionBezaicnerNulbar.Value;
var BisherMissionMitZait = Optimat.Glob.TAD(DictZuMissionBezaicnerMissionZuusctandLezte, MissionBezaicner);
var BisherMissionErhalte = false;
if (null != BisherMissionMitZait.Wert)
{
BisherMissionErhalte = OptimatScritNuzerZait < BisherMissionMitZait.Zait;
}
if (!BisherMissionErhalte)
{
DictZuMissionBezaicnerMissionZuusctandLezte[MissionBezaicner] =
new SictWertMitZait <SictMissionZuusctand>(
OptimatScritNuzerZait, Mission);
}
}
}
}
return(true);
}
}
void EveOnlnWirkungKümere()
{
var BeginZaitMikro = Bib3.Glob.StopwatchZaitMikroSictInt();
var BeginZaitMili = BeginZaitMikro / 1000;
if (null != VorsclaagWirkungAusfüürungTask.Wert)
{
if (!VorsclaagWirkungAusfüürungTask.Wert.IsCompleted &&
!VorsclaagWirkungAusfüürungTask.Wert.IsCanceled &&
!VorsclaagWirkungAusfüürungTask.Wert.IsFaulted)
{
// Vorheriger VorsclaagWirkungAusfüürungTask noc aktiiv.
var VorsclaagWirkungAusfüürungTaskAlterMili = BeginZaitMili - VorsclaagWirkungAusfüürungTask.Zait;
if (VorsclaagWirkungAusfüürungTaskAlterMili < 44444)
{
return;
}
}
}
var GbsAingaabeWaalZiilProzesWindowHandle = this.GbsAingaabeWaalZiilProcessMainWindowHandle;
var GbsAingaabeEveOnlnAutoFraigaabe = this.GbsAingaabeEveOnlnWirkungFraigaabe;
if (!GbsAingaabeEveOnlnAutoFraigaabe)
{
return;
}
if (IntPtr.Zero == GbsAingaabeWaalZiilProzesWindowHandle)
{
return;
}
/*
* 2015.03.03
*
* var EveOnlnSensoScnapscusAuswertLezteFertig = this.EveOnlnSensoScnapscusAuswertLezteFertig;
* */
var VonOptimatMeldungZuusctandLezte = this.VonOptimatMeldungZuusctandLezte as Optimat.EveOnline.Base.VonAutomatMeldungZuusctand;
if (null == VonOptimatMeldungZuusctandLezte)
{
return;
}
var Task = new Task(() =>
{
lock (LockWirkung)
{
var VorsclaagListeWirkung =
VonOptimatMeldungZuusctandLezte.VorsclaagListeWirkung
.WhereNullable((KandidaatVorsclaagWirkung) =>
!(ListeNaacProcessWirkung
.AnyNullable((KandidaatWirkung) => KandidaatWirkung.VorsclaagWirkungIdent == KandidaatVorsclaagWirkung.Ident) ?? false))
.ToArrayNullable();
if (VorsclaagListeWirkung.NullOderLeer())
{
return;
}
var ScritListeNaacProcessWirkung = ScritWirkungFüüreAus(
VorsclaagListeWirkung,
GbsAingaabeWaalZiilProzesWindowHandle);
if (!ScritListeNaacProcessWirkung.NullOderLeer())
{
this.ListeNaacProcessWirkung =
Bib3.Glob.ListeEnumerableAgregiirt(
this.ListeNaacProcessWirkung,
ScritListeNaacProcessWirkung)
.Reversed()
.Take(10)
.Reversed()
.ToArrayNullable();
}
}
});
VorsclaagWirkungAusfüürungTask = new SictWertMitZait <Task>(BeginZaitMili, Task);
Task.Start();
}
abstract public long?NuzerAlterMili <T>(SictWertMitZait <T>?WertMitZaitNuzer);
public void MenuEntryAktiviirtLezteMitZaitSeze(SictWertMitZait <VonSensor.MenuEntry> MenuEntryAktiviirtLezteMitZait)
{
this.MenuEntryAktiviirtLezteMitZait = MenuEntryAktiviirtLezteMitZait;
AnnaameMenuEntryAktiivAktualisiire();
}
static public Int64 BetraagSumeInIntervalBerecne(
Int64 IntervalBeginInklusiiv,
Int64 IntervalEndeExklussiv,
IEnumerable <SictWertMitZait <Int64> > ListeMespunkt)
{
if (null == ListeMespunkt)
{
return(0);
}
if (IntervalEndeExklussiv == IntervalBeginInklusiiv)
{
return(0);
}
if (IntervalEndeExklussiv < IntervalBeginInklusiiv)
{
return(-BetraagSumeInIntervalBerecne(IntervalEndeExklussiv, IntervalBeginInklusiiv, ListeMespunkt));
}
var Enumerator = ListeMespunkt.GetEnumerator();
SictWertMitZait <Int64>?MespunktFrüheste = null;
SictWertMitZait <Int64>?MespunktLezte = null;
Int64 Sume = 0;
while (Enumerator.MoveNext())
{
var Mespunkt = Enumerator.Current;
if (!MespunktFrüheste.HasValue)
{
MespunktFrüheste = Mespunkt;
var VorMespunktFrühesteIntervalLänge =
Math.Min(IntervalEndeExklussiv, Mespunkt.Zait) - IntervalBeginInklusiiv;
if (0 < VorMespunktFrühesteIntervalLänge)
{
Sume = VorMespunktFrühesteIntervalLänge * Mespunkt.Wert;
}
}
if (MespunktLezte.HasValue)
{
var ZwisceMespunktScnitIntervalBegin =
Math.Max(IntervalBeginInklusiiv, MespunktLezte.Value.Zait);
var ZwisceMespunktScnitIntervalEnde =
Math.Min(IntervalEndeExklussiv, Mespunkt.Zait);
var ScnitLänge =
ZwisceMespunktScnitIntervalEnde - ZwisceMespunktScnitIntervalBegin;
if (0 < ScnitLänge)
{
var ZwisceMespunktBetraagDiferenz = Mespunkt.Wert - MespunktLezte.Value.Wert;
var ZwisceMespunktScnitIntervalBeginBetraag =
MespunktLezte.Value.Wert + ((ZwisceMespunktBetraagDiferenz * (ZwisceMespunktScnitIntervalBegin - MespunktLezte.Value.Zait)) / ScnitLänge);
var ZwisceMespunktScnitIntervalEndeBetraag =
MespunktLezte.Value.Wert + ((ZwisceMespunktBetraagDiferenz * (ZwisceMespunktScnitIntervalEnde - MespunktLezte.Value.Zait)) / ScnitLänge);
var InScnitBetraag =
(ZwisceMespunktScnitIntervalBeginBetraag + ZwisceMespunktScnitIntervalEndeBetraag) * ScnitLänge / 2;
Sume += InScnitBetraag;
}
}
if (IntervalEndeExklussiv <= Mespunkt.Zait)
{
break;
}
MespunktLezte = Mespunkt;
}
if (MespunktLezte.HasValue)
{
var NaacMespunktLezteIntervalLänge =
IntervalEndeExklussiv - Math.Max(IntervalBeginInklusiiv, MespunktLezte.Value.Zait);
if (0 < NaacMespunktLezteIntervalLänge)
{
Sume += NaacMespunktLezteIntervalLänge * MespunktLezte.Value.Wert;
}
}
return(Sume);
}
