Beispiel #1
0
        /// <summary>
        /// Saves the given <paramref name="stringFile"/> to an xml file formated as "strings_<paramref name="language"/>.xml"
        /// in the specified <paramref name="directory"/>.
        /// </summary>
        /// <param name="stringFile">The <see cref="StringFile"/> to save.</param>
        /// <param name="directory">The directory to save the <paramref name="stringFile"/> to.</param>
        /// <param name="language">The language of the <see cref="StringFile"/>.</param>
        /// <returns>Whether the <see cref="StringFile"/> was saved.</returns>
        private static bool SaveStrings(StringFile stringFile, string directory, string language)
        {
            string filename = "strings_" + language + ".xml";
            string path     = Path.Combine(directory, filename);

            /// Make a backup of the current languagefile.
            if (File.Exists(path + ".bak"))
            {
                File.Delete(path + ".bak");
            }
            if (File.Exists(path))
            {
                File.Move(path, path + ".bak");
            }
            /// Serialize the StringFile
            try
            {
                XmlSerializer           s  = new XmlSerializer(typeof(StringFile));
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                ns.Add("", "");
                using (XmlTextWriter writer = new XmlTextWriter(new StreamWriter(path)))
                {
                    writer.Formatting = Formatting.Indented;
                    s.Serialize(writer, stringFile, ns);
                }
                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Beispiel #2
0
        public static void ReadDatabase(StringFile StringFile, string ConnectionString)
        {
            SQLiteConnection Connection = new SQLiteConnection(ConnectionString);

            Connection.Open();

            StringFile.Strings = new List <bscrString>();

            using (SQLiteTransaction Transaction = Connection.BeginTransaction())
                using (SQLiteCommand Command = new SQLiteCommand(Connection)) {
                    Command.CommandText = "SELECT english, PointerRef FROM Text ORDER BY PointerRef";
                    SQLiteDataReader r = Command.ExecuteReader();
                    while (r.Read())
                    {
                        String SQLText;

                        try {
                            SQLText = r.GetString(0).Replace("''", "'");
                        } catch (System.InvalidCastException) {
                            SQLText = "";
                        }

                        int PointerRef = r.GetInt32(1);


                        bscrString b = new bscrString();
                        b.Position = (uint)PointerRef;
                        b.String   = SQLText;
                        StringFile.Strings.Add(b);
                    }

                    Transaction.Rollback();
                }
            return;
        }
Beispiel #3
0
        public void CanInvokeFileAction()
        {
            // Arrange
            Resource project = GetSharedProject();

            var args = new
            {
                Title       = "New issue",
                Description = "Blah ...",
                Severity    = 5,
                Attachment  = new { Title = "Att", Description = "Blah blah" }
            };

            var attachment = new StringFile {
                ContentType = "text/plain", Filename = "test.txt", Data = "1234"
            };
            var files = new { attachment = attachment };

            using (var resp = project.Controls[MasonTestConstants.Rels.IssueAdd].Upload <Resource>(Session, args, files))
            {
                dynamic result = resp.Created();
                Assert.AreEqual("New issue", result.Title);
                Assert.AreEqual(5, result.Severity);
                Assert.IsNotNull(result.Attachments);
                Assert.AreEqual(1, result.Attachments.Count);
            }
        }
Beispiel #4
0
        private void LoadDefaultStrings()
        {
            _strings        = new LocalisationStrings(_stringPath);
            _defaultStrings = LoadStrings(_stringPath, "en");

            // Get Available language list
            _languageList = new List <LanguageInfo>();
            foreach (CultureInfo language in _strings.GetAvailableLanguages())
            {
                if (language.Name != "en")
                {
                    LanguageInfo langInfo = new LanguageInfo(language);
                    _languageList.Add(langInfo);
                }
            }

            DrawLanguageList(null);

            // Build section trees
            treeSections.Nodes.Clear();

            tvSections.Nodes.Clear();
            foreach (StringSection section in _defaultStrings.Sections)
            {
                treeSections.Nodes.Add(section.SectionName);
                tvSections.Nodes.Add(section.SectionName);
            }
        }
        /// <summary>
        /// Tries to load all language files for the <paramref name="culture2Load"/> in the specified
        /// <paramref name="directory"/>.
        /// </summary>
        /// <remarks>
        /// The language for a culture can be split up into more than one file: We search the language for
        /// the parent culture (if present), then the more specific region language.
        /// If a language string is already present in the internal dictionary, it will be overwritten by
        /// the new string.
        /// </remarks>
        /// <param name="directory">Directory to load from.</param>
        /// <param name="culture2Load">Culture for that the language resource file will be searched.</param>
        protected void TryAddLanguageFile(string directory, CultureInfo culture2Load)
        {
            string fileName = string.Format("strings_{0}.xml", culture2Load.Name);
            string filePath = Path.Combine(directory, fileName);

            if (!File.Exists(filePath))
            {
                return;
            }

            try
            {
                XmlSerializer s        = new XmlSerializer(typeof(StringFile));
                Encoding      encoding = Encoding.UTF8;
                using (TextReader r = new StreamReader(filePath, encoding))
                {
                    StringFile resources = (StringFile)s.Deserialize(r);

                    foreach (StringLocalized languageString in resources.Strings)
                    {
                        _languageStrings[languageString.StringName] = PrepareAndroidFormat(languageString.Text);
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRegistration.Get <ILogger>().Warn("Failed to load language resource file '{0}'", ex, filePath);
            }
        }
Beispiel #6
0
 private void btnNewStrings_Click(object sender, EventArgs e)
 {
     _defaultStrings               = new StringFile();
     _defaultStrings._sections     = new List <StringSection>();
     _defaultStrings._languageName = "en";
     tabsModes.Controls[(int)Tabs.Create].Enabled = true;
     tabsModes.SelectedIndex = (int)Tabs.Create;
 }
        public override bool ParseFromData()
        {
            if (!base.ParseFromData())
            {
                return(false);
            }

            SetReadFloatForwardBy(1);
            STFFile    = new StringFile().Deserialize(this);
            CustomName = ReadString(Encoding.UTF8);
            Volume     = ReadInt32();
            GuildIds   = ReadList(() => ReadString(Encoding.ASCII));
            return(true);
        }
Beispiel #8
0
 public static void Load()
 {
     if (ResourceManager.FileExists("unityallods.cfg"))
     {
         StringFile sf = new StringFile("unityallods.cfg");
         foreach (string cmd in sf.Strings)
         {
             GameConsole.Instance.ExecuteCommand(cmd);
         }
     }
     else
     {
         Save();
     }
 }
Beispiel #9
0
 private void btnNew_Click(object sender, EventArgs e)
 {
     if (CheckSave())
     {
         NewLanguageDialog newlanguage = new NewLanguageDialog(_languageList);
         if (newlanguage.ShowDialog() == DialogResult.OK)
         {
             _languageList.Add(newlanguage.Selected);
             DrawLanguageList(newlanguage.Selected.Name);
             _targetStrings = new StringFile();
             _targetStrings._languageName = newlanguage.Selected.Name;
             _targetStrings._sections     = new List <StringSection>();
             cbLanguages_SelectedIndexChanged(this, new EventArgs());
         }
     }
 }
Beispiel #10
0
    private static bool CheckServerConfig()
    {
        if (ResourceManager.FileExists("server.cfg"))
        {
            StringFile sf = new StringFile("server.cfg");
            // execute all commands from there
            foreach (string cmd in sf.Strings)
            {
                Debug.Log(cmd);
                GameConsole.Instance.ExecuteCommand(cmd);
            }
            return(true);
        }

        return(false);
    }
Beispiel #11
0
        public override Request Bind(ISession session, object args, object files)
        {
            var payload = new Dictionary <string, object>();

            string jsonArgs = SerializeArgsToJson(args);

            payload[JsonFile] = new StringFile {
                ContentType = "application/json", Data = jsonArgs, Filename = "args"
            };

            JsonFilesPropertiesVisitor v          = new JsonFilesPropertiesVisitor(payload);
            ObjectSerializer           serializer = new ObjectSerializer(files.GetType()); // FIXME: null check

            serializer.Serialize(files, v);

            return(session.Bind(HRef).Method(Method).AsMultipartFormData().Body(payload));
        }
Beispiel #12
0
        public static int Export(List <string> args)
        {
            if (args.Count < 2)
            {
                Console.WriteLine("Usage: db outfile");
                return(-1);
            }

            string     InDatabase = args[0];
            string     OutFile    = args[1];
            StringFile StringFile = new StringFile();

            ReadDatabase(StringFile, "Data Source=" + InDatabase);
            StringFile.CreateFile(OutFile);

            return(0);
        }
        public override bool ParseFromData()
        {
            if (!base.ParseFromData())
            {
                return(false);
            }


            Complexity        = ReadFloat();
            STFFile           = new StringFile().Deserialize(this);
            CustomName        = ReadString(Encoding.UTF8);
            Volume            = ReadInt32();
            SchematicQuantity = ReadInt32();
            CraftingValues    = ReadList <CraftingValue>(true, true);
            CreatorName       = ReadString(Encoding.UTF8);
            Complexity2       = ReadInt32();
            SchematicDataSize = ReadFloat();
            return(true);
        }
Beispiel #14
0
        private void cbLanguages_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cbLanguages.SelectedIndex != 0 && cbLanguages.SelectedIndex != _currentLanguage)
            {
                if (CheckSave())
                {
                    LanguageInfo info = _languageList[cbLanguages.SelectedIndex - 1];
                    _targetStrings = LoadStrings(_stringPath, info.Name);

                    BuildMissingList();
                    ColourMissingSections();
                    SetTargetSection();
                    BuildEditList();
                    DrawTargetList();
                    btnSave.Enabled  = false;
                    _modifiedSection = false;
                    _currentLanguage = cbLanguages.SelectedIndex;
                }
            }
            cbLanguages.SelectedIndex = _currentLanguage;
        }
Beispiel #15
0
        static void LoadStrings(IGameInstance sriv)
        {
            var results = sriv.SearchForFiles("*.le_strings");

            foreach (var result in results)
            {
                string filename = result.Value.Filename.ToLowerInvariant();
                filename = Path.GetFileNameWithoutExtension(filename);

                string[] pieces       = filename.Split('_');
                string   languageCode = pieces.Last();

                Language language = LanguageUtility.GetLanguageFromCode(languageCode);

                if (!languageStrings.ContainsKey(language))
                {
                    languageStrings.Add(language, new Dictionary <uint, string>());
                }

                Dictionary <uint, string> strings = languageStrings[language];

                using (Stream s = sriv.OpenPackfileFile(result.Value.Filename, result.Value.Packfile))
                {
                    StringFile file = new StringFile(s, language, sriv);

                    foreach (var hash in file.GetHashes())
                    {
                        if (strings.ContainsKey(hash))
                        {
                            continue;
                        }

                        strings.Add(hash, file.GetString(hash));
                    }
                }
            }
        }
        public static void Main(string[] args)
        {
            Options options = null;

            try
            {
                options = CommandLine.Parse<Options>();
            }
            catch (CommandLineException exception)
            {
                Console.WriteLine(exception.ArgumentHelp.Message);
                Console.WriteLine();
                Console.WriteLine(exception.ArgumentHelp.GetHelpText(Console.BufferWidth));

#if DEBUG
                Console.ReadLine();
#endif
                return;
            }

            string outputFile = options.Output != null ? options.Output : Path.ChangeExtension(options.Input, ".le_strings");

            Console.WriteLine("Packing {0} and creating {1}...", options.Input, outputFile);

            XDocument xml = null;

            using (Stream s = File.OpenRead(options.Input))
            {
                xml = XDocument.Load(s);
            }

            var stringsNode = xml.Descendants("Strings").First();
            string languageString = stringsNode.Attribute("Language").Value;
            string gameString = stringsNode.Attribute("Game").Value;

            Language language = LanguageUtility.GetLanguageFromCode(languageString);
            IGameInstance instance = GameInstance.GetFromString(gameString);

            var stringNodes = stringsNode.Descendants("String");

            UInt16 bucketCount = (UInt16)(stringNodes.Count() / 5);
            if (bucketCount < 32)
                bucketCount = 32;
            else if (bucketCount < 64)
                bucketCount = 64;
            else if (bucketCount < 128)
                bucketCount = 128;
            else if (bucketCount < 256)
                bucketCount = 256;
            else if (bucketCount < 512)
                bucketCount = 512;
            else 
                bucketCount = 1024;

            StringFile stringFile = new StringFile(bucketCount, language, instance);

            foreach (var stringNode in stringNodes)
            {
                uint hash;

                var nameAttribute = stringNode.Attribute("Name");
                if (nameAttribute != null)
                {
                    hash = Hashes.CrcVolition(nameAttribute.Value);
                }
                else
                {
                    hash = uint.Parse(stringNode.Attribute("Hash").Value, System.Globalization.NumberStyles.HexNumber);
                }


                string value = stringNode.Value;

                if (stringFile.ContainsKey(hash))
                {
                    Console.WriteLine("You are attempting to add a duplicate key to the strings file.");
                    Console.WriteLine("Name: \"{0}\", Hash: {1}, Value: {2}", nameAttribute != null ? nameAttribute.Value : "", hash, value);
                    Console.WriteLine("Other value: {0}", stringFile.GetString(hash));
                    return;
                }
                
                stringFile.AddString(hash, value);
            }

            using (Stream s = File.Create(outputFile))
            {
                stringFile.Save(s);
            }

            Console.WriteLine("Done.");
#if DEBUG
            Console.ReadLine();
#endif
        }
Beispiel #17
0
        static void Main(string[] args)
        {
            Options options = null;

            try
            {
                options = CommandLine.Parse <Options>();
            }
            catch (CommandLineException exception)
            {
                Console.WriteLine(exception.ArgumentHelp.Message);
                Console.WriteLine();
                Console.WriteLine(exception.ArgumentHelp.GetHelpText(Console.BufferWidth));

#if DEBUG
                Console.ReadLine();
#endif
                return;
            }

            if (options.Output == null)
            {
                options.Output = options.NewName;
            }

            string outputFolder = options.Output;

            Directory.CreateDirectory(outputFolder);

            IGameInstance sriv = GameInstance.GetFromSteamId(GameSteamID.SaintsRowIV);
            LoadStrings(sriv);

            IAssetAssemblerFile newAsm;
            using (Stream newAsmStream = File.OpenRead(Path.Combine("templates", "template_customize_item.asm_pc")))
            {
                newAsm = AssetAssemblerFile.FromStream(newAsmStream);
            }

            XDocument customizationItem = null;
            using (Stream itemsTemplateStream = File.OpenRead(Path.Combine("templates", "template_customization_items.xtbl")))
            {
                customizationItem = XDocument.Load(itemsTemplateStream);
            }
            var customizationItemTable = customizationItem.Descendants("Table").First();

            XElement itemNode = FindCustomizationItem(options.Source, sriv);

            if (itemNode == null)
            {
                Console.WriteLine("Couldn't find {0}.", options.Source);

#if DEBUG
                Console.ReadLine();
#endif

                return;
            }

            string itemName = itemNode.Element("Name").Value;
            itemNode.Element("Name").Value = options.NewName;

            string originalDisplayName = itemNode.Element("DisplayName").Value;
            uint   originalStringCrc   = Hashes.CrcVolition(originalDisplayName);
            string newDisplayName      = "DUPLICATED_" + options.NewName.ToUpperInvariant();
            itemNode.Element("DisplayName").Value = newDisplayName;

            List <string> str2Names = new List <string>();

            bool found = false;

            var dlcElement = itemNode.Element("Is_DLC");

            if (dlcElement != null)
            {
                string isDLCString = dlcElement.Value;

                // Remove Is_DLC element so DLC items show up in SRIV
                dlcElement.Remove();
            }

            var wearOptionsNode = itemNode.Element("Wear_Options");
            int wearOption      = 0;
            foreach (var wearOptionNode in wearOptionsNode.Descendants("Wear_Option"))
            {
                var    meshInformationNode  = wearOptionNode.Element("Mesh_Information");
                var    maleMeshFilenameNode = meshInformationNode.Element("Male_Mesh_Filename");
                var    filenameNode         = maleMeshFilenameNode.Element("Filename");
                string maleMeshFilename     = filenameNode.Value;


                string newMaleMeshFilename = (wearOption == 0) ? String.Format("cm_{0}.cmeshx", options.NewName) : String.Format("cm_{0}_{1}.cmeshx", options.NewName, wearOption);
                filenameNode.Value = newMaleMeshFilename;

                var femaleMeshFilenameNode = meshInformationNode.Element("Female_Mesh_Filename");
                filenameNode = femaleMeshFilenameNode.Element("Filename");
                string femaleMeshFilename = filenameNode.Value;

                string newFemaleMeshFilename = (wearOption == 0) ? String.Format("cf_{0}.cmeshx", options.NewName) : String.Format("cf_{0}_{1}.cmeshx", options.NewName, wearOption);
                filenameNode.Value = newFemaleMeshFilename;

                Console.WriteLine("Mapping mesh {0} -> {1}", maleMeshFilename, newMaleMeshFilename);
                Console.WriteLine("Mapping mesh {0} -> {1}", femaleMeshFilename, newFemaleMeshFilename);

                string clothSimFilename     = null;
                var    clothSimFilenameNode = meshInformationNode.Element("Cloth_Sim_Filename");
                if (clothSimFilenameNode != null)
                {
                    filenameNode = clothSimFilenameNode.Element("Filename");
                    string xmlClothSimFilename = filenameNode.Value;
                    clothSimFilename = Path.ChangeExtension(xmlClothSimFilename, ".sim_pc");
                    string newClothSimFilename = (wearOption == 0) ? String.Format("cm_{0}.simx", options.NewName) : String.Format("cm_{0}_{1}.simx", options.NewName, wearOption);
                    filenameNode.Value = newClothSimFilename;
                    Console.WriteLine("Mapping cloth sim {0} -> {1}", xmlClothSimFilename, newClothSimFilename);
                }

                var variantNodes = itemNode.Element("Variants").Descendants("Variant");
                foreach (var variantNode in variantNodes)
                {
                    var  meshVariantInfoNode = variantNode.Element("Mesh_Variant_Info");
                    var  variantIdNode       = meshVariantInfoNode.Element("VariantID");
                    uint variantId           = uint.Parse(variantIdNode.Value);
                    int  crc = Hashes.CustomizationItemCrc(itemName, maleMeshFilename, variantId);

                    string maleStr2   = String.Format("custmesh_{0}.str2_pc", crc);
                    string femaleStr2 = String.Format("custmesh_{0}f.str2_pc", crc);

                    int newCrc = Hashes.CustomizationItemCrc(options.NewName, newMaleMeshFilename, variantId);

                    string newMaleStr2   = String.Format("custmesh_{0}.str2_pc", newCrc);
                    string newFemaleStr2 = String.Format("custmesh_{0}f.str2_pc", newCrc);

                    string newMaleName   = (wearOption == 0) ? String.Format("cm_{0}", options.NewName) : String.Format("cm_{0}_{1}", options.NewName, wearOption);
                    string newFemaleName = (wearOption == 0) ? String.Format("cf_{0}", options.NewName) : String.Format("cf_{0}_{1}", options.NewName, wearOption);

                    bool foundMale   = ClonePackfile(sriv, maleStr2, clothSimFilename, options.Output, newAsm, itemName, newMaleName, Path.Combine(outputFolder, newMaleStr2));
                    bool foundFemale = ClonePackfile(sriv, femaleStr2, clothSimFilename, options.Output, newAsm, itemName, newFemaleName, Path.Combine(outputFolder, newFemaleStr2));

                    if (foundMale || foundFemale)
                    {
                        found = true;
                    }
                }

                wearOption++;
            }

            if (found)
            {
                customizationItemTable.Add(itemNode);
            }

            using (Stream xtblOutStream = File.Create(Path.Combine(outputFolder, "customization_items.xtbl")))
            {
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.OmitXmlDeclaration = true;
                settings.Encoding           = new UTF8Encoding(false);
                settings.NewLineChars       = "\r\n";
                settings.Indent             = true;
                settings.IndentChars        = "\t";
                using (XmlWriter writer = XmlWriter.Create(xtblOutStream, settings))
                {
                    customizationItem.Save(writer);
                }
            }

            using (Stream asmOutStream = File.Create(Path.Combine(outputFolder, "customize_item.asm_pc")))
            {
                newAsm.Save(asmOutStream);
            }

            string stringXmlFolder = Path.Combine(outputFolder, "stringxml");
            Directory.CreateDirectory(stringXmlFolder);

            foreach (var pair in languageStrings)
            {
                Language language = pair.Key;
                Dictionary <uint, string> strings = pair.Value;

                StringFile file = new StringFile(language, sriv);

                string newString = "CLONE: " + options.NewName;
                if (strings.ContainsKey(originalStringCrc))
                {
                    string originalString = strings[originalStringCrc];
                    newString = "CLONE: " + originalString;
                }
                else
                {
                    Console.WriteLine("Warning: original language string could not be found for {0}.", language);
                }


                file.AddString(newDisplayName, newString);

                string newFilename    = Path.Combine(outputFolder, String.Format("{0}_{1}.le_strings", options.NewName, LanguageUtility.GetLanguageCode(language)));
                string newXmlFilename = Path.Combine(stringXmlFolder, String.Format("{0}_{1}.xml", options.NewName, LanguageUtility.GetLanguageCode(language)));

                using (Stream s = File.Create(newFilename))
                {
                    file.Save(s);
                }

                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent       = true;
                settings.IndentChars  = "\t";
                settings.NewLineChars = "\r\n";

                using (XmlWriter xml = XmlTextWriter.Create(newXmlFilename, settings))
                {
                    xml.WriteStartDocument();
                    xml.WriteStartElement("Strings");
                    xml.WriteAttributeString("Language", language.ToString());
                    xml.WriteAttributeString("Game", sriv.Game.ToString());

                    xml.WriteStartElement("String");

                    xml.WriteAttributeString("Name", newDisplayName);
                    xml.WriteString(newString);

                    xml.WriteEndElement(); // String

                    xml.WriteEndElement(); // Strings
                    xml.WriteEndDocument();
                }
            }

            Console.WriteLine("Finished cloning customization item {0} to {1}!", options.Source, options.NewName);
#if DEBUG
            Console.ReadLine();
#endif
        }
Beispiel #18
0
 public StringExporter(StringFile stringFile)
 {
     StringFile = stringFile;
 }
Beispiel #19
0
 public StringExporter(byte[] data)
 {
     using (var memoryStream = new MemoryStream(data))
         StringFile = new StringFileReader().Load(data);
 }
        public static void Main(string[] args)
        {
            Options options = null;

            try
            {
                options = CommandLine.Parse<Options>();
            }
            catch (CommandLineException exception)
            {
                Console.WriteLine(exception.ArgumentHelp.Message);
                Console.WriteLine();
                Console.WriteLine(exception.ArgumentHelp.GetHelpText(Console.BufferWidth));

#if DEBUG
                Console.ReadLine();
#endif
                return;
            }

            IGameInstance instance = GameInstance.GetFromString(options.Game);

            string filename = Path.GetFileNameWithoutExtension(options.Input);
            string languageCode = filename.Remove(0, filename.Length - 2);
            Language language = LanguageUtility.GetLanguageFromCode(languageCode);

            Console.WriteLine("Loading XTBL files...");
            Dictionary<UInt32, string> hashLookup = new Dictionary<UInt32, string>();
            var results = instance.SearchForFiles("*.xtbl");
            foreach (var pair in results)
            {
                string xtbl = null;
                using (StreamReader reader = new StreamReader(pair.Value.GetStream()))
                {
                    xtbl = reader.ReadToEnd();
                }
                Regex regex = new Regex("<Name>(.*?)</Name>", RegexOptions.Compiled);
                foreach (Match m in regex.Matches(xtbl))
                {
                    uint hash = Hashes.CrcVolition(m.Groups[1].Value);
                    if (!hashLookup.ContainsKey(hash))
                        hashLookup.Add(hash, m.Groups[1].Value);
                }
            }

            string outputFile = (options.Output != null) ? options.Output : Path.ChangeExtension(options.Input, ".xml");

            Console.WriteLine("Extracting {0} to {1}...", options.Input, outputFile);

            StringFile stringFile = null;

            using (Stream stream = File.OpenRead(options.Input))
            {
                 stringFile = new StringFile(stream, language, instance);
            }

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.IndentChars = "\t";
            settings.NewLineChars = "\r\n";

            Dictionary<string, string> stringsWithName = new Dictionary<string, string>();
            Dictionary<uint, string> stringsWithHash = new Dictionary<uint, string>();

            foreach (uint hash in stringFile.GetHashes())
            {
                string text = stringFile.GetString(hash);

                if (hashLookup.ContainsKey(hash))
                    stringsWithName.Add(hashLookup[hash], text);
                else
                    stringsWithHash.Add(hash, text);
            }

            

            using (XmlWriter xml = XmlTextWriter.Create(outputFile, settings))
            {
                xml.WriteStartDocument();
                xml.WriteStartElement("Strings");
                xml.WriteAttributeString("Language", language.ToString());
                xml.WriteAttributeString("Game", instance.Game.ToString());
                
                foreach (var pair in stringsWithName.OrderBy(x => x.Key))
                {
                    xml.WriteStartElement("String");

                    xml.WriteAttributeString("Name", pair.Key);
                    xml.WriteString(pair.Value);

                    xml.WriteEndElement(); // String
                }

                foreach (var pair in stringsWithHash)
                {
                    xml.WriteStartElement("String");

                    xml.WriteAttributeString("Hash", pair.Key.ToString("X8"));
                    xml.WriteString(pair.Value);

                    xml.WriteEndElement(); // String
                    
                }

                xml.WriteEndElement(); // Strings
                xml.WriteEndDocument();
            }

            Console.WriteLine("Done.");
#if DEBUG
            Console.ReadLine();
#endif
        }
Beispiel #21
0
        public static void Main(string[] args)
        {
            Options options = null;

            try
            {
                options = CommandLine.Parse <Options>();
            }
            catch (CommandLineException exception)
            {
                Console.WriteLine(exception.ArgumentHelp.Message);
                Console.WriteLine();
                Console.WriteLine(exception.ArgumentHelp.GetHelpText(Console.BufferWidth));

#if DEBUG
                Console.ReadLine();
#endif
                return;
            }

            IGameInstance instance = GameInstance.GetFromString(options.Game);

            string   filename     = Path.GetFileNameWithoutExtension(options.Input);
            string   languageCode = filename.Remove(0, filename.Length - 2);
            Language language     = LanguageUtility.GetLanguageFromCode(languageCode);

            Dictionary <UInt32, string> hashLookup = new Dictionary <UInt32, string>();

            if (options.LoadXtbls)
            {
                Console.WriteLine("Loading XTBL files...");
                Dictionary <string, FileSearchResult> results = instance.SearchForFiles("*.xtbl");
                int i = 0;
                foreach (var pair in results)
                {
                    i++;
                    Console.WriteLine("[{0}/{1}] Loading xtbl: {2}", i, results.Count, pair.Key);

                    string xtbl = null;
                    using (StreamReader reader = new StreamReader(pair.Value.GetStream()))
                    {
                        xtbl = reader.ReadToEnd();
                    }
                    Regex regex = new Regex("<Name>(.*?)</Name>", RegexOptions.Compiled);
                    foreach (Match m in regex.Matches(xtbl))
                    {
                        uint hash = Hashes.CrcVolition(m.Groups[1].Value);
                        if (!hashLookup.ContainsKey(hash))
                        {
                            hashLookup.Add(hash, m.Groups[1].Value);
                        }
                    }
                }
            }

            string outputFile = (options.Output != null) ? options.Output : Path.ChangeExtension(options.Input, ".xml");

            Console.WriteLine("Extracting {0} to {1}...", options.Input, outputFile);

            StringFile stringFile = null;

            using (Stream stream = File.OpenRead(options.Input))
            {
                stringFile = new StringFile(stream, language, instance);
            }

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent       = true;
            settings.IndentChars  = "\t";
            settings.NewLineChars = "\r\n";

            Dictionary <string, string> stringsWithName = new Dictionary <string, string>();
            Dictionary <uint, string>   stringsWithHash = new Dictionary <uint, string>();

            foreach (uint hash in stringFile.GetHashes())
            {
                string text = stringFile.GetString(hash);

                if (hashLookup.ContainsKey(hash))
                {
                    stringsWithName.Add(hashLookup[hash], text);
                }
                else
                {
                    stringsWithHash.Add(hash, text);
                }
            }



            using (XmlWriter xml = XmlTextWriter.Create(outputFile, settings))
            {
                xml.WriteStartDocument();
                xml.WriteStartElement("Strings");
                xml.WriteAttributeString("Language", language.ToString());
                xml.WriteAttributeString("Game", instance.Game.ToString());

                foreach (var pair in stringsWithName.OrderBy(x => x.Key))
                {
                    xml.WriteStartElement("String");

                    xml.WriteAttributeString("Name", pair.Key);
                    xml.WriteString(pair.Value);

                    xml.WriteEndElement(); // String
                }

                foreach (var pair in stringsWithHash)
                {
                    xml.WriteStartElement("String");

                    xml.WriteAttributeString("Hash", pair.Key.ToString("X8"));
                    xml.WriteString(pair.Value);

                    xml.WriteEndElement(); // String
                }

                xml.WriteEndElement(); // Strings
                xml.WriteEndDocument();
            }

            Console.WriteLine("Done.");
#if DEBUG
            Console.ReadLine();
#endif
        }
Beispiel #22
0
        public static void Main(string[] args)
        {
            Options options = null;

            try
            {
                options = CommandLine.Parse <Options>();
            }
            catch (CommandLineException exception)
            {
                Console.WriteLine(exception.ArgumentHelp.Message);
                Console.WriteLine();
                Console.WriteLine(exception.ArgumentHelp.GetHelpText(Console.BufferWidth));

#if DEBUG
                Console.ReadLine();
#endif
                return;
            }

            string outputFile = options.Output != null ? options.Output : Path.ChangeExtension(options.Input, ".le_strings");

            Console.WriteLine("Packing {0} and creating {1}...", options.Input, outputFile);

            XDocument xml = null;

            using (Stream s = File.OpenRead(options.Input))
            {
                xml = XDocument.Load(s);
            }

            var    stringsNode    = xml.Descendants("Strings").First();
            string languageString = stringsNode.Attribute("Language").Value;
            string gameString     = stringsNode.Attribute("Game").Value;

            Language      language = LanguageUtility.GetLanguageFromCode(languageString);
            IGameInstance instance = GameInstance.GetFromString(gameString);

            StringFile stringFile = new StringFile(language, instance);

            var stringNodes = stringsNode.Descendants("String");

            foreach (var stringNode in stringNodes)
            {
                uint hash;

                var nameAttribute = stringNode.Attribute("Name");
                if (nameAttribute != null)
                {
                    hash = Hashes.CrcVolition(nameAttribute.Value);
                }
                else
                {
                    hash = uint.Parse(stringNode.Attribute("Hash").Value, System.Globalization.NumberStyles.HexNumber);
                }


                string value = stringNode.Value;

                if (stringFile.ContainsKey(hash))
                {
                    Console.WriteLine("You are attempting to add a duplicate key to the strings file.");
                    Console.WriteLine("Name: \"{0}\", Hash: {1}, Value: {2}", nameAttribute != null ? nameAttribute.Value : "", hash, value);
                    Console.WriteLine("Other value: {0}", stringFile.GetString(hash));
                    return;
                }

                stringFile.AddString(hash, value);
            }

            using (Stream s = File.Create(outputFile))
            {
                stringFile.Save(s);
            }

            Console.WriteLine("Done.");
#if DEBUG
            Console.ReadLine();
#endif
        }