Exemplo n.º 1
0
        /// <summary>
        /// Deserialization constructor.
        /// </summary>
        /// <param name="character">The character for this training</param>
        /// <param name="serial">The serialization object for this training</param>
        /// <param name="isPaused">When true, the training is currently paused.</param>
        /// <param name="startTimeWhenPaused">Training starttime when the queue is actually paused.
        /// Indeed, in such case, CCP returns empty start and end time, so we compute a "what if we start now" scenario.</param>
        internal QueuedSkill(Character character, SerializableQueuedSkill serial, bool isPaused, ref DateTime startTimeWhenPaused)
        {
            Owner = character;
            StartSP = serial.StartSP;
            EndSP = serial.EndSP;
            Level = serial.Level;
            Skill = character.Skills[serial.ID];

            if (!isPaused)
            {
                // Not paused, we should trust CCP
                StartTime = serial.StartTime;
                EndTime = serial.EndTime;
            }
            else
            {
                // StartTime and EndTime were empty on the serialization object if the skill was paused
                // So we compute a "what if we start now" scenario
                StartTime = startTimeWhenPaused;
                if (Skill != null)
                {
                    Skill.SkillPoints = StartSP;
                    startTimeWhenPaused += Skill.GetLeftTrainingTimeForLevelOnly(Level);
                }
                EndTime = startTimeWhenPaused;
            }
        }
Exemplo n.º 2
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="character">The character</param>
 /// <param name="src">The static certificate class</param>
 /// <param name="category">The owning category</param>
 internal CertificateClass(Character character, StaticCertificateClass src, CertificateGroup category)
 {
     Character = character;
     Category = category;
     StaticData = src;
     Certificate = new Certificate(character, src.Certificate, this);
 }
Exemplo n.º 3
0
        /// <summary>
        /// Creation for new settings for this character.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <exception cref="System.ArgumentNullException">character</exception>
        public MonitoredCharacterSettings(Character character)
        {
            character.ThrowIfNull(nameof(character));

            CharacterGuid = character.Guid;
            Name = character.Name;
            Settings = character.UISettings;
        }
Exemplo n.º 4
0
        internal static Uri GetCharacterUri(Character character)
        {
            character.ThrowIfNull(nameof(character));

            EveMonClient.EnsureCacheDirInit();

            return new Uri(Path.Combine(EveMonClient.EVEMonXmlCacheDir, $"{character.Name}.xml"));
        }
