Exemple #1
0
        public void Serialize()
        {
            //CSharpCodeProvider.cre
            CSharpCodeProvider prov = new CSharpCodeProvider(new Dictionary <string, string>()
            {
                { "CompilerVersion", "v4.0" }
            });

            CompilerParameters cp = new CompilerParameters(new []
            {
                "mscorlib.dll", "System.dll", "System.IO.dll", "System.xml.dll", "System.Xml.Serializer.dll", "System.Runtime.dll",
                "System.ObjectModel.dll", "System.Collections.dll",
                "FileExplorer3.dll", "FileExplorer3.IO.dll", "FileExplorer3.WPF.dll",
                "Caliburn.Micro.dll", "Caliburn.Micro.Platform.dll"
            });

            cp.GenerateExecutable = false;
            cp.GenerateInMemory   = true;

            Progress.Clear();

            CompilerResults cr = prov.CompileAssemblyFromSource(cp, Script);

            if (cr.Errors.HasErrors)
            {
                Progress.Add("Error when serializing:");
                cr.Errors.Cast <CompilerError>().ToList().ForEach(err =>
                                                                  Progress.Add(String.Format("{0} at line {1} column {2} ", err.ErrorText, err.Line, err.Column)));
            }
        }
Exemple #2
0
        /// <summary>
        ///     Updates the engine's progress
        /// </summary>
        /// <param name="deltaTime"></param>
        public void Update(double deltaTime)
        {
            if (!Initialized)
            {
                return;
            }

            var keyframes = LayerProperty.UntypedKeyframes.ToList();

            Progress = Progress.Add(TimeSpan.FromMilliseconds(deltaTime));

            // The current keyframe is the last keyframe before the current time
            CurrentKeyframe = keyframes.LastOrDefault(k => k.Position <= Progress);
            // The next keyframe is the first keyframe that's after the current time
            NextKeyframe = keyframes.FirstOrDefault(k => k.Position > Progress);

            if (CurrentKeyframe == null)
            {
                KeyframeProgress      = 0;
                KeyframeProgressEased = 0;
            }
            else if (NextKeyframe == null)
            {
                KeyframeProgress      = 1;
                KeyframeProgressEased = 1;
            }
            else
            {
                var timeDiff = NextKeyframe.Position - CurrentKeyframe.Position;
                KeyframeProgress      = (float)((Progress - CurrentKeyframe.Position).TotalMilliseconds / timeDiff.TotalMilliseconds);
                KeyframeProgressEased = (float)Easings.Interpolate(KeyframeProgress, CurrentKeyframe.EasingFunction);
            }

            // LayerProperty determines what's next: reset, stop, continue
        }
Exemple #3
0
 public void Update(IEnumerable <LevelProgressDto> collection)
 {
     Progress.Clear();
     foreach (var model in collection)
     {
         Progress.Add(model);
     }
 }
Exemple #4
0
        public void WriteProgress(long sourceId, ProgressRecord progressRecord)
        {
            CheckForCancellation();

            if (Progress.IsOpen && Progress.Count < MaxRecords)
            {
                Progress.Add(progressRecord);
            }
        }
Exemple #5
0
 /// <summary>
 /// Updates the progress for this task, a notification is sent to the client
 /// </summary>
 /// <param name="value">The value to add to the progress</param>
 /// <example>
 /// If the player were to obtain a certain amount of collectibles, <c>value</c> might be the item lot here.
 /// </example>
 protected void AddProgress(float value)
 {
     if (this.Mission.Player.TryGetComponent <MissionInventoryComponent>(out var missionInventoryComponent) && !MissionParser.CheckPrerequiredMissions(this.Mission.PrerequisiteMissions, missionInventoryComponent.AllMissions))
     {
         return;
     }
     Progress.Add(value);
     MessageUpdateMissionTask();
 }
