/// <summary>
        /// Writes all variables into a file.
        /// </summary>
        /// <param name="drc">source</param>
        /// <param name="baseFolder">Path in the file.</param>
        /// <param name="fileName">file name to be written</param>
        public void Write(DBRecordCollection drc, string baseFolder, string fileName = null)
        {
            // construct the full path
            string fullPath          = Path.Combine(baseFolder, drc.Id);
            string destinationFolder = Path.GetDirectoryName(fullPath);

            if (fileName != null)
            {
                fullPath          = Path.Combine(baseFolder, fileName);
                destinationFolder = baseFolder;
            }

            // Create the folder path if necessary
            if (!Directory.Exists(destinationFolder))
            {
                Directory.CreateDirectory(destinationFolder);
            }

            // Open the file
            using (StreamWriter outStream = new StreamWriter(fullPath, false))
            {
                // Write all the variables
                foreach (Variable variable in drc)
                {
                    outStream.WriteLine(variable.ToString());
                }
            }
        }
예제 #2
0
        /// <summary>
        /// Gets a DBRecord for the specified item ID string.
        /// </summary>
        /// <remarks>
        /// Changed by VillageIdiot
        /// Changed search order so that IT records have precedence of TQ records.
        /// Add Custom Map database.  Custom Map records have precedence over IT records.
        /// </remarks>
        /// <param name="itemId">Item Id which we are looking up</param>
        /// <returns>Returns the DBRecord for the item Id</returns>
        public DBRecordCollection GetRecordFromFile(string itemId)
        {
            itemId = TQData.NormalizeRecordPath(itemId);

            if (this.ArzFileMod != null)
            {
                DBRecordCollection recordMod = arzProv.GetItem(this.ArzFileMod, itemId);
                if (recordMod != null)
                {
                    // Custom Map records have highest precedence.
                    return(recordMod);
                }
            }

            if (this.ArzFileIT != null)
            {
                // see if it's in IT ARZ file
                DBRecordCollection recordIT = arzProv.GetItem(this.ArzFileIT, itemId);
                if (recordIT != null)
                {
                    // IT file takes precedence over TQ.
                    return(recordIT);
                }
            }

            return(arzProv.GetItem(ArzFile, itemId));
        }
예제 #3
0
파일: ArzFile.cs 프로젝트: Knopy/TQVaultAE
        /// <summary>
        /// Gets the DBRecord for a particular ID.
        /// </summary>
        /// <param name="recordId">string ID of the record will be normalized internally</param>
        /// <returns>DBRecord corresponding to the string ID.</returns>
        public DBRecordCollection GetItem(string recordId)
        {
            DBRecordCollection result = null;

            if (string.IsNullOrEmpty(recordId))
            {
                return(result);
            }

            recordId = TQData.NormalizeRecordPath(recordId);
            DBRecordCollection databaseRecord;

            if (cache.ContainsKey(recordId))
            {
                databaseRecord = this.cache[recordId];
            }
            else
            {
                RecordInfo rawRecord;
                if (recordInfo.ContainsKey(recordId))
                {
                    rawRecord = this.recordInfo[recordId];
                }
                else
                {
                    // record not found
                    return(null);
                }

                databaseRecord = rawRecord.Decompress(this);
                this.cache.Add(recordId, databaseRecord);
            }

            return(databaseRecord);
        }
예제 #4
0
		/// <summary>
		/// Gets the Infor for a specific item id.
		/// </summary>
		/// <param name="itemId">Item ID which we are looking up.  Will be normalized internally.</param>
		/// <returns>Returns Infor for item ID and NULL if not found.</returns>
		public Info GetInfo(string itemId)
		{
			if (string.IsNullOrEmpty(itemId))
				return null;

			itemId = TQData.NormalizeRecordPath(itemId);

			return this.infoDB.GetOrAddAtomic(itemId, k =>
			{
				DBRecordCollection record = null;
				// Add support for searching a custom map database
				if (this.ArzFileMod != null)
					record = arzProv.GetItem(this.ArzFileMod, k);

				// Try the expansion pack database first.
				if (record == null && this.ArzFileIT != null)
					record = arzProv.GetItem(this.ArzFileIT, k);

				// Try looking in TQ database now
				if (record == null || this.ArzFileIT == null)
					record = arzProv.GetItem(this.ArzFile, k);

				if (record == null)
					return null;

				return new Info(record);
			});
		}
