示例#1
0
        public override void Initialize(PlayerTimersGroup parentGroup, string player, TimerDefinition definition)
        {
            base.Initialize(parentGroup, player, definition);
            View.SetCooldown(pathCooldown);

            skillEntryParser = new SkillEntryParser(WurmApi);

            MoreOptionsAvailable = true;

            PerformAsyncInits();
        }
示例#2
0
        public override void Initialize(PlayerTimersGroup parentGroup, string player, TimerDefinition definition)
        {
            base.Initialize(parentGroup, player, definition);
            View.SetCooldown(PrayCooldown);
            MoreOptionsAvailable = true;

            skillEntryParser = new SkillEntryParser(WurmApi);

            favorNotify = new FavorTimerNotify(this, Character, ServerGroupId, Logger, SoundManager, TrayPopups, skillEntryParser);

            View.UpdateSkill(FaithLevel);
            View.ShowSkill = ShowFaithSkillOnTimer;

            PerformAsyncInits();
        }
示例#3
0
        public CombatResultsProcessor(CombatStatus combatStatus, ILogger logger, IWurmApi wurmApi)
        {
            if (combatStatus == null)
            {
                throw new ArgumentNullException("combatStatus");
            }
            if (logger == null)
            {
                throw new ArgumentNullException("logger");
            }
            this.combatStatus = combatStatus;
            this.logger       = logger;

            damageEntryParser = new DamageEntryParser(logger);
            skillEntryParser  = new SkillEntryParser(wurmApi);

            SetupRules();
        }
示例#4
0
        public override void Initialize(PlayerTimersGroup parentGroup, string player, TimerDefinition definition)
        {
            base.Initialize(parentGroup, player, definition);

            View.SetCooldown(ShortMeditCooldown);

            skillEntryParser = new SkillEntryParser(WurmApi);

            sleepNotify         = new SleepBonusNotify(Logger, SoundManager, TrayPopups, Character, "Can turn off sleep bonus now");
            sleepNotify.Enabled = SleepBonusReminder;

            View.UpdateSkill(MeditationSkill);
            View.ShowSkill      = ShowMeditSkill;
            View.ShowMeditCount = ShowMeditCount;

            MoreOptionsAvailable = true;
            PerformAsyncInits();
        }
示例#5
0
            public FavorTimerNotify(PrayerTimer timer, string player, string serverGroupId, ILogger logger,
                                    ISoundManager soundManager, ITrayPopups trayPopups, [NotNull] SkillEntryParser skillEntryParser)
            {
                if (skillEntryParser == null)
                {
                    throw new ArgumentNullException("skillEntryParser");
                }
                this.serverGroupId    = serverGroupId;
                this.skillEntryParser = skillEntryParser;
                Settings = timer.favorSettings;

                favorHandler = new NotifyHandler(
                    logger,
                    soundManager,
                    trayPopups,
                    Settings.FavorNotifySoundId,
                    player,
                    "",
                    Settings.FavorNotifyPopupPersist);
            }
        public SkillLevelTrigger(string characterName, TriggerEntity triggerEntity, ISoundManager soundManager,
                                 ITrayPopups trayPopups, IWurmApi wurmApi, ILogger logger)
            : base(triggerEntity, soundManager, trayPopups, wurmApi, logger)
        {
            if (characterName == null)
            {
                throw new ArgumentNullException("characterName");
            }
            this.characterName = characterName;
            this.logger        = logger;
            skillEntryParser   = new SkillEntryParser(wurmApi);
            LockedLogTypes     = new[] { LogType.Skills };

            SkillFeedback = "(no data)";

            skillHistoricRefresher = new TriggerableAsyncOperation(RefreshSkill);

            character = wurmApi.Characters.Get(characterName);
            character.LogInOrCurrentServerPotentiallyChanged += CharacterOnLogInOrCurrentServerPotentiallyChanged;

            skillHistoricRefresher.Trigger();
        }
