C# Plan.PlanTo方法代码示例

        /// <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;
        }

        /// <summary>
        /// Merge the selected plans.
        /// </summary>
        private void MergePlans()
        {
            // Build the merge plan
            var result = new Plan(m_character);
            using (result.SuspendingEvents())
            {
                // Merge the plans
                foreach (ListViewItem item in lbPlanList.SelectedItems)
                {
                    Plan plan = (Plan)item.Tag;
                    foreach (PlanEntry entry in plan)
                    {
                        // If not planned yet, we add the new entry
                        if (!result.IsPlanned(entry.Skill, entry.Level))
                            result.PlanTo(entry.Skill, entry.Level, entry.Priority, entry.Notes);

                        // Then we update the entry's groups
                        var newEntry = result.GetEntry(entry.Skill, entry.Level);

                        // The entry may be null if the character already knows it.
                        if (newEntry != null)
                            newEntry.PlanGroups.Add(plan.Name);
                    }
                }
            }

            // Request a new name for this plan
            using (NewPlanWindow npw = new NewPlanWindow())
            {
                DialogResult dr = npw.ShowDialog();
                if (dr == DialogResult.Cancel)
                    return;

                // Change the plan's name and add it
                result.Name = npw.Result;
                m_character.Plans.Add(result);
            }
        }

        /// <summary>
        /// Exports the character's selected skills as plan.
        /// </summary>
        /// <param name="character">The character.</param>
        /// <param name="selectedSkills">The selected skills.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static async Task ExportCharacterSkillsAsPlanAsync(Character character, IEnumerable<Skill> selectedSkills = null)
        {
            character.ThrowIfNull(nameof(character));

            // Create a character without any skill
            CharacterScratchpad scratchpad = new CharacterScratchpad(character);
            scratchpad.ClearSkills();

            // Create a new plan
            Plan plan = new Plan(scratchpad) { Name = "Skills Plan" };

            IEnumerable<Skill> skills = selectedSkills ?? character.Skills.Where(skill => skill.IsPublic);

            // Add all trained skill levels that the character has trained so far
            foreach (Skill skill in skills)
            {
                plan.PlanTo(skill, skill.Level);
            }

            await ExportPlanAsync(plan, character);
        }