public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "players_countries":
PlayerCountries = parser.ReadStringList();
break;
case "countries":
var countriesParser = parser.Parse(new CountriesParser());
foreach (var country in countriesParser.Countries)
{
Countries.Add(new JProperty(country.Tag, JObject.FromObject(country)));
}
break;
case "diplomacy":
var diplomacyParser = parser.Parse(new DiplomacyParser());
foreach (var keyValue in diplomacyParser.DiplomaciesByType)
{
var jArray = new JArray(keyValue.Value.Select(p => JObject.FromObject(p)));
Diplomacy.Add(new JProperty(keyValue.Key, jArray));
}
break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "leader": Leader = parser.Parse(new ParadoxId()); break;
case "unit": Units.Add(parser.Parse(new Unit())); break;
case "attachments": Attachments = parser.ReadList(() => parser.Parse (new ParadoxId())); break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "leader": Leader = parser.Parse(new ParadoxId()); break;
case "unit": Units.Add(parser.Parse(new Unit())); break;
case "attachments": Attachments = parser.ReadList(() => parser.Parse(new ParadoxId())); break;
}
}
public static RuleSet Parse(string filename, string name)
{
m_ruleset = new RuleSet();
m_ruleset.Name = name;
if (!File.Exists(filename))
{
m_ruleset.Errors.Add(string.Format("File not found: {0}", filename));
return(m_ruleset);
}
using (FileStream fs = new FileStream(filename, FileMode.Open))
{
try
{
ParadoxParser.Parse(fs, ParseRule);
m_ruleset.LawRules.ParentRuleSet = m_ruleset;
} catch (Exception ex)
{
m_ruleset.Errors.Add(ex.ToString());
}
}
return(m_ruleset);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("Expected path to a .eu4 file.");
return;
}
//dotnet publish -c Release --no-self-contained -r linux-x64
//dotnet publish -c Release -r linux-x64
var sw = new Stopwatch();
sw.Start();
Console.WriteLine("\nStart parsing\n");
using var stream = OpenSaveGame(args[0]);
var stats = ParadoxParser.Parse(stream, new Parser());
Console.WriteLine($"\nParsing finished after {sw.Elapsed.TotalSeconds:N2}s");
Console.WriteLine("\nStart exporting to json\n");
sw.Restart();
string json = JsonConvert.SerializeObject(stats, Formatting.Indented);
string dir = Path.GetDirectoryName(args[0]);
string fileName = Path.GetFileNameWithoutExtension(args[0]) + ".json";
File.WriteAllText(Path.Combine(dir, fileName), json);
Console.WriteLine($"\nExporting finished after {sw.Elapsed.TotalSeconds:N2}s");
}
public void NestedParse()
{
string input = @"rebel_faction=
{
id=
{
id=21016
type=40
}
type=""nationalist_rebels""
}";
string actual = string.Empty;
Action <ParadoxParser, string> action = (p, s) =>
{
if (s == "rebel_faction")
{
Action <ParadoxParser, string> innerAction = (p2, s2) =>
{
if (p2.CurrentIndent == 1 && s2 == "type")
{
actual = p2.ReadString();
}
};
p.Parse(innerAction);
}
};
ParadoxParser.Parse(input.ToStream(), action);
Assert.AreEqual("nationalist_rebels", actual);
}
public void ParseListObject()
{
var data = @"attachments={
{
id=2296
type=54
}
{
id=61768
type=4713
}
}";
IList <Cid> actual = null;
ParadoxParser.Parse(data.ToStream(), (p, s) =>
{
if (s == "attachments")
{
actual = p.ReadList(() => p.Parse(new Cid()));
}
});
Assert.NotNull(actual);
Assert.Equal(2, actual.Count);
Assert.Equal(2296, actual[0].Id);
Assert.Equal(54, actual[0].Type);
Assert.Equal(61768, actual[1].Id);
Assert.Equal(4713, actual[1].Type);
}
public void BooleanParse3()
{
var data = "cool={ 1.0 }".ToStream();
Assert.Throws <ApplicationException>(() =>
ParadoxParser.Parse(data, (p, s) => p.ReadBool()));
}
public void SimpleMultiLine()
{
string toParse = "date=\"1770.12.5\"" + Environment.NewLine +
"player=\"JAP\"" + Environment.NewLine +
"monarch=12209";
var data = toParse.ToStream();
DateTime?actualDate = null;
string actualPlayer = null;
int? actualMonarch = null;
Dictionary <string, Action <ParadoxParser> > dictionary = new Dictionary <string, Action <ParadoxParser> >
{
{ "date", x => actualDate = x.ReadDateTime() },
{ "player", x => actualPlayer = x.ReadString() },
{ "monarch", x => actualMonarch = x.ReadInt32() }
};
ParadoxParser.Parse(data, dictionary.ParserAdapter());
Assert.That(actualDate.HasValue);
Assert.That(!String.IsNullOrEmpty(actualPlayer));
Assert.That(actualMonarch.HasValue);
Assert.AreEqual(new DateTime(1770, 12, 5), actualDate);
Assert.AreEqual("JAP", actualPlayer);
Assert.AreEqual(12209, actualMonarch);
}
public void FloatPrecedingAndTrailingZeroesDontMatter()
{
Stream data = "list={ 0001.200 0.63 2.110000 0023.421000 }".ToStream();
ParadoxParser.Parse(data, floatAction);
Assert.Equal(expectedFloat, actualFloat);
}
private void ParseDynasties(ParadoxParser parser, string tag)
{
Dynasty dyn = new Dynasty();
dyn.ID = Int32.Parse(tag);
dyn.Filename = m_lastFileName;
Dynasties[dyn.ID] = dyn;
Action <ParadoxParser, string> getOptions = (p, s) =>
{
if (s == "name")
{
dyn.Name = p.ReadString();
}
else if (s == "culture")
{
dyn.CultureString = p.ReadString();
}
else if (s == "coat_of_arms")
{
ParseCoatOfArms(dyn, p, s);
}
};
parser.Parse(getOptions);
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (parser.CurrentIndent == 1)
{
Countries.Add(parser.Parse(new Country(token)));
}
}
public void ReadCommaDoubleNoSpaceList()
{
Stream data = "list={1.200,.63,2.11,23.421}".ToStream();
ParadoxParser.Parse(data, floatAction);
Assert.Equal(expectedFloat, actualFloat);
}
public void SimpleList()
{
Stream data = "list={1 2 3 4 5 6 7 8}".ToStream();
ParadoxParser.Parse(data, action);
Assert.Equal(expected, actual);
}
public void VerySpacedList()
{
var data = " list = { 1 2 3 4 5 6 7 8 } ".ToStream();
ParadoxParser.Parse(data, action);
Assert.Equal(expected, actual);
}
/// <summary>
/// Loads a file containing a province.
/// </summary>
/// <param name="filename">Path of the file to load.</param>
public override void Parse(string filename)
{
if (!File.Exists(filename))
{
Errors.Add("Unable to find file: " + filename);
return;
}
using (FileStream fs = new FileStream(filename, FileMode.Open))
{
try
{
m_curProv = new Province();
m_curProv.Filename = filename;
m_curProv.ID = Int32.Parse(Path.GetFileName(filename).Split('-')[0].Trim());
ParadoxParser.Parse(fs, ParseProvinceData);
if (!String.IsNullOrWhiteSpace(m_curProv.Title))
{
if (Provinces.ContainsKey(m_curProv.ID))
{
Provinces.Remove(m_curProv.ID);
}
Provinces[m_curProv.ID] = m_curProv;
}
m_curProv = null;
} catch (Exception ex)
{
Errors.Add(ex.ToString());
}
}
}
public void IntEmptySpacedList()
{
var data = " list = { } ".ToStream();
ParadoxParser.Parse(data, action);
Assert.Equal(Enumerable.Empty <int>(), actual);
}
public void SpaceList()
{
var data = "list = { 1 2 3 4 5 6 7 8 }".ToStream();
ParadoxParser.Parse(data, action);
CollectionAssert.AreEqual(expected, actual);
}
public void ReadCommaIntList()
{
var data = "list = { 1, 2, 3, 4, 5 }".ToStream();
ParadoxParser.Parse(data, action);
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5 }, actual);
}
public void DoubleEmptyList()
{
var data = "list={}".ToStream();
ParadoxParser.Parse(data, floatAction);
Assert.Equal(Enumerable.Empty <double>(), actualFloat);
}
public void IntEmptyList()
{
var data = "list={}".ToStream();
ParadoxParser.Parse(data, action);
CollectionAssert.AreEqual(Enumerable.Empty <int>(), actual);
}
private void ParseCultureGroups(ParadoxParser parser, string tag)
{
CultureGroup cg = new CultureGroup();
cg.Name = tag;
cg.Filename = m_lastFileName;
if (CultureGroups.ContainsKey(tag))
{
CultureGroups.Remove(tag);
}
CultureGroups[tag] = cg;
Action <ParadoxParser, string> getOptions = (p, s) =>
{
if (s == "graphical_culture")
{
cg.GraphicalCulture = p.ReadString();
}
else if (s == "second_graphical_culture")
{
p.ReadString();
}
else
{
ParseCultures(cg, p, s);
}
};
parser.Parse(getOptions);
}
public void ReadCommaIntListNoSpace()
{
var data = "list={1,2,3,4,5}".ToStream();
ParadoxParser.Parse(data, action);
Assert.Equal(new[] { 1, 2, 3, 4, 5 }, actual);
}
public void VerySpacedFloatingList()
{
Stream data = " list = { 1.200 .63 2.11 23.421 } ".ToStream();
ParadoxParser.Parse(data, floatAction);
Assert.Equal(expectedFloat, actualFloat);
}
partial void unrecognizedToken(ParadoxParser parser, string token)
{
if (token.Length == 3 && token.ToUpper() == token)
{
_powers.Add(parser.Parse(new TradePower(token)));
}
}
public void SimpleFloatingList()
{
Stream data = "list={1.200 .63 2.11 23.421}".ToStream();
ParadoxParser.Parse(data, floatAction);
CollectionAssert.AreEqual(expectedFloat, actualFloat);
}
public void TokenCallback(ParadoxParser parser, string token)
{
CultureGroupDefinition cultureGroup = new CultureGroupDefinition();
cultureGroup.Entity.Id = token;
CultureGroups.Add(parser.Parse(cultureGroup));
}
public void BooleanParse2()
{
var data = "cool=no".ToStream();
bool isCool = true;
ParadoxParser.Parse(data, (p, s) => isCool = p.ReadBool());
Assert.Equal(false, isCool);
}
public void BooleanParse()
{
var data = "cool=yes".ToStream();
bool isCool = false;
ParadoxParser.Parse(data, (p, s) => isCool = p.ReadBool());
Assert.AreEqual(true, isCool);
}
public void TokenCallback(ParadoxParser parser, string token)
{
LandedTitleDefinition landedTitle = new LandedTitleDefinition();
landedTitle.Entity.Id = token;
LandedTitles.Add(parser.Parse(landedTitle));
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "development":
Development = parser.ReadFloat();
break;
case "raw_development":
RawDevelopment = parser.ReadFloat();
break;
case "capped_development":
CappedDevelopment = parser.ReadFloat();
break;
case "realm_development":
RealmDevelopment = parser.ReadFloat();
break;
case "institutions":
Institutions = parser.ReadIntList();
break;
case "colors":
Colors = parser.Parse(new Colors());
break;
case "estimated_monthly_income":
EstimatedMonthlyIncome = parser.ReadFloat();
break;
case "technology":
Technology = parser.Parse(new Technology());
break;
case "great_power_score":
GreatPowerScore = parser.ReadFloat();
break;
case "score_rating":
ScoreRatings = parser.ReadDoubleList();
break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == this.currentParsedProvinceStr && parser.CurrentIndent == 0)
{
var newProv = new SaveProvince(this.currentParsedProvince++);
this.Provinces.Add(parser.Parse <SaveProvince>(newProv));
this.currentParsedProvinceStr = this.currentParsedProvince.ToString();
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == this.currentParsedProvinceStr && parser.CurrentIndent == 0)
{
var newProv = new SaveProvince(this.currentParsedProvince++);
this.Provinces.Add(parser.Parse<SaveProvince>(newProv));
this.currentParsedProvinceStr = this.currentParsedProvince.ToString();
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token != "id")
throw new ApplicationException("Unrecognized token: " + token);
if (parser.NextIsBracketed())
EventIds.Add(parser.Parse(new ParadoxId()));
else
EventNames.Add(parser.ReadString());
}
private static void ParseLaws( ParadoxParser parser, List<Law> lawRules )
{
Law l = new Law( "" );
Action<ParadoxParser, string> lawGroup = ( p, s ) =>
{
l = new Law( s );
Action<ParadoxParser, string> lawOptions = ( p2, s2 ) =>
{
switch( s2 )
{
case "banned_religion_group":
case "banned_religion":
l.BannedReligions.Add( p2.ReadString() );
break;
case "allowed_religion_group":
case "allowed_religion":
l.AllowedReligions.Add( p2.ReadString() );
break;
case "banned_culture_group":
case "banned_culture":
l.BannedCultures.Add( p2.ReadString() );
break;
case "allowed_culture_group":
case "allowed_culture":
l.AllowedCultures.Add( p2.ReadString() );
break;
}
};
p.Parse( lawOptions );
lawRules.Add( l );
};
parser.Parse( lawGroup );
}
partial void unrecognizedToken(ParadoxParser parser, string token)
{
if (!parser.NextIsBracketed())
throw new ApplicationException("Unrecognized token: " + token);
WarGoal = parser.Parse(new WarGoal(token));
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "name": Name = parser.ReadString(); break;
case "tax": Tax = parser.ReadDouble(); break;
case "add_core": Cores.Add(parser.ReadString()); break;
case "top_provinces": TopProvinces = parser.ReadStringList(); break;
case "army": Armies.Add(parser.Parse(new Army())); break;
}
}
public void TokenCallback(ParadoxParser parser, string token)
{
if (token == "incoming")
incomings.Add(parser.Parse(new Incoming()));
else if (token == "trade_goods_size")
tradeGoodsSize = parser.ReadDoubleList();
else
throw new ApplicationException(token + " not recognized");
}
public void TokenCallback(ParadoxParser parser, string token)
{
switch (token)
{
case "actual_added_value": actualAddedValue = parser.ReadInt32(); break;
case "value": value = parser.ReadInt32(); break;
case "from": from = parser.ReadInt32(); break;
case "modifier": modifier = parser.Parse(new Cid()); break;
}
}
private static CharacterRule ParseCharacter( ParadoxParser parser )
{
CharacterRule cr = new CharacterRule();
Action<ParadoxParser, string> getOptions = ( p, s ) =>
{
switch( s )
{
case "gender":
cr.IsFemale = p.ReadString() == "female";
break;
case "religion":
cr.Religion = p.ReadString();
break;
case "culture":
cr.Culture = p.ReadString();
break;
case "id":
cr.ID = p.ReadInt32();
break;
case "dynasty":
cr.Dynasty = p.ReadInt32();
break;
case "write_character":
cr.WriteCharacter = p.ReadBool();
break;
case "title":
cr.Titles.Add( p.ReadString() );
break;
}
};
parser.Parse( getOptions );
return cr;
}
private static void ParseRule( ParadoxParser parser, string tag )
{
switch( tag )
{
case "ignored_titles":
m_ruleset.IgnoredTitles.AddRange( parser.ReadStringList() );
break;
case "muslim_laws":
m_ruleset.MuslimLawFollowers.AddRange( parser.ReadStringList() );
break;
case "male_culture":
m_ruleset.MaleCultures.AddRange( parser.ReadStringList() );
break;
case "female_culture":
m_ruleset.FemaleCultures.AddRange( parser.ReadStringList() );
break;
case "male_religion":
m_ruleset.MaleReligions.AddRange( parser.ReadStringList() );
break;
case "female_religion":
m_ruleset.FemaleReligions.AddRange( parser.ReadStringList() );
break;
case "required_rules":
m_ruleset.RequiredRules.AddRange( parser.ReadStringList() );
break;
case "levy_tax_weight":
List<int> ltw = (List<int>)parser.ReadIntList();
if( ltw.Count >= 4 )
{
int i = 0;
m_ruleset.LawRules.LevyTax.Min = ltw[0];
m_ruleset.LawRules.LevyTax.Normal = ltw[1];
m_ruleset.LawRules.LevyTax.Large = ltw[2];
m_ruleset.LawRules.LevyTax.Max = ltw[3];
}
break;
case "character":
m_ruleset.CharRules.Add( ParseCharacter( parser ) );
break;
case "succession_laws":
ParseLaws( parser, m_ruleset.LawRules.SuccessionLaws );
break;
case "gender_laws":
ParseLaws( parser, m_ruleset.LawRules.GenderLaws );
break;
case "misc":
parser.Parse( ParseMiscRules );
break;
case "cul_gen":
parser.Parse( ParseCultureGenRules );
break;
}
}
