public List <CultureGroup> LoadCultures(string folder, string[] except = null)
{
var fileNames = Directory.GetFiles(Path.Combine(folder, "common", "cultures"));
if (except != null)
{
fileNames = fileNames.Where(x => !except.Any(y => x.EndsWith(y + ".json"))).ToArray();
}
var cultureGroups = new List <CultureGroup>();
foreach (var fileName in fileNames)
{
var obj = LoadObject(fileName);
var cultureGroupProps = obj.Properties().Where(x => x.Name != "_filename");
foreach (var cultureGroupProp in cultureGroupProps)
{
var cultureProps = ((JObject)cultureGroupProp.Value).Properties().Where(x => x.Name != "graphical_culture" && x.Name != "second_graphical_culture");
var cultureGroup = new CultureGroup
{
Name = cultureGroupProp.Name,
Cultures = cultureProps.Select(x => new Culture
{
Name = x.Name,
Primary = x.Value.Value <string>("primary"),
}).ToList()
};
cultureGroups.Add(cultureGroup);
}
}
return(cultureGroups);
}
private void MakeCultures(CultureGroup group, int culCount, CultureGroup baseGroup)
{
Log("Generating Cultures");
SendMessage("Generating Cultures");
Province prov;
List <Province> provsOwnedByCulture;
List <Province> provs = new List <Province>((IEnumerable <Province>)group.CustomFlags["provs"]);
Culture baseCul, thisCul;
Title county;
List <Culture> baseCuls = baseGroup.Cultures.Values.ToList();
int nameGenGroup = (int)group.CustomFlags["name_group"];
int genOffset = m_options.Random.Next(256);
for (int i = 0; i < culCount; i++)
{
if (provs.Count == 0)
{
break;
}
baseCul = baseCuls.RandomItem(m_options.Random);
do
{
prov = provs.RandomItem(m_options.Random);
provs.Remove(prov);
} while(!m_options.Data.Localisations.ContainsKey(prov.Title + "_adj"));
county = m_options.Data.Counties[prov.Title];
provsOwnedByCulture = new List <Province>();
provsOwnedByCulture.Add(prov);
Log("Province: " + prov.Title);
string locString = m_options.Data.Localisations[prov.Title + "_adj"];
SendMessage("Generating Culture " + locString.Split(';')[1]);
thisCul = CopyCulture(county, baseCul);
thisCul.CustomFlags["baseCul"] = baseCul;
thisCul.CustomFlags["provs"] = provsOwnedByCulture;
GenerateNewCultureData(thisCul, nameGenGroup, genOffset + i);
if (!prov.CustomFlags.ContainsKey("old_cul"))
{
prov.CustomFlags["old_cul"] = prov.Culture;
}
prov.CustomFlags["owningCulture"] = thisCul;
prov.Culture = thisCul.Name;
thisCul.Group = group;
group.Cultures.Add(thisCul.Name, thisCul);
}
}
/// <summary>
/// Converts a <see cref="CultureGroupEntity"/> data object into a <see cref="CultureGroup"/> domain model.
/// </summary>
/// <returns>The <see cref="CultureGroup"/> domain model.</returns>
/// <param name="dataObject">The <see cref="CultureGroupEntity"/> data object.</param>
internal static CultureGroup ToDomainModel(this CultureGroupEntity dataObject)
{
CultureGroup culture = new CultureGroup
{
Id = dataObject.Id,
GraphicalCultures = dataObject.GraphicalCultures,
Cultures = dataObject.Cultures.ToDomainModels()
};
return(culture);
}
private CultureGroup CopyCultureGroup(Title title, CultureGroup oldGroup)
{
CultureGroup gc = new CultureGroup();
gc.CustomFlags["from_title"] = title;
gc.Name = title.TitleID.Substring(2) + "_grp";
gc.GraphicalCulture = oldGroup.GraphicalCulture;
gc.MiscOptions = oldGroup.MiscOptions;
gc.Cultures = new Dictionary <string, Culture>();
return(gc);
}
private void GenerateCultures()
{
AddLogEntry("Began generating cultures...");
int colorRange = 32;
int n = Random.Next(Settings.CultureGroupsMin, Settings.CultureGroupsMax);
CultureGroups = new List <CultureGroup>(n);
Cultures = new List <Culture>(Settings.CultureGroupsMax);
for (int i = 0; i < n; i++)
{
CultureGroup group = new CultureGroup();
group.BaseColor = Color.FromArgb(
colorRange + Random.Next(256 - colorRange * 2),
colorRange + Random.Next(256 - colorRange * 2),
colorRange + Random.Next(256 - colorRange * 2));
do
{
group.Origin = LandProvinces[Random.Next(LandProvinces.Count)];
}while (group.Origin.CultureGroup != null);
group.Origin.CultureGroup = group;
AddCulture(group); // Guarantee at least one culture per group.
CultureGroups.Add(group);
}
n = Random.Next(Settings.CulturesMin, Settings.CulturesMax);
n -= Cultures.Count;
for (int i = 0; i < n; i++)
{
CultureGroup group = CultureGroups[Random.Next(CultureGroups.Count)];
AddCulture(group);
}
foreach (Province province in LandProvinces)
{
Culture closestCulture = null;
int closestDistance = int.MaxValue;
foreach (Culture culture in Cultures)
{
int testDistance = culture.Origin.DistanceSquared(province.Position);
if (testDistance < closestDistance)
{
closestCulture = culture;
closestDistance = testDistance;
}
}
province.Culture = closestCulture;
}
AddLogEntry("Finished generating cultures.");
}
public bool TryGetCultureGroup(string key, out CultureGroup culGroup)
{
bool found = false;
if (m_useCustomCulture)
{
found = m_customCultureGroups.TryGetValue(key, out culGroup);
}
if (!found)
{
found = CultureGroups.TryGetValue(key, out culGroup);
}
culGroup = null;
return(found);
}
private void WriteCultureGroup(CultureGroup group, StreamWriter cultures, StreamWriter locs)
{
Title tit = (Title)group.CustomFlags["from_title"];
if (m_options.Data.Localisations.ContainsKey(tit.TitleID + "_adj"))
{
string loc = m_options.Data.Localisations[tit.TitleID + "_adj"].Substring(2).Replace("_adj", "_grp");
locs.WriteLine(loc);
}
cultures.WriteLine("{0} = {{", group.Name);
cultures.WriteLine("\tgraphical_culture = {0}", group.GraphicalCulture);
foreach (var cul in group.Cultures)
{
WriteCulture(cul.Value, cultures, locs);
}
cultures.WriteLine("}");
}
private void GenerateCultures(List <CultureGroup> cultureGroups)
{
foreach (CultureGroup group in cultureGroups)
{
int culCount = m_options.Random.Next(m_options.HistoryCulMin, m_options.HistoryCulMax);
CultureGroup baseGroup = (CultureGroup)group.CustomFlags["baseCulGroup"];
MakeCultures(group, culCount, baseGroup);
bool finishedGrowing;
do
{
finishedGrowing = true;
foreach (var pair in group.Cultures)
{
GrowCultures(pair.Value, ref finishedGrowing);
}
} while(!finishedGrowing);
}
}
private void AddCulture(CultureGroup group)
{
int colorRange = 32;
Culture culture = new Culture();
culture.Group = group;
culture.Color = Color.FromArgb(
group.BaseColor.R + Random.Next(-colorRange, colorRange),
group.BaseColor.G + Random.Next(-colorRange, colorRange),
group.BaseColor.B + Random.Next(-colorRange, colorRange));
/*
* do
* culture.Origin = LandProvinces[Random.Next(LandProvinces.Count)];
* while (culture.Origin.Culture != null);
* culture.Origin.Culture = culture;
* Province origin = LandProvinces[0];
*/
int smallestScore = int.MaxValue;
foreach (Province province in LandProvinces)
{
if (province.Culture == null)
{
int score = province.DistanceSquared(culture.Group.Origin);
score += Random.Next(0, 100000);
if (score < smallestScore)
{
culture.Origin = province;
smallestScore = score;
}
}
}
culture.Origin.Culture = culture;
group.Cultures.Add(culture);
Cultures.Add(culture);
}
private void GrowCultureGroup(CultureGroup cg, ref bool finishedGrowing)
{
List <Province> provsOwnedByGroup;
provsOwnedByGroup = (List <Province>)cg.CustomFlags["provs"];
int currCount = provsOwnedByGroup.Count;
for (int i = 0; i < currCount; i++)
{
Province ownProv = provsOwnedByGroup[i];
if (ownProv.CustomFlags.ContainsKey("culGroupSurrounded"))
{
continue;
}
foreach (Province adj in ownProv.Adjacencies)
{
if (m_options.RuleSet.IgnoredTitles.Contains(adj.Title))
{
continue;
}
if (adj.CustomFlags.ContainsKey("owningCultureGroup"))
{
continue;
}
adj.CustomFlags["owningCultureGroup"] = cg;
provsOwnedByGroup.Add(adj);
m_possibleProvinces.Remove(adj);
finishedGrowing = false;
}
ownProv.CustomFlags["culGroupSurrounded"] = true;
}
}
private void WriteCultureGroup( CultureGroup group, StreamWriter cultures, StreamWriter locs )
{
Title tit = (Title)group.CustomFlags["from_title"];
if( m_options.Data.Localisations.ContainsKey( tit.TitleID + "_adj" ) )
{
string loc = m_options.Data.Localisations[tit.TitleID + "_adj"].Substring( 2 ).Replace( "_adj", "_grp" );
locs.WriteLine( loc );
}
cultures.WriteLine( "{0} = {{", group.Name );
cultures.WriteLine( "\tgraphical_culture = {0}", group.GraphicalCulture );
foreach( var cul in group.Cultures )
WriteCulture( cul.Value, cultures, locs );
cultures.WriteLine( "}" );
}
private CultureGroup CopyCultureGroup( Title title, CultureGroup oldGroup )
{
CultureGroup gc = new CultureGroup();
gc.CustomFlags["from_title"] = title;
gc.Name = title.TitleID.Substring( 2 ) + "_grp";
gc.GraphicalCulture = oldGroup.GraphicalCulture;
gc.MiscOptions = oldGroup.MiscOptions;
gc.Cultures = new Dictionary<string, Culture>();
return gc;
}
private void MakeCultures( CultureGroup group, int culCount, CultureGroup baseGroup )
{
Log( "Generating Cultures" );
SendMessage( "Generating Cultures" );
Province prov;
List<Province> provsOwnedByCulture;
List<Province> provs = new List<Province>( (IEnumerable<Province>)group.CustomFlags["provs"] );
Culture baseCul, thisCul;
Title county;
List<Culture> baseCuls = baseGroup.Cultures.Values.ToList();
int nameGenGroup = (int)group.CustomFlags["name_group"];
int genOffset = m_options.Random.Next( 256 );
for( int i = 0; i < culCount; i++ )
{
if( provs.Count == 0 )
break;
baseCul = baseCuls.RandomItem( m_options.Random );
do
{
prov = provs.RandomItem( m_options.Random );
provs.Remove( prov );
} while( !m_options.Data.Localisations.ContainsKey( prov.Title + "_adj" ) );
county = m_options.Data.Counties[prov.Title];
provsOwnedByCulture = new List<Province>();
provsOwnedByCulture.Add( prov );
Log( "Province: " + prov.Title );
string locString = m_options.Data.Localisations[prov.Title + "_adj"];
SendMessage( "Generating Culture " + locString.Split( ';' )[1] );
thisCul = CopyCulture( county, baseCul );
thisCul.CustomFlags["baseCul"] = baseCul;
thisCul.CustomFlags["provs"] = provsOwnedByCulture;
GenerateNewCultureData( thisCul, nameGenGroup, genOffset + i );
if ( !prov.CustomFlags.ContainsKey( "old_cul" ) )
prov.CustomFlags["old_cul"] = prov.Culture;
prov.CustomFlags["owningCulture"] = thisCul;
prov.Culture = thisCul.Name;
thisCul.Group = group;
group.Cultures.Add( thisCul.Name, thisCul );
}
}
private void GrowCultureGroup( CultureGroup cg, ref bool finishedGrowing )
{
List<Province> provsOwnedByGroup;
provsOwnedByGroup = (List<Province>)cg.CustomFlags["provs"];
int currCount = provsOwnedByGroup.Count;
for( int i = 0; i < currCount; i++ )
{
Province ownProv = provsOwnedByGroup[i];
if( ownProv.CustomFlags.ContainsKey( "culGroupSurrounded" ) )
continue;
foreach( Province adj in ownProv.Adjacencies )
{
if( m_options.RuleSet.IgnoredTitles.Contains( adj.Title ) )
continue;
if( adj.CustomFlags.ContainsKey( "owningCultureGroup" ) )
continue;
adj.CustomFlags["owningCultureGroup"] = cg;
provsOwnedByGroup.Add( adj );
m_possibleProvinces.Remove( adj );
finishedGrowing = false;
}
ownProv.CustomFlags["culGroupSurrounded"] = true;
}
}
/// <summary>
/// Applies culture information to the files specified by the Files property.
/// This task intentionally does not validate that strings are valid Cultures so that we can support
/// psuedo-loc.
/// </summary>
/// <returns>True upon completion of the task execution.</returns>
public override bool Execute()
{
// First, process the culture group list the user specified in the cultures property
List<CultureGroup> cultureGroups = new List<CultureGroup>();
if (!String.IsNullOrEmpty(this.Cultures))
{
// Get rid of extra quotes
this.Cultures = this.Cultures.Trim('\"');
foreach (string cultureGroupString in this.Cultures.Split(';'))
{
if (0 == cultureGroupString.Length)
{
// MSBuild v2.0.50727 cannnot handle "" items
// for the invariant culture we require the neutral keyword
continue;
}
CultureGroup cultureGroup = new CultureGroup(cultureGroupString);
cultureGroups.Add(cultureGroup);
}
}
else
{
// Only process the EmbeddedResource items if cultures was unspecified
foreach (ITaskItem file in this.Files)
{
// Ignore non-wxls
if (!String.Equals(file.GetMetadata("Extension"), ".wxl", StringComparison.OrdinalIgnoreCase))
{
Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}. The file type is not supported.", file.ItemSpec);
return false;
}
XmlDocument wxlFile = new XmlDocument();
try
{
wxlFile.Load(file.ItemSpec);
}
catch (FileNotFoundException)
{
Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}. The file was not found.", file.ItemSpec);
return false;
}
catch (Exception e)
{
Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}: {1}", file.ItemSpec, e.Message);
return false;
}
// Take the culture value and try using it to create a culture.
XmlAttribute cultureAttr = wxlFile.DocumentElement.Attributes[WixAssignCulture.CultureAttributeName];
string wxlCulture = null == cultureAttr ? String.Empty : cultureAttr.Value;
if (0 == wxlCulture.Length)
{
// We use a keyword for the invariant culture because MSBuild v2.0.50727 cannnot handle "" items
wxlCulture = InvariantCultureIdentifier;
}
// We found the culture for the WXL, we now need to determine if it maps to a culture group specified
// in the Cultures property or if we need to create a new one.
Log.LogMessage(MessageImportance.Low, "Culture \"{0}\" from EmbeddedResource {1}.", wxlCulture, file.ItemSpec);
bool cultureGroupExists = false;
foreach (CultureGroup cultureGroup in cultureGroups)
{
foreach (string culture in cultureGroup.Cultures)
{
if (String.Equals(wxlCulture, culture, StringComparison.OrdinalIgnoreCase))
{
cultureGroupExists = true;
break;
}
}
}
// The WXL didn't match a culture group we already have so create a new one.
if (!cultureGroupExists)
{
cultureGroups.Add(new CultureGroup(wxlCulture));
}
}
}
// If we didn't create any culture groups the culture was unspecificed and no WXLs were included
// Build an unlocalized target in the output folder
if (cultureGroups.Count == 0)
{
cultureGroups.Add(new CultureGroup());
}
List<TaskItem> cultureGroupItems = new List<TaskItem>();
if (1 == cultureGroups.Count && 0 == this.Files.Length)
{
// Maitain old behavior, if only one culturegroup is specified and no WXL, output to the default folder
TaskItem cultureGroupItem = new TaskItem(cultureGroups[0].ToString());
cultureGroupItem.SetMetadata(OutputFolderMetadataName, CultureGroup.DefaultFolder);
cultureGroupItems.Add(cultureGroupItem);
}
else
{
foreach (CultureGroup cultureGroup in cultureGroups)
{
TaskItem cultureGroupItem = new TaskItem(cultureGroup.ToString());
cultureGroupItem.SetMetadata(OutputFolderMetadataName, cultureGroup.OutputFolder);
cultureGroupItems.Add(cultureGroupItem);
Log.LogMessage("Culture: {0}", cultureGroup.ToString());
}
}
this.CultureGroups = cultureGroupItems.ToArray();
return true;
}
public bool TryGetCultureGroup( string key, out CultureGroup culGroup )
{
bool found = false;
if( m_useCustomCulture )
found = m_customCultureGroups.TryGetValue( key, out culGroup );
if( !found )
found = CultureGroups.TryGetValue( key, out culGroup );
culGroup = null;
return found;
}
/// <summary>
/// Applies culture information to the files specified by the Files property.
/// This task intentionally does not validate that strings are valid Cultures so that we can support
/// psuedo-loc.
/// </summary>
/// <returns>True upon completion of the task execution.</returns>
public override bool Execute()
{
// First, process the culture group list the user specified in the cultures property
List <CultureGroup> cultureGroups = new List <CultureGroup>();
if (!String.IsNullOrEmpty(this.Cultures))
{
// Get rid of extra quotes
this.Cultures = this.Cultures.Trim('\"');
foreach (string cultureGroupString in this.Cultures.Split(';'))
{
if (0 == cultureGroupString.Length)
{
// MSBuild v2.0.50727 cannnot handle "" items
// for the invariant culture we require the neutral keyword
continue;
}
CultureGroup cultureGroup = new CultureGroup(cultureGroupString);
cultureGroups.Add(cultureGroup);
}
}
else
{
// Only process the EmbeddedResource items if cultures was unspecified
foreach (ITaskItem file in this.Files)
{
// Ignore non-wxls
if (!String.Equals(file.GetMetadata("Extension"), ".wxl", StringComparison.OrdinalIgnoreCase))
{
Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}. The file type is not supported.", file.ItemSpec);
return(false);
}
XmlDocument wxlFile = new XmlDocument();
try
{
wxlFile.Load(file.ItemSpec);
}
catch (FileNotFoundException)
{
Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}. The file was not found.", file.ItemSpec);
return(false);
}
catch (Exception e)
{
Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}: {1}", file.ItemSpec, e.Message);
return(false);
}
// Take the culture value and try using it to create a culture.
XmlAttribute cultureAttr = wxlFile.DocumentElement.Attributes[WixAssignCulture.CultureAttributeName];
string wxlCulture = null == cultureAttr ? String.Empty : cultureAttr.Value;
if (0 == wxlCulture.Length)
{
// We use a keyword for the invariant culture because MSBuild v2.0.50727 cannnot handle "" items
wxlCulture = InvariantCultureIdentifier;
}
// We found the culture for the WXL, we now need to determine if it maps to a culture group specified
// in the Cultures property or if we need to create a new one.
Log.LogMessage(MessageImportance.Low, "Culture \"{0}\" from EmbeddedResource {1}.", wxlCulture, file.ItemSpec);
bool cultureGroupExists = false;
foreach (CultureGroup cultureGroup in cultureGroups)
{
foreach (string culture in cultureGroup.Cultures)
{
if (String.Equals(wxlCulture, culture, StringComparison.OrdinalIgnoreCase))
{
cultureGroupExists = true;
break;
}
}
}
// The WXL didn't match a culture group we already have so create a new one.
if (!cultureGroupExists)
{
cultureGroups.Add(new CultureGroup(wxlCulture));
}
}
}
// If we didn't create any culture groups the culture was unspecificed and no WXLs were included
// Build an unlocalized target in the output folder
if (cultureGroups.Count == 0)
{
cultureGroups.Add(new CultureGroup());
}
List <TaskItem> cultureGroupItems = new List <TaskItem>();
if (1 == cultureGroups.Count && 0 == this.Files.Length)
{
// Maintain old behavior, if only one culturegroup is specified and no WXL, output to the default folder
TaskItem cultureGroupItem = new TaskItem(cultureGroups[0].ToString());
cultureGroupItem.SetMetadata(OutputFolderMetadataName, CultureGroup.DefaultFolder);
cultureGroupItems.Add(cultureGroupItem);
}
else
{
foreach (CultureGroup cultureGroup in cultureGroups)
{
TaskItem cultureGroupItem = new TaskItem(cultureGroup.ToString());
cultureGroupItem.SetMetadata(OutputFolderMetadataName, cultureGroup.OutputFolder);
cultureGroupItems.Add(cultureGroupItem);
Log.LogMessage("Culture: {0}", cultureGroup.ToString());
}
}
this.CultureGroups = cultureGroupItems.ToArray();
return(true);
}
static public CW_Event FromParsedItem(Parser.Item root)
{
CW_Event ev = new CW_Event((EventType)Enum.Parse(typeof(EventType), root.name, true));
foreach (Parser.Item item in root.GetChilderen())
{
switch (item.name.ToLower())
{
case "id":
string id = item.GetString();
string[] x = id.Split('.');
if (x.Length == 2)
{
ev.name_space = x[0];
ev.id = int.Parse(x[1]);
}
else
{
ev.name_space = null;
ev.id = int.Parse(id);
}
break;
// Flags
case "title":
ev.title.Add(item);
break;
case "desc":
ev.descriptions.Add(new TriggeredDescription(item));
break;
case "picture":
ev.defaultPicture = GFX_Link.FromTag(item.GetString());
break;
case "border":
ev.border = GFX_Link.FromTag(item.GetString());
break;
case "major": ev.major = item.GetBool(); break;
case "is_friendly": ev.is_friendly = item.GetBool(); break;
case "is_hostile": ev.is_hostile = item.GetBool(); break;
case "is_triggered_only": ev.is_triggered_only = item.GetBool(); break;
case "triggered_from_code": ev.triggered_from_code = item.GetBool(); break;
case "hide_from": ev.hide_from = item.GetBool(); break;
case "hide_new": ev.hide_new = item.GetBool(); break;
case "hide_window": ev.hide_window = item.GetBool(); break;
case "show_root": ev.show_root = item.GetBool(); break;
case "show_from_from": ev.show_from_from = item.GetBool(); break;
case "show_from_from_from": ev.show_from_from_from = item.GetBool(); break;
case "sound": /*Find soound file or something*/ break;
case "notification": ev.notification = item.GetBool(); break;
case "portrait": ev.portrait = item.GetString(); break;
case "offmap": ev.offmap = item.GetEnum <OffMapModes>(); break;
case "window": ev.window = item.GetString(); break;
case "background": ev.background = GFX_Link.FromTag(item.GetString()); break;
case "quest_target": ev.quest_target = item.GetString(); break;
// Pre triggers
case "only_playable": ev.only_playable = item.GetBool(); break;
case "is_part_of_plot": ev.is_part_of_plot = item.GetBool(); break;
case "only_rulers": ev.only_rulers = item.GetBool(); break;
case "religion":
ev.religion = Religion.FromName(item.GetString());
break;
case "religion_group":
ev.religion_group = ReligionGroup.FromName(item.GetString());
break;
case "min_age": ev.min_age = (int)item.GetNumber(); break;
case "max_age": ev.max_age = (int)item.GetNumber(); break;
case "only_independent": ev.only_independent = item.GetBool(); break;
case "only_men": ev.only_men = item.GetBool(); break;
case "only_women": ev.only_women = item.GetBool(); break;
case "only_capable": ev.only_capable = item.GetBool(); break;
case "capable_only": ev.only_capable = item.GetBool(); break;
case "lacks_dlc":
ev.lacks_dlc.Add(item.GetString());
break;
case "has_dlc":
ev.has_dlc.Add(item.GetString());
break;
case "friends": ev.friends = item.GetBool(); break;
case "rivals": ev.rivals = item.GetBool(); break;
case "prisoner": ev.prisoner = item.GetBool(); break;
case "ai": ev.ai = item.GetBool(); break;
case "is_patrician": ev.is_patrician = item.GetBool(); break;
case "is_married": ev.is_married = item.GetBool(); break;
case "is_sick": ev.is_sick = item.GetBool(); break;
case "has_character_flag": ev.has_character_flag = item.GetString(); break;
case "has_global_flag": ev.has_global_flag = item.GetString(); break;
case "has_flag": ev.has_flag = item.GetString(); break;
case "war": ev.war = item.GetBool(); break;
case "culture":
ev.culture = Culture.FromName(item.GetString());
break;
case "culture_group":
ev.culture_group = CultureGroup.FromName(item.GetString());
break;
case "is_in_society": ev.is_in_society = item.GetBool(); break;
// End of pre triggers
case "trigger":
ev.trigger = new Trigger(item);
break;
case "major_trigger":
ev.major_trigger = new Trigger(item);
break;
case "mean_time_to_happen":
ev.mtth = new MeanTimeToHappen(item);
break;
case "weight_multiplier":
ev.weight_multiplier = new WieghtMultiplier(item);
break;
case "immediate":
ev.immediate = new Command(item);
break;
case "fail_trigger_effect":
ev.fail_trigger_effect = new Command(item);
break;
case "option":
ev.options.Add(new Option(item));
break;
case "after":
ev.after = new Command(item);
break;
default:
throw new Parser.Item.BadModException(item, "Did not recognise tag " + item.name);
}
}
return(ev);
}