Exemple #6
0
        private void LoadData()
        {
            foreach (string file in _files)
            {
                if (!File.Exists(file))
                {
                    continue;
                }
                DataGetter data = new DataGetter(file);
                Type       t    = data.GetTypeFromData();

                if (t == typeof(CaseProgress))
                {
                    Progress.Add(file, (CaseProgress)data.ConvertToObject());
                }
                if (t == typeof(CSIData))
                {
                    CSIData.Add(file, (CSIData)data.ConvertToObject());
                }
                if (t == typeof(CurrentCaseData))
                {
                    CurrentData.Add(file, (CurrentCaseData)data.ConvertToObject());
                }
                if (t == typeof(EntityData))
                {
                    EntityData.Add(file, (EntityData)data.ConvertToObject());
                }
                if (t == typeof(EvidenceData))
                {
                    EvidenceData.Add(file, (EvidenceData)data.ConvertToObject());
                }
                if (t == typeof(InterrogationData))
                {
                    InterrogationData.Add(file, (InterrogationData)data.ConvertToObject());
                }
                if (t == typeof(SceneData))
                {
                    SceneData.Add(file, (SceneData)data.ConvertToObject());
                }
                if (t == typeof(StageData))
                {
                    StageData.Add(file, (StageData)data.ConvertToObject());
                }
                if (t == typeof(WrittenData))
                {
                    WrittenData.Add(file, (WrittenData)data.ConvertToObject());
                }
            }
        }
        Tuple <double[][], double[][]> PlayTrainingGame(ActivationNetwork net, bool aiX, bool fullAi)
        {
            TicTacToeGame   game    = new TicTacToeGame();
            List <double[]> inputs  = new List <double[]>();
            List <double[]> outputs = new List <double[]>();

            Model current = new Model(net);

            while (game.GetResult() == TicTacToeGame.Result.Unknown)
            {
                int playSquare;

                if (aiX == game.IsXTurn || fullAi)
                {
                    playSquare = current.BestSquare(game);
                }
                else
                {
                    int[] validSquares = game.ValidSquares().ToArray();
                    playSquare = validSquares[rand.Next(validSquares.Length)];
                }

                game.Move(playSquare);
                inputs.Add(game.GetBoardAsDouble(!game.IsXTurn));
            }

            double output;

            TicTacToeGame.Result result = game.GetResult();
            if (result == TicTacToeGame.Result.XWins)
            {
                output = 1;
            }
            else if (result == TicTacToeGame.Result.OWins)
            {
                output = -1;
            }
            else
            {
                output = 0;
            }
            for (int i = 0; i < inputs.Count; i++)
            {
                outputs.Add(new double[] { output *(i % 2 == 0 ? 1 : -1) });
            }
            Progress.Add(fullAi ? result == TicTacToeGame.Result.Tie : (aiX ? result == TicTacToeGame.Result.XWins : result == TicTacToeGame.Result.OWins));
            return(new Tuple <double[][], double[][]>(inputs.ToArray(), outputs.ToArray()));
        }
        private void TrackProgressExecute(object obj)
        {
            var progressModel = new ProgressModel {
                GoalId = SelectedGoal.GoalId, Date = DateTime.Now
            };
            var newProgessViewModel = new AddProgressViewModel(progressModel, _client);

            var dialog = new TrackProgress();

            dialog.DataContext = newProgessViewModel;
            var result = dialog.ShowDialog();

            if (result.GetValueOrDefault())
            {
                Progress.Add(new ProgressViewModel(SelectedGoal, newProgessViewModel.Progress));
            }
        }
Exemple #9
0
        public void Set(int level, LevelProgressDto progress)
        {
            var current = Get(level);

            if (current != null)
            {
                if (current.Stars < progress.Stars)
                {
                    current.Stars            = progress.Stars;
                    current.Seconds          = progress.Seconds;
                    current.ObjectsCollected = progress.ObjectsCollected;
                }
            }
            else
            {
                Progress.Add(progress);
            }
        }
Exemple #10
0
        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);

            int version = reader.ReadEncodedInt();

            var count = reader.ReadInt();

            for (int i = 0; i < count; i++)
            {
                Path.Add(reader.ReadInt());
            }

            count = reader.ReadInt();

            for (int i = 0; i < count; i++)
            {
                Progress.Add(reader.ReadInt());
            }
        }
