protected AbstractQuestionSet(int numQuestions, Mastery mastery)
{
_numQuestions = numQuestions;
_mastery = mastery;
_questionSet = new string[numQuestions];
_answerSet = new string[numQuestions];
}
/// <summary>
/// Adds the provided mastery's prerequisites to the plan.
/// </summary>
/// <param name="masteryLevel">The mastery level.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">masteryLevel</exception>
public IPlanOperation TryPlanTo(Mastery masteryLevel)
{
masteryLevel.ThrowIfNull(nameof(masteryLevel));
List <StaticSkillLevel> skillsToAdd = new List <StaticSkillLevel>();
Character character = Character as Character;
foreach (SkillLevel skillLevel in masteryLevel
.Select(mcert => mcert.ToCharacter(character).GetCertificateLevel(masteryLevel.Level))
.SelectMany(x => x.PrerequisiteSkills))
{
int plannedLevel = GetPlannedLevel(skillLevel.Skill);
if ((skillLevel.Level == plannedLevel) || (skillLevel.Level <= plannedLevel))
{
continue;
}
// Get skill levels to add
for (int i = plannedLevel + 1; i <= skillLevel.Level; i++)
{
skillsToAdd.Add(new StaticSkillLevel(skillLevel.Skill, i));
}
}
return(TryAddSet(skillsToAdd, $"{masteryLevel.MasteryShip.Ship.Name} Mastery {masteryLevel}"));
}
public Mastery GetMastery(int masteryId, region region, language lang, masteryListData?masteryData = null, bool useCaching = false)
{
Mastery val = Cache.Get <Mastery>(masteryId.ToString(), region.ToString(), lang.ToString(), masteryData.ToString()); //cache getting
if (val != null)
{
return(val);
}
RiotApiCaller <Mastery> caller = new RiotApiCaller <Mastery>(suffix.masteryById);
caller.AddParam(param.region, region);
caller.AddParam(param.locale, lang);
caller.AddParam(param.id, masteryId);
if (masteryData != null)
{
caller.AddParam(param.masteryData, masteryData);
}
else
{
caller.AddParam(param.masteryData, ""); //important for basic information
}
if (useCaching) //your choice
{
Cache.AddOrUpdate(caller.CreateRequest(new System.TimeSpan(1, 0, 0, 0))); // cache adding
}
else
{
caller.CreateRequest();//everytime data coming from riotgames server
}
return(caller.Result.FirstOrDefault());
}
public void AddMastery(Mastery mastery, GameObject go)
{
goTemp = go;
if (enabledMasteries[0] == null)
{
enabledMasteries[0] = mastery;
mastery.GetSkill(this);
Destroy(goTemp.transform.parent.gameObject);
}
else if (enabledMasteries[1] == null)
{
enabledMasteries[1] = mastery;
mastery.GetSkill(this);
Destroy(goTemp.transform.parent.gameObject);
}
else if (enabledMasteries[2] == null)
{
enabledMasteries[2] = mastery;
mastery.GetSkill(this);
Destroy(goTemp.transform.parent.gameObject);
}
else
{
go.GetComponent <AddMastery>().clicked = true;
StartCoroutine(WaitIE(mastery));
}
}
public SkillIntel(string name, Skill s)
{
Name = name;
active = s.m_active;
mastery = s.m_mastery;
acquired = s.m_acquired;
}
/// <summary>
/// Treeview's context menu > Plan "(selection)".
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsmAddToPlan_Click(object sender, EventArgs e)
{
Mastery masteryLevel = treeView.SelectedNode.Tag as Mastery;
CertificateLevel certLevel = treeView.SelectedNode.Tag as CertificateLevel;
IPlanOperation operation;
if (masteryLevel != null)
{
operation = m_plan.TryPlanTo(masteryLevel);
}
else if (certLevel != null)
{
operation = m_plan.TryPlanTo(certLevel);
}
else
{
SkillLevel prereq = (SkillLevel)treeView.SelectedNode.Tag;
operation = m_plan.TryPlanTo(prereq.Skill, prereq.Level);
}
if (operation == null)
{
return;
}
PlanWindow planWindow = ParentForm as PlanWindow;
if (planWindow == null)
{
return;
}
PlanHelper.SelectPerform(new PlanToOperationWindow(operation), planWindow, operation);
}
internal static IList <Mastery> getMasteriesData()
{
string urlRequest = string.Format("https://global.api.pvp.net/api/lol/static-data/{0}/v1.2/mastery?locale={1}&masteryListData=all&api_key={2}", region, locale, apikey);
WebRequest request = WebRequest.Create(urlRequest);
request.Headers.Add(HttpRequestHeader.AcceptLanguage, "en-us");
request.Headers.Add(HttpRequestHeader.AcceptCharset, "ISO-8859-1,utf-8");
string textResponse = string.Empty;
IList <Mastery> masteries = new List <Mastery>();
using (WebResponse response = request.GetResponse())
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
textResponse = reader.ReadToEnd();
dynamic dynObject = JsonConvert.DeserializeObject(textResponse);
foreach (var obj in dynObject.data)
{
var m = new Mastery(obj.Value);
masteries.Add(m);
}
}
}
return(masteries);
}
private void OnAnyMasteryLevelUp(Mastery mastery)
{
if (Game.Instance == null || !Game.Instance.State.IsScenario)
{
return;
}
this.pool.Spawn().Construct(mastery);
}
public void CreateAccount(string username, string email, string password, string fullname, string @class, int year, int semester, string salt)
{
Account account = new Account()
{
Id = Utilities.GenerateGuid().ToString(),
Username = username,
Email = email,
FullName = fullname,
Class = @class,
Year = year,
Semester = semester,
Password = Password.GenerateSaltedHash(password, salt),
Salt = salt,
Masteries = new List <Mastery>(),
QuestionAttempteds = new List <QuestionAttempted>(),
Sessions = new List <Session>(),
Scores = new List <Score>(),
CreationDate = DateTime.Now,
LastLoggedIn = DateTime.Now,
IsLoggedIn = 1
};
account.Character = new Controller.Database.Tables.Character()
{
Id = Utilities.GenerateGuid().ToString(),
TopEqp = 8,
HeadEqp = 8,
BottomEqp = 8,
ShoeEqp = 8,
ChestCount = 0,
AccountId = account.Id
};
for (int i = 0; i < this.GetDbSet <Topic>().Where(topic => topic.Id != 7).Count(); i++)
{
Mastery mastery = new Mastery()
{
AccountId = account.Id,
Exp = 0,
TopicId = (i + 1)
};
account.Masteries.Add(mastery);
}
Inventory inventory = new Inventory()
{
Head = 0,
Shirt = 0,
AccountId = account.Id,
Pant = 0,
Shoe = 0
};
account.Inventory = inventory;
Mutex.WaitOne();
Accounts().Add(account);
Database.SaveChanges();
Mutex.ReleaseMutex();
}
private void storeChildren()
{
Transform atAGlancePanel = this.gameObject.transform.FindChild("Panel - Character At a Glance");
atAGlance = new AtAGlance()
{
panel = atAGlancePanel.gameObject,
description = atAGlancePanel.FindChild("Text - Description").gameObject.GetComponent <Text>(),
status = atAGlancePanel.FindChild("Text - Status").gameObject.GetComponent <Text>()
};
Transform optionsPanel = this.gameObject.transform.FindChild("Panel - Options");
options = new Options()
{
panel = optionsPanel.gameObject,
stats = optionsPanel.FindChild("Button - Stats").GetComponent <Button>(),
classFeatures = optionsPanel.FindChild("Button - Class Features").gameObject.GetComponent <Button>(),
inventory = optionsPanel.FindChild("Button - Inventory").gameObject.GetComponent <Button>(),
levelUp = optionsPanel.FindChild("Button - Level Up").gameObject.GetComponent <Button>()
};
featuresPanel = this.gameObject.transform.FindChild("Panel - Class Features").gameObject;
statsPanel = this.gameObject.transform.FindChild("Panel - Character Stats").gameObject;
// pointAllocationPanel = this.gameObject.transform.FindChild("Panel - Ability Scores").gameObject;
Transform physiquePanel = statsPanel.transform.FindChild("Panel - Physique Stats");
physique = new Physique()
{
panel = physiquePanel.gameObject,
sturdyAndMod = physiquePanel.FindChild("Text - Sturdy & Mod").gameObject.GetComponent <Text>(),
athleticsAndMelee = physiquePanel.FindChild("Text - Athletics & Melee").gameObject.GetComponent <Text>()
};
Transform prowessPanel = statsPanel.transform.FindChild("Panel - Prowess Stats");
prowess = new Prowess()
{
panel = prowessPanel.gameObject,
perceptionAndMod = prowessPanel.FindChild("Text - Perception & Mod").gameObject.GetComponent <Text>(),
rangedAndStealth = prowessPanel.FindChild("Text - Ranged & Stealth").gameObject.GetComponent <Text>()
};
Transform masteryPanel = statsPanel.transform.FindChild("Panel - Mastery Stats");
mastery = new Mastery()
{
panel = masteryPanel.gameObject,
techniqueAndMod = masteryPanel.FindChild("Text - Technique & Mod").gameObject.GetComponent <Text>(),
mechanicalAndMedicinal = masteryPanel.FindChild("Text - Mechanical & Medicinal").gameObject.GetComponent <Text>()
};
Transform knowledgePanel = statsPanel.transform.FindChild("Panel - Knowledge Stats");
knowledge = new Knowledge()
{
panel = knowledgePanel.gameObject,
wellVersedAndMod = knowledgePanel.FindChild("Text - Well-Versed & Mod").gameObject.GetComponent <Text>(),
historicalAndPolitical = knowledgePanel.FindChild("Text - Historical & Political").gameObject.GetComponent <Text>()
};
}
/// <summary>
/// Updates eligibility label and planning menus.
/// </summary>
private void UpdateEligibility()
{
foreach (ToolStripItem control in tlStrpPlanTo.Items)
{
control.Visible = Plan != null;
}
// Not visible
if (SelectedObject == null || Plan == null)
{
return;
}
MasteryShip masteryShip = masteryTreeDisplayControl.MasteryShip;
if (masteryShip == null)
{
return;
}
// First we search the highest eligible mastery level after this plan
IEnumerable <Mastery> eligibleMasteryLevel =
masteryShip.TakeWhile(masteryLevel => Plan.WillGrantEligibilityFor(masteryLevel)).ToList();
Mastery lastEligibleMasteryLevel = null;
if (!eligibleMasteryLevel.Any())
{
tslbEligible.Text = @"(none)";
}
else
{
lastEligibleMasteryLevel = eligibleMasteryLevel.Last();
tslbEligible.Text = lastEligibleMasteryLevel.ToString();
if (masteryShip.HighestTrainedLevel == null)
{
tslbEligible.Text += @" (improved from ""none"")";
}
else if (lastEligibleMasteryLevel.Level > masteryShip.HighestTrainedLevel.Level)
{
tslbEligible.Text += string.Format(CultureConstants.DefaultCulture, " (improved from \"{0}\")",
masteryShip.HighestTrainedLevel);
}
else
{
tslbEligible.Text += @" (no change)";
}
}
// "Plan to N" menus
for (int i = 1; i <= 5; i++)
{
UpdatePlanningMenuStatus(tsPlanToMenu.DropDownItems[i - 1], masteryShip.GetLevel(i), lastEligibleMasteryLevel);
}
}
public void Initialize(Mastery mastery)
{
Mastery = mastery;
Mastery.Experience.Changed += OnExperienceChanged;
Mastery.Experience.LevelUp += OnExperienceLevelup;
this.nameText.text = mastery.Name;
OnExperienceChanged(mastery.Experience);
OnExperienceLevelup(mastery.Experience);
}
/// <summary>
/// Updates a "plan to" menu.
/// </summary>
/// <param name="menu">The menu to update</param>
/// <param name="masteryLevel">The level represent by this menu</param>
/// <param name="lastEligibleMasteryLevel">The highest eligible mastery after this plan</param>
private void UpdatePlanningMenuStatus(ToolStripItem menu, Mastery masteryLevel, Mastery lastEligibleMasteryLevel)
{
menu.Visible = masteryLevel != null;
menu.Enabled = masteryLevel != null &&
(lastEligibleMasteryLevel == null || masteryLevel.Level > lastEligibleMasteryLevel.Level);
if (menu.Enabled)
{
menu.Tag = Plan.TryPlanTo(masteryLevel);
}
}
/// <summary>
/// Updates the shown treecontrol
/// </summary>
private void UpdateTree()
{
Mastery oldSelection = SelectedMasteryLevel;
TreeNode newSelection = null;
treeView.ImageList = Settings.UI.SafeForWork ? m_emptyImageList : imageList;
treeView.BeginUpdate();
try
{
// Clear the old items
treeView.Nodes.Clear();
// No update when not fully initialized
if (m_character == null || m_masteryShip == null)
{
return;
}
// Create the nodes when not done, yet
if (treeView.Nodes.Count == 0)
{
foreach (Mastery masteryLevel in m_masteryShip)
{
TreeNode node = CreateNode(masteryLevel);
treeView.Nodes.Add(node);
// Does the old selection still exists ?
if (masteryLevel == oldSelection)
{
newSelection = node;
}
}
}
// Update the nodes
foreach (TreeNode node in treeView.Nodes)
{
UpdateNode(node);
}
// Is the old selection kept ? Then we select the matching node
if (newSelection != null)
{
treeView.SelectedNode = newSelection;
}
}
finally
{
treeView.EndUpdate();
}
}
IEnumerator WaitIE(Mastery mastery)
{
yield return(new WaitForSeconds(0.1f));
Time.timeScale = 0;
mtext.gameObject.SetActive(true);
mtext1.gameObject.SetActive(true);
mtext2.gameObject.SetActive(true);
mtext3.gameObject.SetActive(true);
yield return(WaitForInput(mastery));
}
//CONSTRUCTEURS
public Skill(bool active, Mastery mastery, bool acquired, int cSuccess)
{
m_mastery = mastery;
m_active = active;
if (mastery == Mastery.Expert)
{
m_acquired = acquired;
}
else
{
m_acquired = false;
}
consecutiveSuccess = cSuccess;
}
public void Construct(Mastery mastery)
{
this.nameText.text = mastery.Name;
foreach (var star in this.stars)
{
star.gameObject.SetActive(false);
}
foreach (var star in this.stars.Take(mastery.Experience.Level))
{
star.gameObject.SetActive(true);
}
}
public MasteryPage(RiotSharp.SummonerEndpoint.MasteryPage masteryPage)
{
InitializeComponent();
// Loads the values of masteries from JSON file
_Mastery = LoadJson();
_images = new Image[] {image4111, image4112, image4113, image4114, image4121, image4122, image4123, image4124, image4131, image4132, image4133,
image4134, image4141, image4142, image4143, image4144, image4151, image4152, image4154, image4162, image4211, image4212,
image4213, image4214, image4221, image4222, image4224, image4231, image4232, image4233, image4234, image4241, image4242,
image4243, image4244, image4251, image4252, image4253, image4262, image4311, image4312, image4313, image4314, image4322,
image4323, image4324, image4331, image4332, image4333, image4334, image4341, image4342, image4343, image4344, image4352,
image4353, image4362};
labelName.Content = masteryPage.Name;
SetupImages();
SetupMasteryPage(masteryPage);
SetupToolTip();
}
/// <summary>
/// Sets the visible status of the context menu submenu.
/// </summary>
/// <param name="menu">The menu.</param>
/// <param name="masteryLevel">The mastery level.</param>
private void SetAdditionMenuStatus(ToolStripItem menu, Mastery masteryLevel)
{
menu.Visible = masteryLevel != null;
if (masteryLevel == null)
{
return;
}
menu.Enabled = !Plan.WillGrantEligibilityFor(masteryLevel);
if (menu.Enabled)
{
menu.Tag = Plan.TryPlanTo(masteryLevel);
}
}
public async Task RebaseMasteriesAsync_ShouldRepopulateMasteriesTable_WhenPassedValidParameters()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "RebaseMasteriesAsync_ShouldRepopulateMasteriesTable_WhenPassedValidParameters")
.Options;
string validAccessToken = string.Empty;
string validCollectionName = "masteries";
int validPageSize = 100;
Mastery validMastery = new Mastery
{
Id = Guid.NewGuid(),
Name = "testMastery",
DeletedOn = DateTime.UtcNow.AddHours(2),
IsDeleted = true
};
IEnumerable <Mastery> validMasteryList = new List <Mastery>()
{
validMastery
};
// Act
using (DataContext actContext = new DataContext(contextOptions))
{
Mock <IPandaScoreClient> pandaScoreClientMock = new Mock <IPandaScoreClient>();
pandaScoreClientMock
.Setup(mock => mock.GetEntitiesParallel <Mastery>(validAccessToken, validCollectionName, validPageSize))
.Returns(Task.FromResult(validMasteryList));
MasteryService SUT = new MasteryService(
pandaScoreClientMock.Object,
actContext);
await SUT.RebaseMasteriesAsync(validAccessToken);
}
// Assert
using (DataContext assertContext = new DataContext(contextOptions))
{
Assert.IsTrue(assertContext.Masteries.Count() == 1);
Assert.IsTrue(assertContext.Masteries.Contains(validMastery));
}
}
public async Task FilterMasteriesAsync_ShouldReturnMasteries_WhenPassedValidParameters()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "FilterMasteries_ShouldReturnMasteries_WhenPassedValidParameters")
.Options;
string validSortOrder = "name_asc";
string validFilter = "testMastery";
int validPageSize = 10;
int validPageNumber = 1;
string validName = "testMastery";
Mastery validMastery = new Mastery
{
Name = validName
};
IEnumerable <Mastery> result = new List <Mastery>();
// Act
using (DataContext actContext = new DataContext(contextOptions))
{
Mock <IPandaScoreClient> pandaScoreEndpointrMock = new Mock <IPandaScoreClient>();
await actContext.Masteries.AddAsync(validMastery);
await actContext.SaveChangesAsync();
MasteryService SUT = new MasteryService(
pandaScoreEndpointrMock.Object,
actContext);
result = await SUT.FilterMasteriesAsync(validSortOrder, validFilter, validPageNumber, validPageSize);
}
// Assert
using (DataContext assertContext = new DataContext(contextOptions))
{
var mastery = result.ToArray()[0];
Assert.IsTrue(assertContext.Masteries.Count().Equals(result.Count()));
Assert.IsTrue(assertContext.Masteries.Any(m => m.Name.Equals(mastery.Name)));
}
}
/// <summary>
/// Create a node from a mastery.
/// </summary>
/// <param name="masteryLevel">The mastery level.</param>
/// <returns></returns>
private TreeNode CreateNode(Mastery masteryLevel)
{
TreeNode node = new TreeNode
{
Text = masteryLevel.ToString(),
Tag = masteryLevel
};
foreach (CertificateLevel certificate in masteryLevel
.OrderBy(cert => cert.Certificate.Class.Name)
.Select(cert => cert.ToCharacter(m_character).GetCertificateLevel(masteryLevel.Level)))
{
node.Nodes.Add(CreateNode(certificate));
}
return(node);
}
/// <summary>
/// Checks whether, after this plan, the owner will be eligible to the provided mastery
/// </summary>
/// <param name="masteryLevel">The mastery level.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">masteryLevel</exception>
public bool WillGrantEligibilityFor(Mastery masteryLevel)
{
masteryLevel.ThrowIfNull(nameof(masteryLevel));
if (masteryLevel.IsTrained)
{
return(true);
}
Character character = Character as Character;
// We check every prerequisite is trained
return(!masteryLevel.Select(mcert => mcert.ToCharacter(character).GetCertificateLevel(masteryLevel.Level))
.SelectMany(cert => cert.PrerequisiteSkills)
.Select(skillToTrain => new { skillToTrain, skill = skillToTrain.Skill })
.Where(skillToTrain => skillToTrain.skill.Level < skillToTrain.skillToTrain.Level)
.Where(skillToTrain => !IsPlanned(skillToTrain.skill, skillToTrain.skillToTrain.Level))
.Select(skill => skill.skillToTrain)
.Any());
}
public int Roll(Mastery masteries)
{
var result = Roll();
if (masteries.HasFlag(Mastery.TwoDice))
{
result = Math.Max(Roll(), result);
}
if (masteries.HasFlag(Mastery.Average))
{
if (result < DiceAverage)
{
result = DiceAverage;
}
}
if (masteries.HasFlag(Mastery.Plus2))
{
result += 2;
}
return(result);
}
IEnumerator WaitForInput(Mastery mastery)
{
bool done = false;
while (!done)
{
if (Input.GetKey(KeyCode.Alpha1))
{
enabledMasteries[0].LoseSkill(this);
enabledMasteries[0] = mastery;
done = true; // breaks the loop
}
if (Input.GetKey(KeyCode.Alpha2))
{
enabledMasteries[1].LoseSkill(this);
enabledMasteries[1] = mastery;
done = true;
}
if (Input.GetKey(KeyCode.Alpha3))
{
enabledMasteries[2].LoseSkill(this);
enabledMasteries[2] = mastery;
done = true;
}
yield return(null);
}
Time.timeScale = 1;
mtext.gameObject.SetActive(false);
mtext1.gameObject.SetActive(false);
mtext2.gameObject.SetActive(false);
mtext3.gameObject.SetActive(false);
mastery.GetSkill(this);
Destroy(goTemp.transform.parent.gameObject);
goTemp = null;
}
public async Task <DiscordEmbed> GetEmbed()
{
var embed = new DiscordEmbedBuilder
{
Title = Title,
Description = Description,
ThumbnailUrl = Mastery.GetAttribute <MasteryInfoAttribute>().ImageUrl,
Color = new DiscordColor(Mastery.GetAttribute <MasteryInfoAttribute>().Color),
Url = BuildUrl
};
embed.WithAuthor((ExpansionRequired) ? $"[{PatchVersion}][AoM]" : $"[{PatchVersion}]");
var author = await Program.Client.GetUserAsync(AuthorId);
embed.AddField("Author", author.Mention);
embed.AddField("Build", BuildUrl);
if (!String.IsNullOrEmpty(ForumUrl))
{
embed.AddField("Forum Post", ForumUrl);
}
if (!String.IsNullOrEmpty(VideoUrl))
{
embed.AddField("Video", VideoUrl);
}
if (!String.IsNullOrEmpty(ImageUrl))
{
embed.ImageUrl = ImageUrl;
}
embed.WithFooter($"ID: {BuildId}");
return(embed.Build());
}
public void ShowMastery(Mastery mastery)
{
masteryPreview.gameObject.SetActive(true);
masteryPicturePreview.sprite = mastery.Icon;
masteryDescription.text = mastery.Description;
}
/// <summary>
/// Create a node from a mastery.
/// </summary>
/// <param name="masteryLevel">The mastery level.</param>
/// <returns></returns>
private TreeNode CreateNode(Mastery masteryLevel)
{
TreeNode node = new TreeNode
{
Text = masteryLevel.ToString(),
Tag = masteryLevel
};
foreach (CertificateLevel certificate in masteryLevel
.OrderBy(cert => cert.Certificate.Class.Name)
.Select(cert => cert.ToCharacter(m_character).GetCertificateLevel(masteryLevel.Level)))
{
node.Nodes.Add(CreateNode(certificate));
}
return node;
}
public static void Background_is_not_empty(Mastery actual) => Assert.NotEmpty(actual.Background);
public static void Region_is_known(Mastery actual) => Assert.NotEqual(MasteryRegionName.Unknown, actual.Region);
public static void Order_is_not_negative(Mastery actual) => Assert.InRange(actual.Order, 0, int.MaxValue);
public static void Requirement_is_not_null(Mastery actual) => Assert.NotNull(actual.Requirement);
/// <summary>
/// Sets the visible status of the context menu submenu.
/// </summary>
/// <param name="menu">The menu.</param>
/// <param name="masteryLevel">The mastery level.</param>
private void SetAdditionMenuStatus(ToolStripItem menu, Mastery masteryLevel)
{
menu.Visible = masteryLevel != null;
if (masteryLevel == null)
return;
menu.Enabled = !Plan.WillGrantEligibilityFor(masteryLevel);
if (menu.Enabled)
menu.Tag = Plan.TryPlanTo(masteryLevel);
}
/// <summary>
/// Updates a "plan to" menu.
/// </summary>
/// <param name="menu">The menu to update</param>
/// <param name="masteryLevel">The level represent by this menu</param>
/// <param name="lastEligibleMasteryLevel">The highest eligible mastery after this plan</param>
private void UpdatePlanningMenuStatus(ToolStripItem menu, Mastery masteryLevel, Mastery lastEligibleMasteryLevel)
{
menu.Visible = masteryLevel != null;
menu.Enabled = masteryLevel != null &&
(lastEligibleMasteryLevel == null || masteryLevel.Level > lastEligibleMasteryLevel.Level);
if (menu.Enabled)
menu.Tag = Plan.TryPlanTo(masteryLevel);
}
/// <summary>
/// Deserialization constructor.
/// </summary>
/// <param name="masteryLevel">The mastery level.</param>
/// <param name="src">The source.</param>
internal MasteryCertificate(Mastery masteryLevel, SerializableMasteryCertificate src)
{
MasteryLevel = masteryLevel;
Certificate = StaticCertificates.GetCertificateByID(src.ID);
}