示例#7
0
        async Task <List <SkillLevelReportItem> > GetSkillLevelsAsync(QueryParams queryParams)
        {
            List <SkillLevelReportItem> reportItems = new List <SkillLevelReportItem>();
            var serverGroup = queryParams.ServerGroupId;

            if (!string.IsNullOrWhiteSpace(serverGroup))
            {
                var parser = new SkillEntryParser(wurmApi);
                foreach (var character in queryParams.GameCharacters)
                {
                    var wurmChar = wurmApi.Characters.Get(character);

                    var characterReportItems = new List <SkillLevelReportItem>();

                    var latestSkillDump = await wurmChar.Skills.GetLatestSkillDumpAsync(serverGroup);

                    if (!latestSkillDump.IsNull)
                    {
                        foreach (var skillInfo in latestSkillDump.All)
                        {
                            var item = characterReportItems.FirstOrDefault(x => skillInfo.IsSkillName(x.Name));
                            if (item == null)
                            {
                                item = new SkillLevelReportItem()
                                {
                                    Name          = skillInfo.NameNormalized.ToLowerInvariant().Capitalize(),
                                    GameCharacter = character,
                                };
                                characterReportItems.Add(item);
                            }
                            item.CurrentValue = skillInfo.Value;
                        }
                    }

                    var entries =
                        await
                        wurmChar.Logs.ScanLogsServerGroupRestrictedAsync(
                            !latestSkillDump.IsNull?latestSkillDump.Stamp : DateTime.Now - TimeSpan.FromDays(365),
                            DateTime.Now,
                            LogType.Skills,
                            new ServerGroup(serverGroup));

                    foreach (var logEntry in entries)
                    {
                        var skillEntry = parser.TryParseSkillInfoFromLogLine(logEntry);
                        if (skillEntry != null)
                        {
                            var item = characterReportItems.FirstOrDefault(x => skillEntry.IsSkillName(x.Name));
                            if (item == null)
                            {
                                item = new SkillLevelReportItem()
                                {
                                    Name          = skillEntry.NameNormalized.ToLowerInvariant().Capitalize(),
                                    GameCharacter = character,
                                };
                                characterReportItems.Add(item);
                            }
                            item.CurrentValue = skillEntry.Value;
                        }
                    }
                    reportItems.AddRange(characterReportItems);
                }
            }

            return(reportItems);
        }
示例#8
0
        private async void generateQueryBtn_Click(object sender, EventArgs e)
        {
            try
            {
                telemetry.TrackEvent("Skill Stats: generating query");

                ThrowIfNoServerGroup();

                generateQueryBtn.Enabled = false;
                var queryParams = BuildQueryParams();

                List <SkillGainReportItem> reportItems = new List <SkillGainReportItem>();
                var serverGroup = queryParams.ServerGroupId;
                if (!string.IsNullOrWhiteSpace(serverGroup))
                {
                    var parser = new SkillEntryParser(wurmApi);
                    foreach (var character in queryParams.GameCharacters)
                    {
                        var wurmChar = wurmApi.Characters.Get(character);
                        var entries  = await wurmChar.Logs.ScanLogsServerGroupRestrictedAsync(fromDtpick.Value,
                                                                                              toDtpick.Value,
                                                                                              LogType.Skills,
                                                                                              new ServerGroup(serverGroup));

                        var characterReportItems = new List <SkillGainReportItem>();
                        foreach (
                            var logEntry in
                            entries.Where(
                                entry => entry.Timestamp >= fromDtpick.Value && entry.Timestamp <= toDtpick.Value))
                        {
                            var skillEntry = parser.TryParseSkillInfoFromLogLine(logEntry);
                            if (skillEntry != null)
                            {
                                var item = characterReportItems.FirstOrDefault(x => skillEntry.IsSkillName(x.Name));
                                if (item == null)
                                {
                                    item = new SkillGainReportItem()
                                    {
                                        Name          = skillEntry.NameNormalized.ToLowerInvariant().Capitalize(),
                                        GameCharacter = character,
                                        StartValue    = skillEntry.Value - (skillEntry.Gain ?? 0f)
                                    };
                                    characterReportItems.Add(item);
                                }
                                item.CurrentValue = skillEntry.Value;
                            }
                        }
                        reportItems.AddRange(characterReportItems);
                    }

                    var view = new SkillGainsForm(queryParams, reportItems);
                    view.ShowCenteredOnForm(this);
                }
            }
            catch (Exception exception)
            {
                ShowError(exception);
                logger.Error(exception, "Historic skills query build failed");
            }
            finally
            {
                generateQueryBtn.Enabled = true;
            }
        }