Exemplo n.º 5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MasteryCertificate"/> class.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <param name="masteryCertificate">The mastery certificate.</param>
        internal MasteryCertificate(Character character, MasteryCertificate masteryCertificate)
        {
            if (masteryCertificate == null)
                return;

            MasteryLevel = masteryCertificate.MasteryLevel;
            Certificate = masteryCertificate.ToCharacter(character);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Constructor from the API.
        /// </summary>
        /// <param name="character"></param>
        /// <param name="src"></param>
        internal Standing(Character character, SerializableStandingsListItem src)
        {
            m_character = character;

            m_entityID = src.ID;
            EntityName = src.Name;
            StandingValue = src.StandingValue;
            Group = src.Group;
        }
Exemplo n.º 7
0
        /// <summary>
        /// Constructor from the settings.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <param name="src">The source.</param>
        /// <exception cref="System.ArgumentNullException">src</exception>
        public EmploymentRecord(Character character, SerializableEmploymentHistory src)
        {
            src.ThrowIfNull(nameof(src));

            m_character = character;
            m_corporationId = src.CorporationID;
            m_corporationName = src.CorporationName;
            StartDate = src.StartDate;
        }
Exemplo n.º 8
0
        /// <summary>
        /// Gets the character XML.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static IXPathNavigable GetCharacterXml(Character character)
        {
            character.ThrowIfNull(nameof(character));

            EveMonClient.EnsureCacheDirInit();

            XmlDocument doc = new XmlDocument();
            doc.Load(Path.Combine(EveMonClient.EVEMonXmlCacheDir, $"{character.Name}.xml"));
            return doc;
        }
Exemplo n.º 9
0
        /// <summary>
        /// Constructor used in code.
        /// </summary>
        /// <param name="character"></param>
        /// <exception cref="System.ArgumentNullException">character</exception>
        public ImplantSetsWindow(Character character)
            : this()
        {
            character.ThrowIfNull(nameof(character));

            m_character = character;
            m_sets = character.ImplantSets.Export();
            m_maxJumpClones = character.Skills[DBConstants.InfomorphPsychologySkillID].Level +
                              character.Skills[DBConstants.AdvancedInfomorphPsychologySkillID].Level;
        }
Exemplo n.º 10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="CertificateLevel"/> class.
        /// </summary>
        /// <param name="skill">The skill.</param>
        /// <param name="cert">The cert.</param>
        /// <param name="character">The character.</param>
        public CertificateLevel(KeyValuePair<CertificateGrade, List<StaticSkillLevel>> skill, Certificate cert,
            Character character)
        {
            m_character = character;

            Level = skill.Key;
            Certificate = cert;
            Status = CertificateStatus.Untrained;
            PrerequisiteSkills = skill.Value.ToCharacter(character);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="plan">The plan.</param>
        private PlanPrinter(Plan plan)
        {
            m_plan = plan;
            m_plan.UpdateStatistics();

            m_character = (Character)plan.Character;
            m_settings = Settings.Exportation.PlanToText;

            m_font = FontFactory.GetFont("Arial", 10);
            m_boldFont = FontFactory.GetFont("Arial", 10, FontStyle.Bold | FontStyle.Underline);
        }
Exemplo n.º 12
0
        /// <summary>
        /// Constructor from the API.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <param name="src">The source.</param>
        /// <exception cref="System.ArgumentNullException">src</exception>
        public EmploymentRecord(Character character, SerializableEmploymentHistoryListItem src)
        {
            src.ThrowIfNull(nameof(src));

            m_character = character;
            m_corporationId = src.CorporationID;
            m_corporationName = String.IsNullOrWhiteSpace(src.CorporationName)
                ? GetIDToName(src.CorporationID)
                : src.CorporationName;
            StartDate = src.StartDate;
        }
Exemplo n.º 13
0
        /// <summary>
        /// Constructor at character's initialization time.
        /// </summary>
        /// <param name="character"></param>
        /// <param name="src"></param>
        /// <param name="certClass"></param>
        internal Certificate(Character character, StaticCertificate src, CertificateClass certClass)
        {
            m_character = character;
            m_levels = new CertificateLevel[6];

            StaticData = src;
            Class = certClass;

            foreach (KeyValuePair<CertificateGrade, List<StaticSkillLevel>> skill in src.PrerequisiteSkills)
            {
                m_levels[(int)skill.Key] = new CertificateLevel(skill, this, character);
            }
        }
Exemplo n.º 14
0
        /// <summary>
        /// Constructor from the API.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <param name="src">The source.</param>
        internal KillLog(Character character, SerializableKillLogListItem src)
        {
            Character = character;
            KillTime = src.KillTime;
            TimeSinceKill = DateTime.UtcNow.Subtract(src.KillTime);
            MoonID = src.MoonID;
            Victim = src.Victim;
            Attackers = src.Attackers;
            SolarSystem = StaticGeography.GetSolarSystemByID(src.SolarSystemID);

            m_items.AddRange(src.Items.Select(item => new KillLogItem(item)));

            Group = src.Victim.ID == character.CharacterID ? KillGroup.Losses : KillGroup.Kills;
        }
        /// <summary>
        /// Initializes a new instance of <see cref="AttributesOptimizerControl"/>.
        /// </summary>
        /// <param name="character">Character information</param>
        /// <param name="plan">Skill plan</param>
        /// <param name="remapping">Optimized remapping</param>
        /// <param name="description"></param>
        public AttributesOptimizerControl(Character character, BasePlan plan,
            RemappingResult remapping, string description)
        {
            InitializeComponent();
            lbMEM.Font = FontFactory.GetFont("Tahoma");
            lbWIL.Font = FontFactory.GetFont("Tahoma");
            lbCHA.Font = FontFactory.GetFont("Tahoma");
            lbPER.Font = FontFactory.GetFont("Tahoma");
            lbINT.Font = FontFactory.GetFont("Tahoma");

            m_character = character;
            m_plan = plan;
            m_remapping = remapping;
            m_description = description;

            UpdateControls(m_character, m_plan, m_remapping, m_description);
        }
Exemplo n.º 16
0
 /// <summary>
 /// Creates formatted string for character exportation.
 /// </summary>
 /// <param name="format"></param>
 /// <param name="character"></param>
 /// <param name="plan"></param>
 /// <exception cref="NotImplementedException"></exception>
 /// <returns></returns>
 public static string Export(CharacterSaveFormat format, Character character, Plan plan = null)
 {
     switch (format)
     {
         case CharacterSaveFormat.Text:
             return ExportAsText(character, plan);
         case CharacterSaveFormat.EFTCHR:
             return ExportAsEFTCHR(character, plan);
         case CharacterSaveFormat.EVEMonXML:
             return ExportAsEVEMonXML(character, plan);
         case CharacterSaveFormat.HTML:
             return ExportAsHTML(character, plan);
         case CharacterSaveFormat.CCPXML:
             return ExportAsCCPXML(character);
         default:
             throw new NotImplementedException();
     }
 }
Exemplo n.º 17
0
        /// <summary>
        /// Creates a plan from a character skill queue.
        /// </summary>
        /// <param name="newPlan">The new plan.</param>
        /// <param name="character">The character.</param>
        public static bool CreatePlanFromCharacterSkillQueue(Plan newPlan, Character character)
        {
            CCPCharacter ccpCharacter = character as CCPCharacter;

            if (ccpCharacter == null)
                return false;

            if (!ccpCharacter.SkillQueue.Any())
            {
                MessageBox.Show(@"There are no skills in the characters' queue.",
                    @"Plan Creation Failure",
                    MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }

            if (ccpCharacter.Plans.Any(x => x.Name == newPlan.Name))
            {
                MessageBox.Show(@"There is already a plan with the same name in the characters' Plans.",
                    @"Plan Creation Failure",
                    MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }

            // Add skill queue in plan
            foreach (QueuedSkill qSkill in ccpCharacter.SkillQueue)
            {
                newPlan.PlanTo(qSkill.Skill, qSkill.Level);
            }

            // Check if there is already a plan with the same skills
            if (ccpCharacter.Plans.Any(plan => !newPlan.Except(plan, new PlanEntryComparer()).Any()))
            {
                MessageBox.Show(@"There is already a plan with the same skills in the characters' Plans.",
                    @"Plan Creation Failure",
                    MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }

            // Add plan and save
            ccpCharacter.Plans.Insert(0, newPlan);

            return true;
        }
Exemplo n.º 18
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="character">The character.</param>
 /// <param name="queuedSkills">The queued skills.</param>
 public QueuedSkillsEventArgs(Character character, IEnumerable<QueuedSkill> queuedSkills)
 {
     Character = character;
     CompletedSkills = new List<QueuedSkill>(queuedSkills).AsReadOnly();
 }
Exemplo n.º 19
0
        /// <summary>
        /// Sends a mail alert for a skill completion
        /// </summary>
        /// <param name="queueList">Current Skill Queue</param>
        /// <param name="skill">Skill that has just completed</param>
        /// <param name="character">Character affected</param>
        /// <exception cref="System.ArgumentNullException">
        /// </exception>
        public static void SendSkillCompletionMail(IList<QueuedSkill> queueList, QueuedSkill skill, Character character)
        {
            s_isTestMail = false;

            queueList.ThrowIfNull(nameof(queueList));

            skill.ThrowIfNull(nameof(skill));

            CCPCharacter ccpCharacter = character as CCPCharacter;

            // Current character isn't a CCP character, so can't have a Queue.
            if (ccpCharacter == null)
                return;

            string skillLevelText = $"{skill.SkillName} {Skill.GetRomanFromInt(skill.Level)}";
            string subjectText = $"{character.Name} has finished training {skillLevelText}.";

            // Message's first line
            StringBuilder body = new StringBuilder();
            body
                .AppendLine(subjectText)
                .AppendLine();

            // Next skills in queue
            if (queueList[0] != null)
            {
                string plural = queueList.Count > 1 ? "s" : String.Empty;
                body.AppendLine($"Next skill{plural} in queue:");

                foreach (QueuedSkill qskill in queueList)
                {
                    body.AppendLine($"- {qskill}");
                }
                body.AppendLine();
            }
            else
                body
                    .AppendLine("Character is not training.")
                    .AppendLine();

            // Skill queue less than a day
            if (ccpCharacter.SkillQueue.LessThanWarningThreshold)
            {
                TimeSpan skillQueueEndTime = ccpCharacter.SkillQueue.EndTime.Subtract(DateTime.UtcNow);
                TimeSpan timeLeft = SkillQueue.WarningThresholdTimeSpan.Subtract(skillQueueEndTime);

                // Skill queue empty?
                if (timeLeft > SkillQueue.WarningThresholdTimeSpan)
                    body.AppendLine("Skill queue is empty.");
                else
                {
                    string timeLeftText = skillQueueEndTime < TimeSpan.FromMinutes(1)
                        ? skillQueueEndTime.ToDescriptiveText(DescriptiveTextOptions.IncludeCommas)
                        : skillQueueEndTime.ToDescriptiveText(DescriptiveTextOptions.IncludeCommas, false);

                    body.AppendLine($"Queue ends in {timeLeftText}.");
                }
            }

            // Short format (also for SMS)
            if (Settings.Notifications.UseEmailShortFormat)
            {
                SendMail(Settings.Notifications,
                    $"[STC] {character.Name} :: {skillLevelText}",
                    body.ToString());

                return;
            }

            // Long format
            if (character.Plans.Count > 0)
            {
                body.AppendLine("Next skills listed in plans:")
                    .AppendLine();
            }

            foreach (Plan plan in character.Plans)
            {
                if (plan.Count <= 0)
                    continue;

                // Print plan name
                CharacterScratchpad scratchpad = new CharacterScratchpad(character);
                body.AppendLine($"{plan.Name}:");

                // Scroll through entries
                int i = 0;
                int minDays = 1;
                foreach (PlanEntry entry in plan)
                {
                    TimeSpan trainTime = scratchpad.GetTrainingTime(entry.Skill, entry.Level,
                        TrainingOrigin.FromPreviousLevelOrCurrent);

                    // Only print the first three skills, and the very long skills
                    // (first limit is one day, then we add skills duration)
                    if (++i > 3 && trainTime.Days <= minDays)
                        continue;

                    if (i > 3)
                    {
                        // Print long message once
                        if (minDays == 1)
                            body.AppendLine().Append($"Longer skills from {plan.Name}:").AppendLine();

                        minDays = trainTime.Days + minDays;
                    }
                    body.Append($"\t{entry}");

                    // Notes
                    if (!string.IsNullOrEmpty(entry.Notes))
                        body.Append($" ({entry.Notes})");

                    // Training time
                    body
                        .Append(trainTime.Days > 0 ? $" - {trainTime.Days}d, {trainTime}" : $" - {trainTime}")
                        .AppendLine();
                }
                body.AppendLine();
            }

            SendMail(Settings.Notifications, subjectText, body.ToString());
        }
Exemplo n.º 20
0
        /// <summary>
        /// Outputs a plan or shopping list for a given character to a stream writer.
        /// </summary>
        /// <param name="context">context of the request</param>
        /// <param name="requestPath">url of the request</param>
        /// <param name="sw">stream writer to output to</param>
        /// <param name="character">character to use</param>
        private static void GeneratePlanOrShoppingOutput(string context, string requestPath, TextWriter sw, Character character)
        {
            sw.WriteLine("<h1>Hello, {0}</h1>", HttpUtility.HtmlEncode(character.Name));
            sw.WriteLine("<a href=\"/characters\">List all characters</a><hr/>");
            sw.WriteLine("<a href=\"{0}\">Character overview</a>", context);

            Regex regex =
                new Regex(
                    @"\/(owned\/(?'skillId'[^\/]+)\/(?'markOwned'[^\/]+)\/)?(?'requestType'shopping|plan)\/(?'planName'[^\/]+)(.*)",
                    RegexOptions.CultureInvariant | RegexOptions.Compiled);
            Match match = regex.Match(requestPath);

            if (match.Success)
            {
                string requestType = match.Groups["requestType"].Value;
                bool shopping = requestType.Equals("shopping", StringComparison.OrdinalIgnoreCase);
                string planName = HttpUtility.UrlDecode(match.Groups["planName"].Value);

                int skillId;
                bool setAsOwned;
                if (match.Groups["skillId"].Success &&
                    match.Groups["markOwned"].Success &&
                    Int32.TryParse(match.Groups["skillId"].Value, out skillId) &&
                    Boolean.TryParse(match.Groups["markOwned"].Value, out setAsOwned))
                {
                    Skill skill = character.Skills.FirstOrDefault(x => x.ID == skillId);
                    if (skill != null)
                    {
                        sw.WriteLine("<h2>Skillbook shopping result</h2>");
                        skill.IsOwned = setAsOwned;
                        sw.WriteLine("<a href=\"\" onclick=\"CCPEVE.showInfo({0})\">{1}</a> is now marked as {2} owned.", skill.ID,
                            HttpUtility.HtmlEncode(skill.Name), skill.IsOwned ? String.Empty : "not");
                    }
                    else
                    {
                        // Display an error message
                        sw.WriteLine("<h2>Error Message</h2>");
                        sw.WriteLine("Skill with id '{0}' could not be found", skillId);
                    }
                    sw.WriteLine("<hr/>");
                }

                Plan plan = character.Plans[planName];
                if (plan == null)
                {
                    // Display an error message
                    sw.WriteLine("<h2>Error Message</h2>");
                    sw.WriteLine("A plan named \"{0}\" does not exist.", HttpUtility.HtmlEncode(planName));
                }
                else
                {
                    sw.WriteLine("<h2>Plan: {0}</h2>", HttpUtility.HtmlEncode(plan.Name));

                    PlanExportSettings x = new PlanExportSettings
                    {
                        // Only if not shopping
                        EntryTrainingTimes = !shopping,
                        // Only if not shopping
                        EntryStartDate = !shopping,
                        // Only if not shopping
                        EntryFinishDate = !shopping,
                        // Only if not shopping
                        FooterTotalTime = !shopping,
                        // Only if not shopping
                        FooterDate = !shopping,
                        FooterCount = true,
                        ShoppingList = shopping,
                        EntryCost = true,
                        FooterCost = true,
                        Markup = MarkupType.Html
                    };

                    sw.Write(PlanIOHelper.ExportAsText(plan, x, ExportActions(context, requestType, plan)));
                }
            }
            else
            {
                sw.WriteLine("<h2>Error Message</h2>");
                sw.WriteLine("Invalid request");
            }

            sw.WriteLine("<br/><br/><a href=\"{0}\">Character overview</a>", context);
            sw.WriteLine("<hr/><a href=\"/characters\">List all characters</a>");
        }
Exemplo n.º 21
0
        /// <summary>
        /// Outputs a list of skills for a given character ordered by time to a stream writer.
        /// </summary>
        /// <param name="context">context of the request</param>
        /// <param name="sw">stream writer to output to</param>
        /// <param name="character">character to use</param>
        private static void GenerateSkillsByTimeOutput(string context, TextWriter sw, Character character)
        {
            sw.WriteLine("<h1>Hello, {0}</h1>", HttpUtility.HtmlEncode(character.Name));
            sw.WriteLine("<a href=\"/characters\">List all characters</a><hr/>");
            sw.WriteLine("<a href=\"{0}\">Character overview</a>", context);

            sw.WriteLine("<h2>Your skills by training time:</h2>");

            IEnumerable<Skill> allskills = character.Skills.Where(x => x.IsPublic && x.Level < 5 && x.Level > 0);
            allskills = allskills.OrderBy(x => x.GetLeftTrainingTimeToNextLevel);

            sw.WriteLine("<table>");
            sw.Write("<tr><td colspan=\"2\" width=\"265\"><b>Skill</b></td>" +
                     "<td width=\"100\"><b>Next Level</b></td><td><b>Training Time</b></td></tr>");

            int index = 0;
            foreach (Skill s in allskills)
            {
                index++;
                sw.Write("<tr>");

                sw.Write("<td width=\"15\">");
                sw.Write("<b>{0}.</b>", index);
                sw.Write("</td>");

                sw.Write("<td width=\"300\">");
                sw.Write("<b><a href=\"\" onclick=\"CCPEVE.showInfo({0})\">{1}</a></b>", s.ID, s.Name);
                sw.Write("</td>");

                sw.Write("<td width=\"100\">");
                sw.Write("<b>{0} -&gt; {1}</b>", s.RomanLevel, Skill.GetRomanFromInt(s.Level + 1));
                sw.Write("</td>");

                sw.Write("<td>");
                sw.Write(s.GetLeftTrainingTimeToNextLevel.ToDescriptiveText(
                    DescriptiveTextOptions.FullText |
                    DescriptiveTextOptions.IncludeCommas |
                    DescriptiveTextOptions.SpaceText));
                sw.Write("</td>");
                sw.Write("</tr>");
            }
            sw.WriteLine("</table>");

            sw.WriteLine("<br/><a href=\"{0}\">Character overview</a>", context);
            sw.WriteLine("<hr/><a href=\"/characters\">List all characters</a>");
        }
Exemplo n.º 22
0
        /// <summary>
        /// Outputs a list of plans for a given character to a stream writer.
        /// </summary>
        /// <param name="context">context of the request</param>
        /// <param name="sw">stream writer to output to</param>
        /// <param name="character">character to use</param>
        private static void GeneratePlanListOutput(string context, TextWriter sw, Character character)
        {
            sw.WriteLine("<h1>Hello, {0}</h1>", HttpUtility.HtmlEncode(character.Name));
            sw.WriteLine("<a href=\"/characters\">List all characters</a><hr/>");

            sw.WriteLine("<h2>Your plans:</h2>");
            foreach (Plan plan in character.Plans)
            {
                sw.WriteLine("<a href=\"{0}/plan/{1}\">{2}</a> (<a href=\"{0}/shopping/{1}\">shopping list</a>)<br/>",
                    context,
                    HttpUtility.UrlEncode(plan.Name),
                    HttpUtility.HtmlEncode(plan.Name));
            }

            sw.WriteLine("<h2>Your skills:</h2>");
            sw.WriteLine("<a href=\"{0}/skills/bytime\">By training time</a><br/>", context);

            sw.WriteLine("<hr/><a href=\"/characters\">List all characters</a>");
        }
Exemplo n.º 23
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="character">The character.</param>
 /// <param name="industryJobs">The industry jobs.</param>
 public IndustryJobsEventArgs(Character character, IEnumerable<IndustryJob> industryJobs)
 {
     Character = character;
     CompletedJobs = industryJobs.ToList().AsReadOnly();
 }
Exemplo n.º 24
0
 /// <summary>
 /// Returns an equivalent enumeration with character skills.
 /// </summary>
 /// <param name="src"></param>
 /// <param name="character"></param>
 /// <returns></returns>
 public static IEnumerable<SkillLevel> ToCharacter(this IEnumerable<StaticSkillLevel> src, Character character)
     => src.Where(item => item.Skill != null)
         .Select(item => new SkillLevel(character?.Skills[item.Skill.ID] ?? SkillCollection.Skills[item.Skill.ID], item.Level));
Exemplo n.º 25
0
 /// <summary>
 /// Internal constructor, only used for character creation and updates
 /// </summary>
 /// <param name="owner"></param>
 /// <param name="group"></param>
 /// <param name="skill"></param>
 internal Skill(Character owner, SkillGroup group, StaticSkill skill)
 {
     Character = owner;
     StaticData = skill;
     Group = group;
 }
Exemplo n.º 26
0
        /// <summary>
        /// Gets this skill's representation for the provided character.
        /// </summary>
        /// <param name="character"></param>
        /// <returns></returns>
        public Skill ToCharacter(Character character)
        {
            character.ThrowIfNull(nameof(character));

            return character.Skills[StaticData.ArrayIndex];
        }
Exemplo n.º 27
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="character"></param>
 public CharacterChangedEventArgs(Character character)
 {
     Character = character;
 }
Exemplo n.º 28
0
        /// <summary>
        /// Gets this certificate's representation for the provided character.
        /// </summary>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">character</exception>
        public Certificate ToCharacter(Character character)
        {
            character.ThrowIfNull(nameof(character));

            return character.Certificates.FirstOrDefault(x => x.ID == Certificate.ID);
        }
Exemplo n.º 29
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="character">The character.</param>
 /// <param name="endedContracts">The ended contracts.</param>
 public ContractsEventArgs(Character character, IEnumerable<Contract> endedContracts)
 {
     Character = character;
     EndedContracts = endedContracts;
 }
Exemplo n.º 30
0
 /// <summary>
 /// Returns an equivalent enumeration with character skills.
 /// </summary>
 /// <param name="src"></param>
 /// <param name="character"></param>
 /// <returns></returns>
 public static IEnumerable<Skill> ToCharacter(this IEnumerable<StaticSkill> src, Character character)
     => src.Select(skill => character.Skills[skill.ID]);