예제 #5
0
파일: Database.cs 프로젝트: lvlvy/TQVaultAE
        /// <summary>
        /// Gets the Infor for a specific item id.
        /// </summary>
        /// <param name="itemId">Item ID which we are looking up.  Will be normalized internally.</param>
        /// <returns>Returns Infor for item ID and NULL if not found.</returns>
        public Info GetInfo(string itemId)
        {
            Info result = null;

            if (string.IsNullOrEmpty(itemId))
            {
                return(result);
            }

            itemId = TQData.NormalizeRecordPath(itemId);
            Info info;

            if (infoDB.ContainsKey(itemId))
            {
                info = this.infoDB[itemId];
            }
            else
            {
                DBRecordCollection record = null;

                // Add support for searching a custom map database
                if (this.ArzFileMod != null)
                {
                    record = this.ArzFileMod.GetItem(itemId);
                }

                // Try the expansion pack database first.
                if (record == null && this.ArzFileIT != null)
                {
                    record = this.ArzFileIT.GetItem(itemId);
                }

                // Try looking in TQ database now
                if (record == null || this.ArzFileIT == null)
                {
                    record = this.ArzFile.GetItem(itemId);
                }

                if (record == null)
                {
                    return(null);
                }

                info = new Info(record);
                this.infoDB.Add(itemId, info);
            }

            return(info);
        }
예제 #6
0
        /// <summary>
        /// Handler for clicking on a treeView item
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">TreeViewEventArgs data</param>
        private void TreeView1_AfterSelect(object sender, TreeViewEventArgs e)
        {
            // Make sure we have selected the last child
            // otherwise this will be a directory.
            if (this.treeViewTOC.SelectedNode.GetNodeCount(false) == 0)
            {
                this.destFile = this.treeViewTOC.SelectedNode.FullPath;
                try
                {
                    List <string> recordText = new List <string>();
                    if (fileType == CompressedFileType.ArzFile)
                    {
                        this.dataGridView1.Visible  = true;
                        this.textBoxDetails.Visible = false;
                        this.record = arzProv.GetRecordNotCached(arzFile, this.destFile);
                        foreach (Variable variable in this.record)
                        {
                            if (variable.IsValueNonZero() || !hideZeroValuesToolStripMenuItem.Checked)
                            {
                                recordText.Add(variable.ToString());
                            }
                        }
                    }
                    else if (fileType == CompressedFileType.ArcFile)
                    {
                        string extension   = Path.GetExtension(this.destFile).ToUpper();
                        string arcDataPath = Path.Combine(Path.GetFileNameWithoutExtension(arcFile.FileName), this.destFile);
                        if (extension == ".TXT")
                        {
                            byte[] rawData = arcProv.GetData(arcFile, arcDataPath);

                            if (rawData == null)
                            {
                                return;
                            }

                            // now read it like a text file
                            using (StreamReader reader = new StreamReader(new MemoryStream(rawData), Encoding.Default))
                            {
                                string line;
                                while ((line = reader.ReadLine()) != null)
                                {
                                    recordText.Add(line);
                                }
                            }

                            this.dataGridView1.Visible  = false;
                            this.textBoxDetails.Visible = true;
                        }
                        else if (extension == ".TEX")
                        {
                            byte[] rawData = arcProv.GetData(arcFile, arcDataPath);

                            if (rawData == null)
                            {
                                return;
                            }

                            Bitmap bitmap = BitmapService.LoadFromTexMemory(rawData, 0, rawData.Length);

                            if (bitmap != null)
                            {
                                this.dataGridView1.Visible  = false;
                                this.pictureBoxItem.Visible = true;
                                this.pictureBoxItem.Image   = bitmap;
                            }
                        }
                        else
                        {
                            this.pictureBoxItem.Visible = false;
                        }
                    }
                    else
                    {
                        this.dataGridView1.Visible  = false;
                        this.pictureBoxItem.Visible = false;
                        this.destFile             = null;
                        this.textBoxDetails.Lines = null;
                        return;
                    }

                    // Now display our results.
                    if (recordText.Count != 0)
                    {
                        this.pictureBoxItem.Visible = false;
                        if (fileType == CompressedFileType.ArzFile)
                        {
                            this.textBoxDetails.Visible = false;
                            this.dataGridView1.Visible  = true;
                            PopulateGridView(recordText);
                        }
                        else
                        {
                            this.dataGridView1.Visible  = false;
                            this.textBoxDetails.Visible = true;
                            string[] output = new string[recordText.Count];
                            recordText.CopyTo(output);
                            this.textBoxDetails.Lines = output;
                        }
                    }
                    else
                    {
                        this.textBoxDetails.Lines = null;
                    }
                }
                catch (Exception ex)
                {
                    this.Log.ErrorException(ex);
                }
            }
            else
            {
                this.destFile             = null;
                this.textBoxDetails.Lines = null;
            }
        }
