public void TestDiff(string leftSerialized, string rightSerialized, string expected)
{
var notes = new Dictionary <int, string>();
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(leftSerialized));
var leftRequirements = builder.ToAchievement().CoreRequirements;
builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(rightSerialized));
var rightRequirements = builder.ToAchievement().CoreRequirements;
var vmRequirementGroup = new RequirementGroupViewModel("Group", leftRequirements, rightRequirements, NumberFormat.Decimal, notes);
var strBuilder = new StringBuilder();
foreach (var vmRequirement in vmRequirementGroup.Requirements)
{
var vmComparison = vmRequirement as RequirementComparisonViewModel;
strBuilder.Append(vmComparison.Definition);
strBuilder.Append('|');
strBuilder.Append(vmComparison.OtherDefinition);
strBuilder.Append('\n');
}
strBuilder.Length--;
Assert.That(strBuilder.ToString(), Is.EqualTo(expected));
}
public void TestCommitVersionDetectedCulture()
{
using (var cultureOverride = new CultureOverride("fr-FR"))
{
var memoryStream = new MemoryStream();
var achievements = Initialize(null, memoryStream);
achievements.Title = "Title";
Assert.That(achievements.Achievements.Count(), Is.EqualTo(0));
var builder = new AchievementBuilder();
builder.Title = "T";
builder.Description = "D";
builder.Points = 1;
builder.CoreRequirements.Add(new Requirement
{
Type = RequirementType.Trigger,
Left = new Field {
Size = FieldSize.Byte, Type = FieldType.MemoryAddress, Value = 0x1234
},
Operator = RequirementOperator.Equal,
Right = new Field {
Type = FieldType.Value, Value = 1
}
});;
var achievement = builder.ToAchievement();
achievements.Replace(null, achievement);
achievements.Commit("Test", null, null);
var output = Encoding.UTF8.GetString(memoryStream.ToArray());
Assert.That(output, Is.EqualTo("0.79\r\nTitle\r\n0:\"T:0xH001234=1\":\"T\":\"D\": : : :Test:1:0:0:0:0:\r\n"));
}
}
public void TestCommitNoFile()
{
var memoryStream = new MemoryStream();
var achievements = Initialize(null, memoryStream);
achievements.Title = "FromScript";
Assert.That(achievements.Achievements.Count(), Is.EqualTo(0));
var builder = new AchievementBuilder();
builder.Title = "T";
builder.Description = "D";
builder.Points = 1;
builder.CoreRequirements.Add(new Requirement
{
Left = new Field {
Size = FieldSize.Byte, Type = FieldType.MemoryAddress, Value = 0x1234
},
Operator = RequirementOperator.Equal,
Right = new Field {
Type = FieldType.Value, Value = 1
}
});
var achievement = builder.ToAchievement();
achievements.Replace(null, achievement);
achievements.Commit("Test", null, null);
var output = Encoding.UTF8.GetString(memoryStream.ToArray());
Assert.That(output, Is.EqualTo("0.030\r\nFromScript\r\n0:\"0xH001234=1\":\"T\":\"D\": : : :Test:1:0:0:0:0:\r\n"));
}
public void TestParseRequirements(string input, string expected)
{
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(input));
Assert.That(builder.RequirementsDebugString, Is.EqualTo(expected));
}
private void WriteAchievement(StreamWriter writer, string author, Achievement achievement, StringBuilder warning)
{
writer.Write(achievement.Id);
writer.Write(":\"");
var requirements = AchievementBuilder.SerializeRequirements(achievement);
if (requirements.Length > AchievementMaxLength && warning != null)
{
warning.AppendFormat("Achievement \"{0}\" exceeds serialized limit ({1}/{2})", achievement.Title, requirements.Length, AchievementMaxLength);
warning.AppendLine();
}
writer.Write(requirements);
writer.Write("\":\"");
WriteEscaped(writer, achievement.Title);
writer.Write("\":\"");
WriteEscaped(writer, achievement.Description);
writer.Write("\":");
writer.Write(" : : :"); // discontinued features
writer.Write(author); // author
writer.Write(':');
writer.Write(achievement.Points);
writer.Write(':');
writer.Write("0:0:0:0:"); // created, modified, upvotes, downvotes
writer.Write(achievement.BadgeName);
writer.WriteLine();
}
private string Process(string input)
{
var parser = Parse("achievement(\"T\", \"D\", 5, " + input + ")");
Assert.That(parser.Achievements.Count(), Is.EqualTo(1));
var achievement = parser.Achievements.First();
var builder = new AchievementBuilder(achievement);
return(builder.SerializeRequirements());
}
public void TestAddAddress(string input, string expected)
{
var requirements = Evaluate(input);
var builder = new StringBuilder();
AchievementBuilder.AppendStringGroup(builder, requirements, NumberFormat.Hexadecimal);
Assert.That(builder.ToString(), Is.EqualTo(expected));
}
/// <summary>
/// Determines if the achievement's requirements match a second achievement.
/// </summary>
/// <returns><c>true</c> if the requirements match, <c>false</c> if not.</returns>
public bool AreRequirementsSame(Achievement achievement)
{
var builder1 = new AchievementBuilder(this);
builder1.Optimize();
var builder2 = new AchievementBuilder(achievement);
builder2.Optimize();
return(builder1.AreRequirementsSame(builder2));
}
private static Achievement CreateValue(string definition)
{
var achievementBuilder = new AchievementBuilder();
if (definition.Length > 2)
{
if (definition[1] == ':')
achievementBuilder.ParseRequirements(Tokenizer.CreateTokenizer(definition));
else
achievementBuilder.ParseValue(Tokenizer.CreateTokenizer(definition));
}
return achievementBuilder.ToAchievement();
}
public void TestSimple()
{
var achievement = Evaluate("achievement(\"T\", \"D\", 5, byte(0x1234) == 1)");
Assert.That(achievement.Title, Is.EqualTo("T"));
Assert.That(achievement.Description, Is.EqualTo("D"));
Assert.That(achievement.Points, Is.EqualTo(5));
var builder = new AchievementBuilder(achievement);
Assert.That(builder.SerializeRequirements(), Is.EqualTo("0xH001234=1"));
}
public void TestDefaultConstructor()
{
var builder = new AchievementBuilder();
Assert.That(builder.Title, Is.EqualTo(""));
Assert.That(builder.Description, Is.EqualTo(""));
Assert.That(builder.Points, Is.EqualTo(0));
Assert.That(builder.Id, Is.EqualTo(0));
Assert.That(builder.BadgeName, Is.EqualTo(""));
Assert.That(builder.CoreRequirements.Count, Is.EqualTo(0));
Assert.That(builder.AlternateRequirements.Count, Is.EqualTo(0));
}
public void TestDefinition(string serialized, string expected)
{
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(serialized));
var requirement = builder.ToAchievement().CoreRequirements.First();
var notes = new Dictionary <int, string>();
var vmRequirement = new RequirementViewModel(requirement, NumberFormat.Decimal, notes);
Assert.That(vmRequirement.Definition, Is.EqualTo(expected));
}
public void TestParseRequirementsAddSourceUninitializedRight()
{
// ensures requirement.Right is uninitialized for AddSource
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer("A:0xN20770f=0"));
var requirement = builder.CoreRequirements.First();
Assert.That(requirement.Right.Size, Is.EqualTo(FieldSize.None));
Assert.That(requirement.Right.Type, Is.EqualTo(FieldType.None));
Assert.That(requirement.Right.Value, Is.EqualTo(0));
}
public void TestSerializeRequirements(string input, string expected)
{
// verify serialization of the builder
var achievement = CreateAchievement(input);
Assert.That(achievement.SerializeRequirements(), Is.EqualTo(expected));
// convert to actual achievement and verify serialization of that
var cheev = achievement.ToAchievement();
Assert.That(AchievementBuilder.SerializeRequirements(cheev), Is.EqualTo(expected));
}
/// <summary>
/// Commits the achivement list back to the 'XXX-User.txt' file.
/// </summary>
public void Commit(string author)
{
var warning = new StringBuilder();
using (var writer = new StreamWriter(_fileSystemService.CreateFile(_filename)))
{
writer.WriteLine(_version);
writer.WriteLine(Title);
foreach (var achievement in _achievements)
{
writer.Write(achievement.Id);
writer.Write(":\"");
var requirements = AchievementBuilder.SerializeRequirements(achievement);
if (requirements.Length > AchievementMaxLength)
{
warning.AppendFormat("Achievement \"{0}\" exceeds serialized limit ({1}/{2})", achievement.Title, requirements.Length, AchievementMaxLength);
warning.AppendLine();
}
writer.Write(requirements);
writer.Write("\":\"");
WriteEscaped(writer, achievement.Title);
writer.Write("\":\"");
WriteEscaped(writer, achievement.Description);
writer.Write("\":");
writer.Write(" : : :"); // discontinued features
writer.Write(author); // author
writer.Write(':');
writer.Write(achievement.Points);
writer.Write(':');
writer.Write("0:0:0:0:"); // created, modified, upvotes, downvotes
writer.Write(achievement.BadgeName);
writer.WriteLine();
}
}
if (warning.Length > 0)
{
MessageBoxViewModel.ShowMessage(warning.ToString());
}
}
public void TestRemovedRequirement()
{
var notes = new Dictionary <int, string>();
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer("0xH1234=7"));
var requirement = builder.ToAchievement().CoreRequirements.First();
var vmRequirement = new RequirementComparisonViewModel(null, requirement, NumberFormat.Decimal, notes);
Assert.That(vmRequirement.Definition, Is.EqualTo(""));
Assert.That(vmRequirement.OtherDefinition, Is.EqualTo("byte(0x001234) == 7"));
Assert.That(vmRequirement.IsModified, Is.True);
}
private static string Evaluate(string input)
{
var script = "achievement(\"title\", \"desc\", 5,\n" + input + "\n)";
var tokenizer = Tokenizer.CreateTokenizer(script);
var parser = new AchievementScriptInterpreter();
if (parser.Run(tokenizer))
{
var achievement = parser.Achievements.First();
var builder = new AchievementBuilder(achievement);
return(builder.RequirementsDebugString);
}
return(parser.Error.InnermostError.Message);
}
protected override ParseErrorExpression ModifyRequirements(AchievementBuilder builder)
{
// not actually modifying requirements, but allows us to do some validation
foreach (var requirement in builder.CoreRequirements)
{
if (requirement.Type == RequirementType.AddHits)
{
return(new ParseErrorExpression("tally not allowed in subclause"));
}
if (requirement.Type == RequirementType.SubHits)
{
return(new ParseErrorExpression("tally not allowed in subclause"));
}
}
return(null);
}
protected override ParseErrorExpression ModifyRequirements(AchievementBuilder builder)
{
var requirementsEx = RequirementEx.Combine(builder.CoreRequirements);
foreach (var requirementEx in requirementsEx)
{
var lastCondition = requirementEx.Requirements.Last();
if (lastCondition.Type != RequirementType.None)
{
return(new ParseErrorExpression(string.Format("Cannot apply '{0}' to condition already flagged with {1}", Name.Name, lastCondition.Type)));
}
lastCondition.Type = RequirementType.SubHits;
}
return(null);
}
public void TestNotes(string serialized, string expected)
{
var notes = new Dictionary <int, string>();
notes[0x1234] = "Addr1";
notes[0x2345] = "Addr2";
notes[0x3456] = "This note is long enough that it will need to be wrapped.";
notes[0x4567] = "This note\nis multiple\nlines.";
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(serialized));
var requirement = builder.ToAchievement().CoreRequirements.First();
var vmRequirement = new RequirementViewModel(requirement, NumberFormat.Decimal, notes);
Assert.That(vmRequirement.Notes, Is.EqualTo(expected));
}
private static bool Matches(string memAddr, SearchCriteria criteria)
{
AchievementBuilder builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(memAddr));
if (criteria.NumConditionsComparison != RequirementOperator.None)
{
var numConditions = builder.CoreRequirements.Count;
foreach (var altGroup in builder.AlternateRequirements)
{
numConditions += altGroup.Count;
}
if (!ValueMatches(numConditions, criteria.NumConditions, criteria.NumConditionsComparison))
{
return(false);
}
}
if (!ValueMatches(builder.AlternateRequirements.Count, criteria.NumAltGroups, criteria.NumAltGroupsComparison))
{
return(false);
}
foreach (var condition in builder.CoreRequirements)
{
if (ConditionMatches(condition, criteria))
{
return(true);
}
}
foreach (var altGroup in builder.AlternateRequirements)
{
foreach (var condition in altGroup)
{
if (ConditionMatches(condition, criteria))
{
return(true);
}
}
}
return(false);
}
public void TestPredicateWithDefaultParameter()
{
var script = "function p(addr, id=17) => byte(addr) == id\n" +
"achievement(\"title\", \"desc\", 5, any_of([1, 2, 3], p))";
var tokenizer = Tokenizer.CreateTokenizer(script);
var parser = new AchievementScriptInterpreter();
if (!parser.Run(tokenizer))
{
Assert.Fail(parser.ErrorMessage);
}
var achievement = parser.Achievements.First();
var builder = new AchievementBuilder(achievement);
Assert.That(builder.RequirementsDebugString, Is.EqualTo(
"byte(0x000001) == 17 || byte(0x000002) == 17 || byte(0x000003) == 17"));
}
public void TestScopedVariable()
{
var script = "function ItemInInventory(id) => any_of(range(0x1200, 0x1208, step=2), addr => word(addr) == id)\n" +
"achievement(\"title\", \"desc\", 5, ItemInInventory(17))";
var tokenizer = Tokenizer.CreateTokenizer(script);
var parser = new AchievementScriptInterpreter();
if (!parser.Run(tokenizer))
{
Assert.Fail(parser.ErrorMessage);
}
var achievement = parser.Achievements.First();
var builder = new AchievementBuilder(achievement);
Assert.That(builder.RequirementsDebugString, Is.EqualTo(
"word(0x001200) == 17 || word(0x001202) == 17 || word(0x001204) == 17 || word(0x001206) == 17 || word(0x001208) == 17"));
}
/// <summary>
/// Commits the asset list back to the 'XXX-User.txt' file.
/// </summary>
public void Commit(string author, StringBuilder warning, List <AssetBase> assetsToValidate)
{
double version = 0.30;
foreach (var achievement in _achievements)
{
var achievementMinimumVersion = AchievementBuilder.GetMinimumVersion(achievement);
if (achievementMinimumVersion > version)
{
version = achievementMinimumVersion;
}
}
foreach (var leaderboard in _leaderboards)
{
var leaderboardMinimumVersion = AchievementBuilder.GetMinimumVersion(leaderboard);
if (leaderboardMinimumVersion > version)
{
version = leaderboardMinimumVersion;
}
}
if (version > 0.30)
{
Version = String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:F2}", version);
}
using (var writer = new StreamWriter(_fileSystemService.CreateFile(_filename)))
{
writer.WriteLine(Version);
writer.WriteLine(Title);
foreach (var achievement in _achievements)
{
WriteAchievement(writer, author, achievement, (assetsToValidate == null || assetsToValidate.Contains(achievement)) ? warning : null);
}
foreach (var leaderboard in _leaderboards)
{
WriteLeaderboard(writer, leaderboard, (assetsToValidate == null || assetsToValidate.Contains(leaderboard)) ? warning : null);
}
}
}
public void TestConstructAlts()
{
var achievement = Evaluate("trigger = always_false()\n" +
"for i in range(0, 10)\n" +
" trigger = trigger || word(0x1000+i) == 10 && prev(word(0x1000+i)) < 10\n" +
"achievement(\"A\", \"B\", 10, trigger)");
var expected = new StringBuilder();
expected.Append("1=1");
for (int i = 0; i <= 10; i++)
{
expected.AppendFormat("S0x {0:x6}=10_d0x {0:x6}<10", i + 0x1000);
}
var builder = new AchievementBuilder(achievement);
Assert.That(builder.SerializeRequirements(), Is.EqualTo(expected.ToString()));
}
public void TestInitialize()
{
var achievements = Initialize("0.099\nTitle\n0:0xH0000c5=0_0xH0000b9=1:I Need Your Help:Talk to the ghost to begin your quest: : : :Jamiras:5:0:0:0:0:53352\n", null);
Assert.That(achievements.Title, Is.EqualTo("Title"));
Assert.That(achievements.Achievements.Count(), Is.EqualTo(1));
var achievement = achievements.Achievements.First();
Assert.That(achievement.Id, Is.EqualTo(0));
Assert.That(achievement.Title, Is.EqualTo("I Need Your Help"));
Assert.That(achievement.Description, Is.EqualTo("Talk to the ghost to begin your quest"));
Assert.That(achievement.Points, Is.EqualTo(5));
Assert.That(achievement.BadgeName, Is.EqualTo("53352"));
var builder = new AchievementBuilder(achievement);
Assert.That(builder.RequirementsDebugString, Is.EqualTo("byte(0x0000C5) == 0 && byte(0x0000B9) == 1"));
}
public LeaderboardViewModel(GameViewModel owner, Leaderboard leaderboard)
{
_clipboard = ServiceRepository.Instance.FindService <IClipboardService>();
_leaderboard = leaderboard;
Title = leaderboard.Title;
Description = leaderboard.Description;
var groups = new List <LeaderboardGroupViewModel>();
var achievement = new AchievementBuilder();
achievement.ParseRequirements(Tokenizer.CreateTokenizer(_leaderboard.Start));
groups.Add(new LeaderboardGroupViewModel("Start Conditions", achievement.ToAchievement().CoreRequirements, owner.Notes)
{
CopyToClipboardCommand = new DelegateCommand(() => _clipboard.SetData(_leaderboard.Start))
});
achievement = new AchievementBuilder();
achievement.ParseRequirements(Tokenizer.CreateTokenizer(_leaderboard.Cancel));
groups.Add(new LeaderboardGroupViewModel("Cancel Condition", achievement.ToAchievement().CoreRequirements, owner.Notes)
{
CopyToClipboardCommand = new DelegateCommand(() => _clipboard.SetData(_leaderboard.Cancel))
});
achievement = new AchievementBuilder();
achievement.ParseRequirements(Tokenizer.CreateTokenizer(_leaderboard.Submit));
groups.Add(new LeaderboardGroupViewModel("Submit Condition", achievement.ToAchievement().CoreRequirements, owner.Notes)
{
CopyToClipboardCommand = new DelegateCommand(() => _clipboard.SetData(_leaderboard.Submit))
});
groups.Add(new LeaderboardGroupViewModel("Value", _leaderboard.Value, owner.Notes)
{
CopyToClipboardCommand = new DelegateCommand(() => _clipboard.SetData(_leaderboard.Value))
});
Groups = groups;
UpdateLocalCommand = null;
CanUpdate = false;
}
public void TestDefinitions(string leftSerialized, string rightSerialized,
string expectedDefinition, string expectedOtherDefinition, bool expectedModified)
{
var notes = new Dictionary <int, string>();
var builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(leftSerialized));
var requirement = builder.ToAchievement().CoreRequirements.First();
builder = new AchievementBuilder();
builder.ParseRequirements(Tokenizer.CreateTokenizer(rightSerialized));
var compareRequirement = builder.ToAchievement().CoreRequirements.First();
var vmRequirement = new RequirementComparisonViewModel(requirement, compareRequirement, NumberFormat.Decimal, notes);
Assert.That(vmRequirement.Definition, Is.EqualTo(expectedDefinition));
Assert.That(vmRequirement.OtherDefinition, Is.EqualTo(expectedOtherDefinition));
Assert.That(vmRequirement.IsModified, Is.EqualTo(expectedModified));
}
public void TestReplace()
{
var achievements = Initialize("0.099\nTitle\n0:0xH001234=0:A:B: : : :U:5:0:0:D:R:B\n", null);
Assert.That(achievements.Achievements.Count(), Is.EqualTo(1));
var achievement = achievements.Achievements.First();
var builder = new AchievementBuilder();
builder.Title = "A2";
builder.Description = "D2";
builder.Points = 10;
var achievement2 = builder.ToAchievement();
var previous = achievements.Replace(achievement, achievement2);
Assert.That(previous, Is.SameAs(achievement));
Assert.That(achievements.Achievements.Count(), Is.EqualTo(1));
Assert.That(achievements.Achievements.First(), Is.SameAs(achievement2));
}
public void TestCombine(string input, string expected)
{
var achievement = new AchievementBuilder();
achievement.ParseRequirements(Tokenizer.CreateTokenizer(input));
var groups = RequirementEx.Combine(achievement.CoreRequirements);
var builder = new StringBuilder();
foreach (var group in groups)
{
if (builder.Length > 0)
{
builder.Append('|');
}
group.AppendString(builder, NumberFormat.Decimal);
}
Assert.That(builder.ToString(), Is.EqualTo(expected));
// make sure we didn't modify the source requirements
Assert.That(achievement.SerializeRequirements(), Is.EqualTo(input));
}
