public GameVM(AmfFile file, GameVM previousVM)
: base(file)
{
SetCharacterOptions();
setCharacter("PC");
SaveFile = new AmfObjectVM(file);
var flagsObject = FlagsObject;
_flags = new GeneralObjectVM(flagsObject);
if (null != previousVM)
{
_searchText = previousVM._searchText;
}
// Flags
foreach (var xmlFlag in XmlData.Current.Flags)
{
if (!_allFlags.ContainsKey(xmlFlag.Name))
{
_allFlags[xmlFlag.Name] = new FlagVM(this, ref flagsObject, xmlFlag);
}
}
foreach (var flag in flagsObject)
{
string flagName = flag.ToString();
if (!_allFlags.ContainsKey(flagName))
{
XmlEnum data = new XmlEnum();
data.Name = flagName;
_allFlags[flagName] = new FlagVM(this, ref flagsObject, data);
}
}
Flags = new UpdatableCollection <FlagVM>(_allFlags.Values.ToList().Where(x => x.Match(SearchText)));
}
static XmlEnum[] ParseFlags(string fileContent)
{
var flags = new List <XmlEnum>();
Regex regex = new Regex(flagRegExString, RegexOptions.Multiline);
var matches = regex.Matches(fileContent);
foreach (Match match in matches)
{
string flag_name = match.Groups[1].Value;
int flag_value = Int32.Parse(match.Groups[2].Value);
string description = "";
if (match.Groups.Count > 3)
{
description = NormalizeXmlString(match.Groups[3].Value);
}
XmlEnum flag = new XmlEnum
{
Name = flag_name,
ID = flag_value,
};
if (description != "")
{
flag.Description = description;
}
Console.WriteLine("Name: " + flag_name + " value: " + flag_value + " description: " + description);
flags.Add(flag);
}
return(flags.ToArray());
}
public void AddTransformationModel(XmlEnum elementName, string createdon, string createdby, ProcessingStepsModel processingSteps)
{
_elementName = elementName;
_createdOn = createdon;
_createdBy = createdby;
_processingStepsModel = processingSteps;
}
public void AddVariable(XmlEnum elementName, string value, string isPublic, string initialValue)
{
_elementName = elementName;
_value = value;
_isPublic = isPublic;
_initialValue = initialValue;
}
public static string GetSingle(string queryString, string attribute, XmlEnum xml)
{
var node = GetSingle(queryString, xml);
if (node != null)
{
return(node.Attributes[attribute].Value);
}
return(string.Empty);
}
public void AddMap(XmlEnum ElementName, string sequence, string name, string mapFilePath, string sourceFilePath, string targetFilePath,
ICodeModulesModel bas, ITransformationVariablesModel variable)
{
_sequence = sequence;
_name = name;
_mapFilePath = mapFilePath;
_sourceFilePath = sourceFilePath;
_targetFilePath = targetFilePath;
_codemodules = bas;
_tfVariables = variable;
}
public static bool Exist(string queryString, XmlEnum xml)
{
switch (xml)
{
case XmlEnum.City:
return(_cityTool.Exist(queryString));
case XmlEnum.DataTree:
return(_dataTool.Exist(queryString));
case XmlEnum.Field:
return(_fieldTool.Exist(queryString));
}
return(false);
}
public static XmlNode GetSingle(string queryString, XmlEnum xml)
{
switch (xml)
{
case XmlEnum.City:
return(_cityTool.GetSingle(queryString));
case XmlEnum.DataTree:
return(_dataTool.GetSingle(queryString));
case XmlEnum.Field:
return(_fieldTool.GetSingle(queryString));
}
return(null);
}
public static List <string> Get(string queryString, string attributeName, XmlEnum xml)
{
switch (xml)
{
case XmlEnum.City:
return(_cityTool.Get(queryString, attributeName));
case XmlEnum.DataTree:
return(_dataTool.Get(queryString, attributeName));
case XmlEnum.Field:
return(_fieldTool.Get(queryString, attributeName));
}
return(null);
}
public FlagVM(GameVM game, ref AmfObject flags, XmlEnum data)
{
_game = game;
_name = data != null ? data.Name : "";
_description = data != null ? data.Description : "";
_flagsObject = flags;
_flags = new GeneralObjectVM(flags);
bool hasFlag = _flags.HasValue(_name);
if (hasFlag)
{
_flagValue = _flagsObject[_name];
}
GameVMProperties = new HashSet <string>();
}
//public void ReadXml(XmlReader reader)
//{
// if (xc == null)
// xc = new XmlConverter();
// //string s = reader.ReadOuterXml();
// textInfo t = xc.Deserialize(typeof(textInfo), reader.ReadOuterXml()) as textInfo;
// this.left = t.left;
//}
void IXmlSerializable.ReadXml(XmlReader reader)
{
string left, top, width, height, fontsize;
left = reader.GetAttribute("left");
top = reader.GetAttribute("top");
width = reader.GetAttribute("width");
height = reader.GetAttribute("height");
fontsize = reader.GetAttribute("font-size");
if (!string.IsNullOrEmpty(left))
{
this.left = float.Parse(Common.GlobalDecimal(left)); // "0"
}
if (!string.IsNullOrEmpty(top))
{
this.top = float.Parse(Common.GlobalDecimal(top)); // "2.953"
}
if (!string.IsNullOrEmpty(width))
{
this.width = float.Parse(Common.GlobalDecimal(width)); // "18.4756"
}
if (!string.IsNullOrEmpty(height))
{
this.height = float.Parse(Common.GlobalDecimal(height)); // "0.4704"
}
if (!string.IsNullOrEmpty(fontsize))
{
this.fontsize = float.Parse(Common.GlobalDecimal(fontsize)); // "8"
}
this.align = XmlEnum.StringToXmlEnum <alignType>(reader.GetAttribute("align")); // "Left"
this.valign = XmlEnum.StringToXmlEnum <valignType>(reader.GetAttribute("valign")); // "Top"
this.fontname = reader.GetAttribute("font-name"); // "Arial"
this.fontbold = GetBool(reader.GetAttribute("font-bold")); // "true"
this.fontitalic = GetBool(reader.GetAttribute("font-italic")); // "false"
this.fontunderline = GetBool(reader.GetAttribute("font-underline")); // "false"
this.nowrap = GetBool(reader.GetAttribute("no-wrap"));
this.group = reader.GetAttribute("group");
this.forecolor = GetRGBColor(reader.GetAttribute("fore-color"), "000000");
this.backcolor = GetRGBColor(reader.GetAttribute("back-color"), "FFFFFF");
this.border = GetBorders(reader.GetAttribute("border")); // "0 0 0 0.1"
this.bordercolor = GetBorderColor(reader.GetAttribute("border-color")); // "000000 000000 000000 FF0000"
this.Value = reader.ReadElementContentAsString();
}
private static string strValue(object prop)
{
if (prop == null)
{
return("");
}
if (prop.GetType().IsEnum)
{
return(XmlEnum.GetXmlEnumString(prop));
}
else if (prop is DateTime)
{
return(((DateTime)prop).ToString("s"));
}
else
{
return(prop.ToString().Trim());
}
}
public FlagVM(GameVM game, AmfObject flags, XmlEnum data, int index)
{
_flagArray = flags;
_game = game;
_index = index;
_label = data != null ? data.Name : "";
_comment = data != null ? data.Description : "";
if (!String.IsNullOrEmpty(_comment))
{
_label = _label + "\u202F*";
}
var value = flags[_index];
if (value is AmfObject)
{
_valueTrait = ((AmfObject)value).Trait;
}
_valueLabel = flags.GetString(_index);
GameVMProperties = new HashSet <string>();
}
public TransformationVariablesModel(XmlEnum elementName)
{
_elementName = elementName;
}
public GameVM(AmfFile file, GameVM previousVM)
: base(file)
{
SetCharacterOptions();
setCharacter("PC");
var flagsObject = FlagsObject;
_flags = new GeneralObjectVM(flagsObject);
if (null != previousVM)
{
_perkSearchText = previousVM._perkSearchText;
_keyItemSearchText = previousVM._keyItemSearchText;
_rawDataSearchText = previousVM._rawDataSearchText;
}
// Perks
var charPerks = Character.PerksArray;
var xmlPerks = XmlData.Current.PerkGroups.SelectMany(x => x.Perks).ToArray();
var unknownPerkGroup = XmlData.Current.PerkGroups.Last();
ImportMissingNamedVectors(charPerks, xmlPerks, "storageName", x => x.GetString("tooltip"), unknownPerkGroup.Perks);
Character.PerkGroups = new List <PerkGroupVM>();
foreach (var xmlGroup in XmlData.Current.PerkGroups)
{
var perksVM = xmlGroup.Perks.OrderBy(x => x.Name).Select(x => new PerkVM(this, charPerks, x)).ToArray();
_allPerks.AddRange(perksVM);
var groupVM = new PerkGroupVM(this, xmlGroup.Name, perksVM);
Character.PerkGroups.Add(groupVM);
}
//Character.Perks = new UpdatableCollection<PerkVM>(_allPerks.Where(x => x.Match(PerkSearchText)));
// KeyItems
var keyItems = Character.KeyItemsArray;
var xmlKeys = XmlData.Current.KeyItems;
ImportMissingNamedVectors(keyItems, xmlKeys, "storageName", x => x.GetString("tooltip"));
_allKeyItems = XmlData.Current.KeyItems.OrderBy(x => x.Name).Select(x => new KeyItemVM(this, keyItems, x)).ToArray();
Character.KeyItems = new UpdatableCollection <KeyItemVM>(_allKeyItems.Where(x => x.Match(KeyItemSearchText)));
// Statuses
var statuses = Character.StatusEffectsArray;
var xmlStatuses = XmlData.Current.Statuses;
ImportMissingNamedVectors(statuses, xmlStatuses, "storageName", x => x.GetString("tooltip"));
_allStatuses = XmlData.Current.Statuses.OrderBy(x => x.Name).Select(x => new StatusEffectVM(this, statuses, x)).ToArray();
Character.StatusEffects = new UpdatableCollection <StatusEffectVM>(_allStatuses.Where(x => x.Match(RawDataSearchText)));
// Flags
foreach (var xmlFlag in XmlData.Current.Flags)
{
if (!_allFlags.ContainsKey(xmlFlag.Name))
{
_allFlags[xmlFlag.Name] = new FlagVM(this, ref flagsObject, xmlFlag);
}
}
foreach (var flag in flagsObject)
{
string flagName = flag.ToString();
if (!_allFlags.ContainsKey(flagName))
{
XmlEnum data = new XmlEnum();
data.Name = flagName;
_allFlags[flagName] = new FlagVM(this, ref flagsObject, data);
}
}
Flags = new UpdatableCollection <FlagVM>(_allFlags.Values.ToList().Where(x => x.Match(RawDataSearchText)));
}
public ProcessingStepsModel(XmlEnum elementName)
{
_elementName = elementName;
}
public void AddCodeModulePathModel(XmlEnum elementName, string basPath)
{
_elementName = elementName;
_codeModulePath = basPath;
}
public GameVM(AmfFile file, GameVM previousVM)
: base(file)
{
SetCharacterOptions();
CharacterSelection = "PC";
var shittyShips = GetObj("shittyShips") ?? new AmfObject(AmfTypes.Array);
Ships = new ShipArrayVM(this, shittyShips);
var flagsObject = FlagsObject;
_flags = new GeneralObjectVM(flagsObject);
// Flags
var flagNames = AllFlags.Keys.ToList();
foreach (var flagName in flagNames)
{
XmlEnum data = new XmlEnum();
data.Name = flagName;
AllFlags[flagName] = new FlagVM(this, ref flagsObject, data);
}
foreach (var xmlFlag in XmlData.Current.Flags)
{
if (!AllFlags.ContainsKey(xmlFlag.Name))
{
AllFlags[xmlFlag.Name] = new FlagVM(this, ref flagsObject, xmlFlag);
}
}
foreach (var flag in flagsObject)
{
string flagName = flag.ToString();
if (!AllFlags.ContainsKey(flagName))
{
XmlEnum data = new XmlEnum();
data.Name = flagName;
AllFlags[flagName] = new FlagVM(this, ref flagsObject, data);
}
}
if (null != previousVM)
{
foreach (var flag in previousVM.AllFlags)
{
string flagName = flag.Key.ToString();
if (!AllFlags.ContainsKey(flagName))
{
XmlEnum data = new XmlEnum();
data.Name = flagName;
AllFlags[flagName] = new FlagVM(this, ref flagsObject, data);
}
}
}
Flags = new UpdatableCollection <FlagVM>(AllFlags.Values.ToList().Where(x => x.Match(SearchText)));
OnPropertyChanged("Flags");
// Codex
var codexEntries = AllCodexEntries.Keys.ToList();
foreach (var codexName in codexEntries)
{
XmlCodexEntry data = new XmlCodexEntry();
data.Name = codexName;
AllCodexEntries[codexName] = new CodexEntryVM(this, data);
}
foreach (var xmlCodex in XmlData.Current.CodexEntries)
{
if (!AllCodexEntries.ContainsKey(xmlCodex.Name))
{
AllCodexEntries[xmlCodex.Name] = new CodexEntryVM(this, xmlCodex);
}
}
foreach (var codexEntry in CodexUnlockedEntriesObj)
{
string codexName = codexEntry.Value.ToString();
if (!AllCodexEntries.ContainsKey(codexName))
{
XmlCodexEntry data = new XmlCodexEntry(codexName);
AllCodexEntries[codexName] = new CodexEntryVM(this, data);
}
}
foreach (var codexEntry in CodexViewedEntriesObj)
{
string codexName = codexEntry.Value.ToString();
if (!AllCodexEntries.ContainsKey(codexName))
{
XmlCodexEntry data = new XmlCodexEntry(codexName);
AllCodexEntries[codexName] = new CodexEntryVM(this, data);
}
}
if (null != previousVM)
{
foreach (var codexEntry in previousVM.AllCodexEntries)
{
string codexName = codexEntry.Value.ToString();
if (!AllCodexEntries.ContainsKey(codexName))
{
XmlCodexEntry data = new XmlCodexEntry(codexName);
AllCodexEntries[codexName] = new CodexEntryVM(this, data);
}
}
}
CodexEntries = new UpdatableCollection <CodexEntryVM>(AllCodexEntries.Values.ToList().Where(x => x.Match(SearchText)));
OnPropertyChanged("CodexEntries");
}
public MapModel(XmlEnum elementName)
{
_elementName = elementName;
}
public TransformationModel(XmlEnum elementName)
{
_elementName = elementName;
}
public CodeModulesModel(XmlEnum element)
{
_element = element;
}
public CodeModulePathModel(XmlEnum elementName)
{
_elementName = elementName;
}
public FlagItem(AmfObject obj, XmlEnum value)
{
_object = obj;
_value = value;
}
public VariableModel(XmlEnum elementName)
{
_elementName = elementName;
}