예제 #7
0
파일: ArzFile.cs 프로젝트: lvlvy/TQVaultAE
            /// <summary>
            /// Decompresses an individual record.
            /// </summary>
            /// <param name="arzFile">ARZ file which we are decompressing.</param>
            /// <returns>decompressed DBRecord.</returns>
            public DBRecordCollection Decompress(ArzFile arzFile)
            {
                // record variables have this format:
                // 0x00 int16 specifies data type:
                //      0x0000 = int - data will be an int32
                //      0x0001 = float - data will be a Single
                //      0x0002 = string - data will be an int32 that is index into string table
                //      0x0003 = bool - data will be an int32
                // 0x02 int16 specifies number of values (usually 1, but sometimes more (for arrays)
                // 0x04 int32 key string ID (the id into the string table for this variable name
                // 0x08 data value
                byte[] data = this.DecompressBytes(arzFile);

                int numberOfDWords = data.Length / 4;

                if (data.Length % 4 != 0)
                {
                    var ex = new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error while parsing arz record {0}, data Length = {1} which is not a multiple of 4", this.ID, (int)data.Length));
                    Log.ErrorException(ex);
                    throw ex;
                }

                DBRecordCollection record = new DBRecordCollection(this.ID, this.RecordType);

                // Create a memory stream to read the binary data
                using (BinaryReader inReader = new BinaryReader(new MemoryStream(data, false)))
                {
                    int i = 0;
                    while (i < numberOfDWords)
                    {
                        short  dataType     = inReader.ReadInt16();
                        short  valCount     = inReader.ReadInt16();
                        int    variableID   = inReader.ReadInt32();
                        string variableName = arzFile.Getstring(variableID);

                        if (variableName == null)
                        {
                            var ex = new ArgumentNullException(string.Format(CultureInfo.InvariantCulture, "Error while parsing arz record {0}, variable is NULL", this.ID));
                            Log.ErrorFormat(CultureInfo.InvariantCulture, "Error in ARZFile - {0}", arzFile.fileName);
                            Log.ErrorException(ex);
                            throw ex;
                        }

                        if (dataType < 0 || dataType > 3)
                        {
                            var ex = new ArgumentOutOfRangeException(string.Format(CultureInfo.InvariantCulture, "Error while parsing arz record {0}, variable {1}, bad dataType {2}", this.ID, variableName, dataType));
                            Log.ErrorFormat(CultureInfo.InvariantCulture, "Error in ARZFile - {0}", arzFile.fileName);
                            Log.ErrorException(ex);
                            throw ex;
                        }

                        Variable v = new Variable(variableName, (VariableDataType)dataType, valCount);

                        if (valCount < 1)
                        {
                            var ex = new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error while parsing arz record {0}, variable {1}, bad valCount {2}", this.ID, variableName, valCount));
                            Log.ErrorFormat(CultureInfo.InvariantCulture, "Error in ARZFile - {0}", arzFile.fileName);
                            Log.ErrorException(ex);
                            throw ex;
                        }

                        // increment our dword count
                        i += 2 + valCount;

                        for (int j = 0; j < valCount; ++j)
                        {
                            switch (v.DataType)
                            {
                            case VariableDataType.Integer:
                            case VariableDataType.Boolean:
                            {
                                int val = inReader.ReadInt32();
                                v[j] = val;
                                break;
                            }

                            case VariableDataType.Float:
                            {
                                float val = inReader.ReadSingle();
                                v[j] = val;
                                break;
                            }

                            case VariableDataType.StringVar:
                            {
                                int    id  = inReader.ReadInt32();
                                string val = arzFile.Getstring(id);
                                if (val == null)
                                {
                                    val = string.Empty;
                                }
                                else
                                {
                                    val = val.Trim();
                                }

                                v[j] = val;
                                break;
                            }

                            default:
                            {
                                int val = inReader.ReadInt32();
                                v[j] = val;
                                break;
                            }
                            }
                        }

                        record.Set(v);
                    }
                }

                return(record);
            }