Exemple #11
0
    protected void btnSave_Click(object sender, System.EventArgs e)
    {
        string text        = this.txtProgressName.Text.Trim();
        string note        = this.txtArea.Text.Trim();
        string versionCode = this.txtVersionCode.Text.Trim();
        bool   @checked    = this.chkIsMainPlan.Checked;

        if (this.action == "add")
        {
            Progress progress = Progress.Creat(System.Guid.NewGuid().ToString(), new System.Guid(this.prjId), text, versionCode, @checked, base.UserCode, System.DateTime.Now, note);
            progress.Add(progress);
        }
        else
        {
            if (this.action == "edit")
            {
                Progress.Update(this.planId, text, versionCode, @checked, note);
            }
        }
        base.RegisterScript("top.ui.winSuccess({ parentName: '_editplan' }); ");
    }
 protected virtual void OnProgress(ProgressRecord progress)
 {
     Progress.Add(progress);
 }
Exemple #13
0
        public static async Task Move(Config config, TraceWriter log)
        {
            var metadata = await Timer.Time(() => MetadataReader.GetMetadata(config.ConnectionString, config.Period), "Fetching metadata", log);

            // Ignore duplicates until further
            var imsTagToId  = metadata.ims.GroupBy(x => x.Tag).Where(x => x.Count() == 1).Select(x => x.First()).ToDictionary(x => x.Tag, x => x.Id);
            var calcTagToId = metadata.calc.Where(x => !string.IsNullOrWhiteSpace(x.Tag)).GroupBy(x => x.Tag).Where(x => x.Count() == 1).Select(x => x.First()).ToDictionary(x => x.Tag, x => x.Id);

            var imsMetas  = metadata.ims.Where(i => imsTagToId.ContainsKey(i.Tag)).ToList();
            var calcMetas = metadata.calc.Where(i => !string.IsNullOrWhiteSpace(i.Tag) && calcTagToId.ContainsKey(i.Tag)).ToList();

            log.Info($"IMS Initial Tag Count: {imsMetas.Count}, Ignored: {metadata.ims.Count - imsMetas.Count}");
            log.Info($"Calc Initial Tag Count: {calcMetas.Count}, Ignored: {metadata.calc.Count - calcMetas.Count}");

            var influxQueryExecutor = new InfluxQueryExecutor(config.InfluxConfig);
            var imsEntityCreator    = new EntityCreator(imsTagToId);
            var calcEntityCreator   = new EntityCreator(calcTagToId);

            var imsFirstTimerMetas = imsMetas.Where(m => !m.Timestamp.HasValue).ToList();
            var imsOldTimerMetas   = imsMetas.Where(m => m.Timestamp.HasValue).ToList();

            var calcFirstTimerMetas = calcMetas.Where(m => !m.Timestamp.HasValue).ToList();
            var calcOldTimerMetas   = calcMetas.Where(m => m.Timestamp.HasValue).ToList();

            var imsTagsWithTimestampBeforeWatermarkTask = Timer.Time(() => GetOutliers(influxQueryExecutor, imsMetas,
                                                                                       config.InfluxConfig.DbImsRetentionPolicy, config.InfluxConfig.DbImsMeasurement, TagTypes.Ims,
                                                                                       config.InfluxConfig.DefaultTime, config.InfluxConfig.DoAdHocResampling, log, true),
                                                                     "Getting timestamp before watermark IMS tags", log);

            var calcTagsWithTimestampBeforeWatermarkTask = Timer.Time(() => GetOutliers(influxQueryExecutor, calcMetas,
                                                                                        config.InfluxConfig.DbCalcRetentionPolicy, config.InfluxConfig.DbCalcMeasurement, TagTypes.Calc,
                                                                                        config.InfluxConfig.DefaultTime, config.InfluxConfig.DoAdHocResampling, log, true),
                                                                      "Getting timestamp before watermark for Calc tags", log);

            var imsTagsWithLastTimestampTask = Timer.Time(() => GetOutliers(influxQueryExecutor, imsMetas,
                                                                            config.InfluxConfig.DbImsRetentionPolicy, config.InfluxConfig.DbImsMeasurement, TagTypes.Ims,
                                                                            config.InfluxConfig.DefaultTime, config.InfluxConfig.DoAdHocResampling, log, false),
                                                          "Getting last timestamps for IMS tags", log);

            var calcTagsWithLastTimestampTask = Timer.Time(() => GetOutliers(influxQueryExecutor, calcMetas,
                                                                             config.InfluxConfig.DbCalcRetentionPolicy, config.InfluxConfig.DbCalcMeasurement, TagTypes.Calc,
                                                                             config.InfluxConfig.DefaultTime, config.InfluxConfig.DoAdHocResampling, log, false),
                                                           "Getting last timestamps for Calc tags", log);

            await Task.WhenAll(imsTagsWithLastTimestampTask, calcTagsWithLastTimestampTask, imsTagsWithTimestampBeforeWatermarkTask, calcTagsWithTimestampBeforeWatermarkTask);

            var imsTagsWithLastTimestamp             = imsTagsWithLastTimestampTask.Result;
            var calcTagsWithLastTimestamp            = calcTagsWithLastTimestampTask.Result;
            var imsTagsWithTimestampBeforeWatermark  = imsTagsWithTimestampBeforeWatermarkTask.Result;
            var calcTagsWithTimestampBeforeWatermark = calcTagsWithTimestampBeforeWatermarkTask.Result;

            var imsFirstTimers = imsFirstTimerMetas
                                 .Where(i => imsTagsWithLastTimestamp.ContainsKey(i.Tag))
                                 .Select(m => new TsMetadata
            {
                Id = m.Id,
                LastTimestampAfterWatermark = imsTagsWithLastTimestamp[m.Tag].timestamp,
                LastValueAfterWatermark     = imsTagsWithLastTimestamp[m.Tag].value,
                Tag = m.Tag
            }).ToList();

            var calcFirstTimers = calcFirstTimerMetas
                                  .Where(c => calcTagsWithLastTimestamp.ContainsKey(c.Tag))
                                  .Select(m => new TsMetadata
            {
                Id = m.Id,
                LastTimestampAfterWatermark = calcTagsWithLastTimestamp[m.Tag].timestamp,
                LastValueAfterWatermark     = calcTagsWithLastTimestamp[m.Tag].value,
                Tag = m.Tag
            }).ToList();

            var imsOldTimers = imsOldTimerMetas
                               .Where(i => imsTagsWithLastTimestamp.ContainsKey(i.Tag))
                               .Select(i => new TsMetadata
            {
                Id = i.Id,
                LastTimestampAfterWatermark  = imsTagsWithLastTimestamp[i.Tag].timestamp,
                LastValueAfterWatermark      = imsTagsWithLastTimestamp[i.Tag].value,
                LastTimestampBeforeWatermark = imsTagsWithTimestampBeforeWatermark.ContainsKey(i.Tag) ? imsTagsWithTimestampBeforeWatermark[i.Tag].timestamp : default(DateTime?),
                LastValueBeforeWatermark     = imsTagsWithTimestampBeforeWatermark.ContainsKey(i.Tag) ? imsTagsWithTimestampBeforeWatermark[i.Tag].value : default(double?),
                Tag       = i.Tag,
                Watermark = i.Timestamp
            }).ToList();

            var calcOldTimers = calcOldTimerMetas
                                .Where(c => calcTagsWithLastTimestamp.ContainsKey(c.Tag))
                                .Select(c => new TsMetadata
            {
                Id = c.Id,
                LastTimestampAfterWatermark  = calcTagsWithLastTimestamp[c.Tag].timestamp,
                LastValueAfterWatermark      = calcTagsWithLastTimestamp[c.Tag].value,
                LastTimestampBeforeWatermark = calcTagsWithTimestampBeforeWatermark.ContainsKey(c.Tag) ? calcTagsWithTimestampBeforeWatermark[c.Tag].timestamp : default(DateTime?),
                LastValueBeforeWatermark     = calcTagsWithTimestampBeforeWatermark.ContainsKey(c.Tag) ? calcTagsWithTimestampBeforeWatermark[c.Tag].value : default(double?),
                Tag       = c.Tag,
                Watermark = c.Timestamp
            }).ToList();

            var imsHasLastBeforeWatermark  = imsOldTimers.Where(ot => ot.LastTimestampBeforeWatermark.HasValue).ToList();
            var calcHasLastBeforeWatermark = calcOldTimers.Where(ot => ot.LastTimestampBeforeWatermark.HasValue).ToList();

            log.Info($"IMS FirstTimer Data Filtered Count: {imsFirstTimers.Count}");
            log.Info($"IMS OldTimer Data Filtered Count: {imsOldTimers.Count}");
            log.Info($"Calc FirstTimer Data Filtered Count: {calcFirstTimers.Count}");
            log.Info($"Calc OldTimer Data Filtered Count: {calcOldTimers.Count}");

            int totalCount = imsOldTimers.Count + calcOldTimers.Count + imsFirstTimers.Count + calcFirstTimers.Count;

            log.Info($"Total Data Filtered Count: {totalCount}");

            var progress = new Progress();

            const string calcIdName    = "CalculatedTag_ID";
            const string calcTableName = "dbo.CalculatedTS";
            const string imsIdName     = "IMSTag_ID";
            const string imsTableName  = "dbo.IMSTS";

            // Serve oldtimers first
            progress.Add(await ProcessMetas(config.ConnectionString, imsIdName, imsTableName, config.InfluxConfig.DbImsRetentionPolicy,
                                            config.InfluxConfig.DbImsMeasurement, TagTypes.Ims, config.InfluxConfig.DefaultTime,
                                            config.InfluxConfig.DoAdHocResampling, config.InfluxConfig.SkipLastPoint,
                                            config.Period, imsOldTimers, config.InfluxConfig.OldtimerBatchSize, config.InfluxConfig.Parallelism, influxQueryExecutor,
                                            imsEntityCreator, progress.ProcessedTags, "IMS Oldtimers", imsOldTimers.Count, totalCount, log));

            progress.Add(await ProcessMetas(config.ConnectionString, calcIdName, calcTableName, config.InfluxConfig.DbCalcRetentionPolicy,
                                            config.InfluxConfig.DbCalcMeasurement, TagTypes.Calc, config.InfluxConfig.DefaultTime,
                                            config.InfluxConfig.DoAdHocResampling, config.InfluxConfig.SkipLastPoint,
                                            config.Period, calcOldTimers, config.InfluxConfig.OldtimerBatchSize, config.InfluxConfig.Parallelism, influxQueryExecutor,
                                            calcEntityCreator, progress.ProcessedTags, "Calc Oldtimers", calcOldTimers.Count, totalCount, log));

            progress.Add(await ProcessMetas(config.ConnectionString, imsIdName, imsTableName, config.InfluxConfig.DbImsRetentionPolicy,
                                            config.InfluxConfig.DbImsMeasurement, TagTypes.Ims, config.InfluxConfig.DefaultTime,
                                            config.InfluxConfig.DoAdHocResampling, config.InfluxConfig.SkipLastPoint,
                                            config.Period, imsFirstTimers, config.InfluxConfig.FirsttimerBatchSize, config.InfluxConfig.Parallelism / 2, influxQueryExecutor,
                                            imsEntityCreator, progress.ProcessedTags, "IMS Firsttimers", imsFirstTimers.Count, totalCount, log));

            progress.Add(await ProcessMetas(config.ConnectionString, calcIdName, calcTableName, config.InfluxConfig.DbCalcRetentionPolicy,
                                            config.InfluxConfig.DbCalcMeasurement, TagTypes.Calc, config.InfluxConfig.DefaultTime,
                                            config.InfluxConfig.DoAdHocResampling, config.InfluxConfig.SkipLastPoint,
                                            config.Period, calcFirstTimers, config.InfluxConfig.FirsttimerBatchSize, config.InfluxConfig.Parallelism / 2, influxQueryExecutor,
                                            calcEntityCreator, progress.ProcessedTags, "Calc Firsttimers", calcFirstTimers.Count, totalCount, log));

            log.Info($"Processed points: {progress.ProcessedPoints}");
        }
Exemple #14
0
 public Task OnProgressAsync(AssetUploadProgressEvent @event,
                             CancellationToken ct)
 {
     Progress.Add(@event.Progress);
     return(Task.CompletedTask);
 }
 protected void DoAddProgress(ProgressRecord progress)
 {
     Progress.Add(progress);
 }