예제 #8
0
        /// <summary>
        /// Builds the table from the database using the passed table Id.
        /// </summary>
        public static LootTableCollection LoadTable(string tableId)
        {
            var ntab = new LootTableCollection(tableId);
            // Get the data
            DBRecordCollection record = Database.DB.GetRecordFromFile(ntab.tableId);

            if (record == null)
            {
                return(ntab);
            }

            // Go through and get all of the randomizerWeight randomizerName pairs that have a weight > 0.
            Dictionary <int, float>  weights = new Dictionary <int, float>();
            Dictionary <int, string> names   = new Dictionary <int, string>();

            foreach (Variable variable in record)
            {
                string upperCase = variable.Name.ToUpperInvariant();
                if (upperCase.StartsWith("RANDOMIZERWEIGHT", StringComparison.Ordinal))
                {
                    string numPart = upperCase.Substring(16);
                    int    num;
                    if (int.TryParse(numPart, out num))
                    {
                        // Make sure the value is an integer or float
                        float value = -1.0F;

                        if (variable.DataType == VariableDataType.Integer)
                        {
                            value = (float)variable.GetInt32(0);
                        }
                        else if (variable.DataType == VariableDataType.Float)
                        {
                            value = variable.GetSingle(0);
                        }

                        if (value > 0)
                        {
                            weights.Add(num, value);
                        }
                    }
                }
                else if (upperCase.StartsWith("RANDOMIZERNAME", StringComparison.Ordinal))
                {
                    string numPart = upperCase.Substring(14);
                    int    num;
                    if (int.TryParse(numPart, out num))
                    {
                        // now get the value
                        string value = variable.GetString(0);
                        if (!string.IsNullOrEmpty(value))
                        {
                            names.Add(num, value);
                        }
                    }
                }
            }

            // Now do an INNER JOIN on the 2 dictionaries to find valid pairs.
            IEnumerable <KeyValuePair <string, float> > buildTableQuery = from weight in weights
                                                                          join name in names on weight.Key equals name.Key
                                                                          select new KeyValuePair <string, float>(name.Value, weight.Value);

            // Iterate the query to build the new unweighted table.
            foreach (KeyValuePair <string, float> kvp in buildTableQuery)
            {
                // Check for a double entry in the table.
                if (ntab.data.ContainsKey(kvp.Key))
                {
                    // for a double entry just add the chance.
                    ntab.data[kvp.Key] += kvp.Value;
                }
                else
                {
                    ntab.data.Add(kvp.Key, kvp.Value);
                }
            }

            // Calculate the total weight.
            ntab.totalWeight = buildTableQuery.Sum(kvp => kvp.Value);

            return(ntab);
        }