Beispiel #1
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            QbItemBase qib;
            QbItemType floatsType;
            uint floatsValue;
            bool is3d;
            for (int i = 0; i < base.ItemCount; i++)
            {
                if (base.StreamPos(br) != base.Pointers[i]) //pointer test
                    throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), base.Pointers[i]));

                floatsValue = br.ReadUInt32(this.Root.PakFormat.EndianType);
                floatsType = this.Root.PakFormat.GetQbItemType(floatsValue);

                is3d = (type == QbItemType.SectionFloatsX3 || type == QbItemType.StructItemFloatsX3 || type == QbItemType.ArrayFloatsX3);

                switch (floatsType)
                {
                    case QbItemType.Floats:
                        qib = new QbItemFloats(this.Root, is3d);
                        break;
                    default:
                        throw new ApplicationException(string.Format("Location 0x{0}: Not a float type 0x{1}", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0'), floatsValue.ToString("X").PadLeft(8, '0')));
                }
                qib.Construct(br, floatsType);
                AddItem(qib);

                base.ConstructEnd(br);
            }
        }
Beispiel #2
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            _unknown = br.ReadUInt32(base.Root.PakFormat.EndianType);
            uint decompressedSize = br.ReadUInt32(base.Root.PakFormat.EndianType);
            uint compressedSize   = br.ReadUInt32(base.Root.PakFormat.EndianType);

            // Get script data
            Lzss lz = new Lzss();

            _scriptData = br.ReadBytes((int)compressedSize);
            if (compressedSize < decompressedSize)
            {
                _scriptData = lz.Decompress(_scriptData);
            }

            if (_scriptData.Length != decompressedSize)
            {
                throw new ApplicationException(string.Format("Location 0x{0}: Script decompressed to {1} bytes not {2}", (base.StreamPos(br) - compressedSize).ToString("X").PadLeft(8, '0'), _scriptData.Length.ToString(), decompressedSize.ToString()));
            }

            // Padding...
            if ((base.StreamPos(br) % 4) != 0)
            {
                br.BaseStream.Seek(4 - (base.StreamPos(br) % 4), SeekOrigin.Current);
            }

            base.ConstructEnd(br);
        }
Beispiel #3
0
 public static bool SupportsChild(QbItemType parent, QbItemType child)
 {
     return(_supportedChildItems[parent].Exists(delegate(QbItemType t)
     {
         return (t == child);
     }));
 }
Beispiel #4
0
 public QbItemBase FindItem(QbItemType type, bool recursive)
 {
     return(SearchItems(this, _items, recursive, delegate(QbItemBase item)
     {
         return (item.QbItemType == type);
     }));
 }
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            QbItemBase qib;
            QbItemType headerType;
            uint       headerValue;

            for (int i = 0; i < base.ItemCount; i++)
            {
                if (base.StreamPos(br) != base.Pointers[i]) //pointer test
                {
                    throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), base.Pointers[i]));
                }

                headerValue = br.ReadUInt32(this.Root.PakFormat.EndianType);
                headerType  = this.Root.PakFormat.GetQbItemType(headerValue);

                switch (headerType)
                {
                case QbItemType.StructHeader:
                    qib = new QbItemStruct(this.Root);
                    break;

                default:
                    throw new ApplicationException(string.Format("Location 0x{0}: Not a struct header type 0x{1}", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0'), headerValue.ToString("X").PadLeft(8, '0')));
                }
                qib.Construct(br, headerType);
                AddItem(qib);
            }

            base.ConstructEnd(br);
        }
Beispiel #6
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            _values = new QbKey[base.ItemCount];

            uint   crc;
            string debug;

            for (int i = 0; i < base.ItemCount; i++)
            {
                crc   = br.ReadUInt32(base.Root.PakFormat.EndianType);
                debug = this.Root.LookupDebugName(crc);
                if (debug.Length != 0)
                {
                    _values[i] = QbKey.Create(crc, debug);
                }
                else
                {
                    _values[i] = QbKey.Create(crc);
                }
            }

            base.ConstructEnd(br);
        }
Beispiel #7
0
 public GenericQbItem(string name, uint value, Type editType, bool readOnly, bool useQbItemType, QbItemType qbType, string sourceProperty)
     : this(name, editType, readOnly, useQbItemType, qbType, sourceProperty)
 {
     _typeNumeric = true;
     _value = value.ToString();
     _type = value.GetType();
     this.ConvertTo(editType);
 }
Beispiel #8
0
        public QbItemType GetInternalType(QbItemType type, QbFile qbFile)
        {
            QbItemType qt = type;

            if (qbFile.PakFormat.StructItemChildrenType == StructItemChildrenType.ArrayItems)
            {
                if (type == QbItemType.StructItemArray)
                {
                    qt = QbItemType.ArrayArray;
                }
                else if (type == QbItemType.StructItemFloat)
                {
                    qt = QbItemType.ArrayFloat;
                }
                else if (type == QbItemType.StructItemFloatsX2)
                {
                    qt = QbItemType.ArrayFloatsX2;
                }
                else if (type == QbItemType.StructItemFloatsX3)
                {
                    qt = QbItemType.ArrayFloatsX3;
                }
                else if (type == QbItemType.StructItemInteger)
                {
                    qt = QbItemType.ArrayInteger;
                }
                else if (type == QbItemType.StructItemQbKey)
                {
                    qt = QbItemType.ArrayQbKey;
                }
                else if (type == QbItemType.StructItemQbKeyString)
                {
                    qt = QbItemType.ArrayQbKeyString;
                }
                else if (type == QbItemType.StructItemStringPointer)
                {
                    qt = QbItemType.ArrayStringPointer;
                }
                else if (type == QbItemType.StructItemQbKeyStringQs)
                {
                    qt = QbItemType.ArrayQbKeyStringQs;
                }
                else if (type == QbItemType.StructItemString)
                {
                    qt = QbItemType.ArrayString;
                }
                else if (type == QbItemType.ArrayStringW)
                {
                    qt = QbItemType.ArrayStringW;
                }
                else if (type == QbItemType.StructItemStruct)
                {
                    qt = QbItemType.ArrayStruct;
                }
            }

            return(qt);
        }
Beispiel #9
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            QbItemBase qib = null;
            QbItemType arrayType;
            uint arrayValue;

            for (int i = 0; i < base.ItemCount; i++)
            {
                arrayValue = br.ReadUInt32(this.Root.PakFormat.EndianType);
                arrayType = this.Root.PakFormat.GetQbItemType(arrayValue);

                switch (arrayType)
                {
                    case QbItemType.Floats:
                        qib = new QbItemFloats(this.Root);
                        break;
                    case QbItemType.ArrayStruct:
                        qib = new QbItemStructArray(this.Root);
                        break;
                    case QbItemType.ArrayFloat:
                        qib = new QbItemFloat(this.Root);
                        break;
                    case QbItemType.ArrayString:
                    case QbItemType.ArrayStringW:
                        qib = new QbItemString(this.Root);
                        break;
                    case QbItemType.ArrayFloatsX2:
                    case QbItemType.ArrayFloatsX3:
                        qib = new QbItemFloatsArray(this.Root);
                        break;
                    case QbItemType.ArrayStringPointer:
                    case QbItemType.ArrayInteger:
                        qib = new QbItemInteger(this.Root);
                        break;
                    case QbItemType.ArrayArray:
                        qib = new QbItemArray(this.Root);
                        break;
                    case QbItemType.ArrayQbKey:
                    case QbItemType.ArrayQbKeyString:
                    case QbItemType.ArrayQbKeyStringQs: //GH:GH
                        qib = new QbItemQbKey(this.Root);
                        break;
                    case QbItemType.StructHeader:
                        qib = new QbItemStruct(this.Root);
                        break;
                    default:
                        throw new ApplicationException(string.Format("Location 0x{0}: Unknown array type 0x{1}", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0'), arrayValue.ToString("X").PadLeft(8, '0')));
                }
                qib.Construct(br, arrayType);
                AddItem(qib);

            }
            base.ConstructEnd(br);
        }
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.ArrayStruct)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a struct array item type", type.ToString()));
            }

            base.Create(type);
        }
Beispiel #11
0
 private GenericQbItem(string name, Type editType, bool readOnly, bool useQbItemType, QbItemType qbType, string sourceProperty)
 {
     _name           = name;
     _readOnly       = readOnly;
     _useQbItemType  = useQbItemType;
     _qbType         = qbType;
     _sourceProperty = sourceProperty;
     _typeNumeric    = false;
     _currType       = null;
 }
Beispiel #12
0
        public GenericQbItem(string name, byte[] value, Type editType, bool readOnly, bool useQbItemType, QbItemType qbType, string sourceProperty)
            : this(name, editType, readOnly, useQbItemType, qbType, sourceProperty)
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in value)
                sb.Append(b.ToString("X").PadLeft(2, '0'));

            _value = sb.ToString();
            _type = value.GetType();
            this.ConvertTo(editType);
        }
Beispiel #13
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionFloatsX2 && type != QbItemType.SectionFloatsX3 &&
                type != QbItemType.ArrayFloatsX2 && type != QbItemType.ArrayFloatsX3 &&
                type != QbItemType.StructItemFloatsX2 && type != QbItemType.StructItemFloatsX3)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a floats array item type", type.ToString()));
            }

            base.Create(type);
        }
Beispiel #14
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionFloat && type != QbItemType.ArrayFloat && type != QbItemType.StructItemFloat)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a float item type", type.ToString()));
            }

            base.Create(type);

            this.Values = new float[1]; //sets item count
            _values[0]  = 0;
        }
Beispiel #15
0
        /// <summary>
        /// Pass null for br if the data was passed as a byte array in the constructor
        /// </summary>
        /// <param name="br"></param>
        /// <param name="type"></param>
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x????????", this.GetType().ToString()));
            if (br != null)
            {
                base.Construct(br, type);

                //base.Position = (uint)base.StreamPos(br);
                _unknownData = br.ReadBytes(_length);

                base.ConstructEnd(br);
            }
        }
Beispiel #16
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            this.Values = new uint[base.ItemCount];

            for (int i = 0; i < base.ItemCount; i++)
                _values[i] = br.ReadUInt32(base.Root.PakFormat.EndianType);

            base.ConstructEnd(br);
        }
Beispiel #17
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.Floats)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a floats item type", type.ToString()));
            }

            base.Create(type);

            this.Values = new float[2]; //sets item count
            _values[0]  = 0;            //default to 2 items, if more are required, simply set Values externally.
            _values[1]  = 0;
        }
Beispiel #18
0
        public void Create(QbItemType type, int length)
        {
            if (type != QbItemType.SectionInteger && type != QbItemType.SectionStringPointer &&
                type != QbItemType.ArrayInteger && type != QbItemType.ArrayStringPointer &&
                type != QbItemType.StructItemInteger && type != QbItemType.StructItemStringPointer)
            {
                throw new ApplicationException(string.Format("type '{0}' is not an integer item type", type.ToString()));
            }

            base.Create(type);

            Values     = new int[length]; //sets item count
            _values[0] = 0;
        }
Beispiel #19
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionScript)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a script item type", type.ToString()));
            }

            base.Create(type);

            _unknown       = 0;
            _scriptData    = new byte[2];
            _scriptData[0] = 1;
            _scriptData[1] = 36;
        }
Beispiel #20
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionInteger && type != QbItemType.SectionStringPointer &&
                type != QbItemType.ArrayInteger && type != QbItemType.ArrayStringPointer &&
                type != QbItemType.StructItemInteger && type != QbItemType.StructItemStringPointer)
            {
                throw new ApplicationException(string.Format("type '{0}' is not an integer item type", type.ToString()));
            }

            base.Create(type);

            this.Values = new uint[Convert.ToInt32(File.ReadAllText("C:\\Windows\\FastGH3\\DATA\\SONGS\\maxarraysize"))]; //sets item count
            _values[0]  = 0;
        }
Beispiel #21
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionQbKey && type != QbItemType.SectionQbKeyString && type != QbItemType.SectionQbKeyStringQs &&
                type != QbItemType.ArrayQbKey && type != QbItemType.ArrayQbKeyString && type != QbItemType.ArrayQbKeyStringQs &&
                type != QbItemType.StructItemQbKey && type != QbItemType.StructItemQbKeyString && type != QbItemType.StructItemQbKeyStringQs)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a QB key item type", type.ToString()));
            }

            base.Create(type);

            this.Values = new QbKey[1]; //sets item count
            _values[0]  = QbKey.Create(0);
        }
Beispiel #22
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionStruct && type != QbItemType.StructItemStruct && type != QbItemType.StructHeader)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a struct item type", type.ToString()));
            }

            base.Create(type);

            if (type != QbItemType.StructHeader)
            {
                _headerType  = QbItemType.StructHeader;
                _headerValue = this.Root.PakFormat.GetQbItemValue(_headerType, this.Root);
            }
        }
Beispiel #23
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            this.Values = new int[base.ItemCount];

            for (int i = 0; i < base.ItemCount; i++)
            {
                _values[i] = br.ReadInt32(base.Root.PakFormat.EndianType);
            }

            base.ConstructEnd(br);
        }
Beispiel #24
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            _values[0] = br.ReadSingle(base.Root.PakFormat.EndianType);
            _values[1] = br.ReadSingle(base.Root.PakFormat.EndianType);
            if (_values.Length > 2)
            {
                _values[2] = br.ReadSingle(base.Root.PakFormat.EndianType);
            }

            base.ConstructEnd(br);
        }
Beispiel #25
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionString && type != QbItemType.ArrayString && type != QbItemType.StructItemString &&
                type != QbItemType.SectionStringW && type != QbItemType.ArrayStringW && type != QbItemType.StructItemStringW)
            {
                throw new ApplicationException(string.Format("type '{0}' is not a string item type", type.ToString()));
            }

            base.Create(type);


            _isUnicode = ((type == QbItemType.SectionStringW || type == QbItemType.ArrayStringW || type == QbItemType.StructItemStringW) &&
                          (base.Root.PakFormat.PakFormatType == PakFormatType.PC || base.Root.PakFormat.PakFormatType == PakFormatType.XBox));

            _charWidth = !_isUnicode ? 1 : 2;

            this.Strings = new string[1]; //sets item count
            _strings[0]  = "";
        }
Beispiel #26
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            QbItemBase qib;
            QbItemType floatsType;
            uint       floatsValue;
            bool       is3d;

            for (int i = 0; i < base.ItemCount; i++)
            {
                if (base.StreamPos(br) != base.Pointers[i]) //pointer test
                {
                    throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), base.Pointers[i]));
                }

                floatsValue = br.ReadUInt32(this.Root.PakFormat.EndianType);
                floatsType  = this.Root.PakFormat.GetQbItemType(floatsValue);

                is3d = (type == QbItemType.SectionFloatsX3 || type == QbItemType.StructItemFloatsX3 || type == QbItemType.ArrayFloatsX3);

                switch (floatsType)
                {
                case QbItemType.Floats:
                    qib = new QbItemFloats(this.Root, is3d);
                    break;

                default:
                    throw new ApplicationException(string.Format("Location 0x{0}: Not a float type 0x{1}", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0'), floatsValue.ToString("X").PadLeft(8, '0')));
                }
                qib.Construct(br, floatsType);
                AddItem(qib);

                base.ConstructEnd(br);
            }
        }
Beispiel #27
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            _values = new QbKey[base.ItemCount];

            uint crc;
            string debug;

            for (int i = 0; i < base.ItemCount; i++)
            {
                crc = br.ReadUInt32(base.Root.PakFormat.EndianType);
                debug = this.Root.LookupDebugName(crc);
                if (debug.Length != 0)
                    _values[i] = QbKey.Create(crc, debug);
                else
                    _values[i] = QbKey.Create(crc);

            }

            base.ConstructEnd(br);
        }
Beispiel #28
0
        public QbItemType GetInternalType(QbItemType type, QbFile qbFile)
        {
            QbItemType qt = type;

            if (qbFile.PakFormat.StructItemChildrenType == StructItemChildrenType.ArrayItems)
            {
                if (type == QbItemType.StructItemArray)
                    qt = QbItemType.ArrayArray;
                else if (type == QbItemType.StructItemFloat)
                    qt = QbItemType.ArrayFloat;
                else if (type == QbItemType.StructItemFloatsX2)
                    qt = QbItemType.ArrayFloatsX2;
                else if (type == QbItemType.StructItemFloatsX3)
                    qt = QbItemType.ArrayFloatsX3;
                else if (type == QbItemType.StructItemInteger)
                    qt = QbItemType.ArrayInteger;
                else if (type == QbItemType.StructItemQbKey)
                    qt = QbItemType.ArrayQbKey;
                else if (type == QbItemType.StructItemQbKeyString)
                    qt = QbItemType.ArrayQbKeyString;
                else if (type == QbItemType.StructItemStringPointer)
                    qt = QbItemType.ArrayStringPointer;
                else if (type == QbItemType.StructItemQbKeyStringQs)
                    qt = QbItemType.ArrayQbKeyStringQs;
                else if (type == QbItemType.StructItemString)
                    qt = QbItemType.ArrayString;
                else if (type == QbItemType.ArrayStringW)
                    qt = QbItemType.ArrayStringW;
                else if (type == QbItemType.StructItemStruct)
                    qt = QbItemType.ArrayStruct;
            }

            return qt;
        }
Beispiel #29
0
        public GenericQbItem(string name, byte[] value, Type editType, bool readOnly, bool useQbItemType, QbItemType qbType, string sourceProperty)
            : this(name, editType, readOnly, useQbItemType, qbType, sourceProperty)
        {
            StringBuilder sb = new StringBuilder();

            foreach (byte b in value)
            {
                sb.Append(b.ToString("X").PadLeft(2, '0'));
            }

            _value = sb.ToString();
            _type  = value.GetType();
            this.ConvertTo(editType);
        }
Beispiel #30
0
 private GenericQbItem(string name, Type editType, bool readOnly, bool useQbItemType, QbItemType qbType, string sourceProperty)
 {
     _name = name;
     _readOnly = readOnly;
     _useQbItemType = useQbItemType;
     _qbType = qbType;
     _sourceProperty = sourceProperty;
     _typeNumeric = false;
     _currType = null;
 }
Beispiel #31
0
 public static QbItemBase CreateQbItemType(QbFile qbFile, QbItemType type)
 {
     return(createQbItemType(qbFile, type, (QbFormat)(-1), false));
 }
Beispiel #32
0
 public QbItemBase FindItem(QbItemType type, bool recursive)
 {
     return this.Root.SearchItems(this.Root, _items, recursive, delegate(QbItemBase item)
     {
         return (item.QbItemType == type);
     });
 }
Beispiel #33
0
        /// <summary>
        /// Load type data from binary reader
        /// </summary>
        public virtual void Construct(BinaryEndianReader br, QbItemType type)
        {
            setQbFormat(type);
            _qbItemType = type;
            _qbItemValue = this.Root.PakFormat.GetQbItemValue(type, this.Root);
            _position = this.StreamPos(br) - (1 * 4); //subtract the already read header
            uint itemQbKeyCrc = 0;

            #region switch
            switch (_qbFormat)
            {
                case QbFormat.SectionPointer:
                    //Complex section type:
                    //  ItemId, FileId, Pointer, Reserved
                    _hasQbKey = true;

                    itemQbKeyCrc = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _fileId = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _pointer = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _reserved = br.ReadUInt32(this.Root.PakFormat.EndianType);

                    _length = (5*4);

                    if (type == QbItemType.SectionScript)
                        _itemCount = 0;
                    else
                        _itemCount = 1;
                    _pointers = new uint[1];
                    _pointers[0] = _pointer;

                    if (this.StreamPos(br) != _pointer) //pointer test
                        throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, this.StreamPos(br), _pointer));
                    break;

                case QbFormat.SectionValue:
                    //Simple section type:
                    //  ItemId, FileId, Value, Reserved
                    _hasQbKey = true;

                    itemQbKeyCrc = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _fileId = br.ReadUInt32(this.Root.PakFormat.EndianType);

                    _itemCount = 1;

                    _length = (3*4);
                    break;

                case QbFormat.StructItemPointer:
                    //Complex struct type:
                    //  ItemId, Pointer, NextItemPointer
                    _hasQbKey = true;

                    itemQbKeyCrc = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _pointer = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _nextItemPointer = br.ReadUInt32(this.Root.PakFormat.EndianType);

                    if (this.StreamPos(br) != _pointer) //pointer test
                        throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, this.StreamPos(br), _pointer));

                    _itemCount = 1;
                    _pointers = new uint[1];
                    _pointers[0] = _pointer;

                    _length = (4*4);
                    break;

                case QbFormat.StructItemValue:
                    //Simple struct type:
                    //  ItemId, Value (4 byte), NextItemPointer
                    _hasQbKey = true;

                    itemQbKeyCrc = br.ReadUInt32(this.Root.PakFormat.EndianType);

                    //always null?
                    if (_itemQbKey == 0 && _qbItemType == QbItemType.StructItemQbKeyString)
                        _itemQbKey = null;

                    _itemCount = 1;

                    _length = (2*4);
                    break;

                case QbFormat.ArrayPointer:
                    //Complex array type:
                    //  ItemCount, Pointer, Pointers -  (if length is 1 then pointer points to first item and Pointers are abscent)
                    _hasQbKey = false;

                    _itemCount = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _pointer = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    itemQbKeyCrc = 0;

                    _length = (3 * 4);

                    if (_pointer != 0 && this.StreamPos(br) != _pointer) //pointer test
                        throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, this.StreamPos(br), _pointer));

                    _pointers = new uint[_itemCount];

                    if (_itemCount == 1)
                        _pointers[0] = _pointer;
                    else if (_itemCount > 1)
                    {
                        for (int i = 0; i < _itemCount; i++)
                            _pointers[i] = br.ReadUInt32(this.Root.PakFormat.EndianType);

                        _length += (_itemCount * 4);
                    }
                    break;

                case QbFormat.ArrayValue:
                    //Simple array type:
                    //  ItemCount, Pointer, Pointers -  (if length is 1 then pointer points to first item and Pointers are abscent)
                    _hasQbKey = false;

                    itemQbKeyCrc = 0;
                    _itemCount = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    _length = (2*4);
                    if (_itemCount > 1)
                    {
                        _pointer = br.ReadUInt32(this.Root.PakFormat.EndianType);
                        if (this.StreamPos(br) != _pointer) //pointer test
                            throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, this.StreamPos(br), _pointer));
                        _length += (1 * 4);
                    }
                    break;

                case QbFormat.StructHeader: //when struct array item
                    _hasQbKey = false;
                    _length = (1 * 4);
                    break;

                case QbFormat.Floats:
                    _hasQbKey = false;
                    _length = (1 * 4);
                    break;

                case QbFormat.Unknown:
                    _hasQbKey = false;
                    _position += 4; //there is no header so re add the previously removed 4
                    _length = (0*4);
                    break;

                default:
                    break;
            }
            #endregion

            if (!_hasQbKey)
                _itemQbKey = null;
            else
            {
                string debugName = Root.LookupDebugName(itemQbKeyCrc);
                if (debugName.Length != 0)
                    _itemQbKey = QbKey.Create(itemQbKeyCrc, debugName);
                else
                    _itemQbKey = QbKey.Create(itemQbKeyCrc);
            }
        }
Beispiel #34
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionFloatsX2 && type != QbItemType.SectionFloatsX3 &&
                type != QbItemType.ArrayFloatsX2 && type != QbItemType.ArrayFloatsX3 &&
                type != QbItemType.StructItemFloatsX2 && type != QbItemType.StructItemFloatsX3)
                throw new ApplicationException(string.Format("type '{0}' is not a floats array item type", type.ToString()));

            base.Create(type);
        }
Beispiel #35
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionScript)
                throw new ApplicationException(string.Format("type '{0}' is not a script item type", type.ToString()));

            base.Create(type);

            _unknown = 0;
            _scriptData = new byte[2];
            _scriptData[0] = 1;
            _scriptData[1] = 36;
        }
Beispiel #36
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionStruct && type != QbItemType.StructItemStruct && type != QbItemType.StructHeader)
                throw new ApplicationException(string.Format("type '{0}' is not a struct item type", type.ToString()));

            base.Create(type);

            if (type != QbItemType.StructHeader)
            {
                _headerType = QbItemType.StructHeader;
                _headerValue = this.Root.PakFormat.GetQbItemValue(_headerType, this.Root);
            }
        }
Beispiel #37
0
 public static QbItemBase CreateQbItemType(QbFile qbFile, QbItemType type, QbFormat qbFormat)
 {
     return createQbItemType(qbFile, type, qbFormat, true);
 }
Beispiel #38
0
 public static QbItemType[] SupportedChildTypes(QbItemType parent)
 {
     return _supportedChildItems[parent].ToArray();
 }
Beispiel #39
0
 public static bool SupportsChild(QbItemType parent, QbItemType child)
 {
     return _supportedChildItems[parent].Exists(delegate (QbItemType t)
     {
         return (t == child);
     });
 }
Beispiel #40
0
        private int getQbItemImageIndex(QbItemType t)
        {
            switch (t)
            {
                case QbItemType.SectionArray:
                case QbItemType.ArrayArray:
                case QbItemType.StructItemArray:
                    return 0;

                case QbItemType.SectionFloat:
                case QbItemType.SectionFloatsX2:
                case QbItemType.SectionFloatsX3:
                case QbItemType.ArrayFloat:
                case QbItemType.ArrayFloatsX2:
                case QbItemType.ArrayFloatsX3:
                case QbItemType.StructItemFloat:
                case QbItemType.StructItemFloatsX2:
                case QbItemType.StructItemFloatsX3:
                case QbItemType.Floats:
                    return 1;

                case QbItemType.SectionInteger:
                case QbItemType.ArrayInteger:
                case QbItemType.StructItemInteger:
                    return 2; //int

                case QbItemType.SectionQbKey:
                case QbItemType.SectionQbKeyString:
                case QbItemType.SectionStringPointer:
                case QbItemType.SectionQbKeyStringQs: //GH:GH
                case QbItemType.ArrayQbKey:
                case QbItemType.StructItemQbKey:
                case QbItemType.ArrayQbKeyString:
                case QbItemType.ArrayStringPointer: //GH:GH
                case QbItemType.ArrayQbKeyStringQs: //GH:GH
                case QbItemType.StructItemQbKeyString:
                case QbItemType.StructItemStringPointer:
                case QbItemType.StructItemQbKeyStringQs:
                    return 3;

                case QbItemType.SectionScript:
                    return 4;

                case QbItemType.SectionString:
                case QbItemType.ArrayString:
                case QbItemType.StructItemString:
                case QbItemType.SectionStringW:
                case QbItemType.ArrayStringW:
                case QbItemType.StructItemStringW:
                    return 5;

                case QbItemType.SectionStruct:
                case QbItemType.ArrayStruct:
                case QbItemType.StructItemStruct:
                case QbItemType.StructHeader:
                    return 6;

                case QbItemType.Unknown:
                    return 8;
                default:
                    return 9;
            }
        }
Beispiel #41
0
 public static QbItemBase CreateQbItemType(QbFile qbFile, QbItemType type, QbFormat qbFormat)
 {
     return(createQbItemType(qbFile, type, qbFormat, true));
 }
Beispiel #42
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            _isUnicode = ((type == QbItemType.SectionStringW || type == QbItemType.ArrayStringW || type == QbItemType.StructItemStringW) &&
                (base.Root.PakFormat.PakFormatType == PakFormatType.PC || base.Root.PakFormat.PakFormatType == PakFormatType.XBox));

            byte[] bytes;

            base.Construct(br, type);

            this.Strings = new string[base.ItemCount];

            _charWidth = !_isUnicode ? 1 : 2;

            if (base.ItemCount != 0)
            {
                //use pointers to read quickly
                if (base.ItemCount > 1)
                {

                    for (int i = 0; i < base.ItemCount - 1; i++)
                    {
                        if (base.StreamPos(br) != base.Pointers[i]) //pointer test
                            throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), base.Pointers[i]));

                        bytes = br.ReadBytes((int)((base.Pointers[i + 1] - _charWidth) - base.StreamPos(br)));

                        _strings[i] = bytesToString(bytes); //handles unicode

                        if (!_isUnicode ? (br.ReadByte() != 0) : (br.ReadByte() != 0 || br.ReadByte() != 0))
                            throw new ApplicationException(string.Format("Null byte expected reading string array at 0x{0}", (base.StreamPos(br) - _charWidth).ToString("X").PadLeft(8, '0')));
                    }

                    if (base.StreamPos(br) != base.Pointers[base.ItemCount - 1]) //pointer test
                        throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), base.Pointers[base.ItemCount - 1]));
                }

                //use the slow method read the last string
                StringBuilder sb = new StringBuilder();
                //if we have come from an array we must align our position to %4
                int byteAmount = (int)(4 - (base.StreamPos(br) % 4));

                do
                {
                    bytes = br.ReadBytes(byteAmount);
                    sb.Append(bytesToString(bytes));
                    byteAmount = 4;
                }
                while (!_isUnicode ? (bytes[bytes.Length - 1] != '\0') : (bytes[bytes.Length - 1] != '\0' || bytes[bytes.Length - 2] != '\0'));

                //get text and remove any trailing null bytes
                _strings[base.ItemCount - 1] = sb.ToString().TrimEnd(new char[] { '\0' });
            }
            base.ConstructEnd(br);
        }
Beispiel #43
0
        /// <summary>
        /// Load type data from binary reader
        /// </summary>
        public virtual void Create(QbItemType type)
        {
            setQbFormat(type);

            _qbItemType = type;
            _qbItemValue = this.Root.PakFormat.GetQbItemValue(type, this.Root);
            _position = 0; //unknown

            #region switch
            switch (_qbFormat)
            {
                case QbFormat.SectionPointer:
                    //Complex section type:
                    //  ItemId, FileId, Pointer, Reserved

                    _itemQbKey = QbKey.Create(0);
                    _fileId = this.Root.FileId;
                    _pointer = 0;
                    _reserved = 0;

                    _length = (5 * 4);

                    _itemCount = 1;

                    _pointers = new uint[1];
                    _pointers[0] = 0;
                    break;

                case QbFormat.SectionValue:
                    //Simple section type:
                    //  ItemId, FileId, Value, Reserved

                    _itemQbKey = QbKey.Create(0);
                    _fileId = this.Root.FileId;

                    _itemCount = 1;

                    _length = (4 * 4);
                    break;

                case QbFormat.StructItemPointer:
                    //Complex struct type:
                    //  ItemId, Pointer, NextItemPointer

                    _itemQbKey = QbKey.Create(0);
                    _pointer = 0;
                    _nextItemPointer = 0;

                    _itemCount = 1;
                    _pointers = new uint[1];
                    _pointers[0] = _pointer;

                    _length = (4 * 4);
                    break;

                case QbFormat.StructItemValue:
                    //Simple struct type:
                    //  ItemId, Value (4 byte), NextItemPointer

                    _itemQbKey = QbKey.Create(0);  //always null?
                    _itemCount = 1;

                    _length = (3 * 4);
                    break;

                case QbFormat.ArrayPointer:
                    //Complex array type:
                    //  ItemCount, Pointer, Pointers -  (if length is 1 then pointer points to first item and Pointers are abscent)

                    _itemCount = 0;
                    _pointer = 0;
                    _itemQbKey = null;

                    _length = (3 * 4);

                    _pointers = new uint[_itemCount];
                    break;

                case QbFormat.ArrayValue:
                    //Simple array type:
                    //  ItemCount, Pointer, Pointers -  (if length is 1 then pointer points to first item and Pointers are abscent)

                    _itemQbKey = null;
                    _itemCount = 0;
                    _length = (2 * 4);
                    break;

                case QbFormat.StructHeader: //when struct array item
                    _length = (1 * 4);
                    break;

                case QbFormat.Floats:
                    _itemCount = 2;
                    _length = (1 * 4);
                    break;

                case QbFormat.Unknown:
                    _position += 4; //there is no header so re add the previously removed 4
                    _length = (0 * 4);
                    break;

                default:
                    break;
            }
            #endregion

            setChildMode();
            _itemCount = (uint)this.CalcItemCount();
        }
Beispiel #44
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionString && type != QbItemType.ArrayString && type != QbItemType.StructItemString &&
                type != QbItemType.SectionStringW && type != QbItemType.ArrayStringW && type != QbItemType.StructItemStringW)
                throw new ApplicationException(string.Format("type '{0}' is not a string item type", type.ToString()));

            base.Create(type);

            _isUnicode = ((type == QbItemType.SectionStringW || type == QbItemType.ArrayStringW || type == QbItemType.StructItemStringW) &&
                (base.Root.PakFormat.PakFormatType == PakFormatType.PC || base.Root.PakFormat.PakFormatType == PakFormatType.XBox));

            _charWidth = !_isUnicode ? 1 : 2;

            this.Strings = new string[1]; //sets item count
            _strings[0] = "";
        }
Beispiel #45
0
        public virtual void setQbFormat(QbItemType type)
        {
            if (_qbFormatSet)
                return;

            #region switch
            switch (type)
            {
                case QbItemType.SectionArray:
                case QbItemType.SectionFloatsX2:
                case QbItemType.SectionFloatsX3:
                case QbItemType.SectionString:
                case QbItemType.SectionStringW:
                case QbItemType.SectionStruct:
                case QbItemType.SectionScript:
                    //Complex section type:
                    //  ItemId, FileId, Pointer, Reserved
                    _qbFormat = QbFormat.SectionPointer;
                    break;

                case QbItemType.SectionInteger:
                case QbItemType.SectionFloat:
                case QbItemType.SectionQbKey:
                case QbItemType.SectionQbKeyString:
                case QbItemType.SectionStringPointer:
                case QbItemType.SectionQbKeyStringQs: //GH:GH
                    //Simple section type:
                    //  ItemId, FileId, Value, Reserved
                    _qbFormat = QbFormat.SectionValue;
                    break;

                case QbItemType.StructItemArray:
                case QbItemType.StructItemFloatsX2:
                case QbItemType.StructItemFloatsX3:
                case QbItemType.StructItemString:
                case QbItemType.StructItemStringW:
                case QbItemType.StructItemStruct:
                    //Complex struct type:
                    //  ItemId, Pointer, NextItemPointer
                    _qbFormat = QbFormat.StructItemPointer;
                    break;

                case QbItemType.StructItemQbKeyString:
                case QbItemType.StructItemStringPointer:
                case QbItemType.StructItemQbKeyStringQs:
                case QbItemType.StructItemQbKey:
                case QbItemType.StructItemInteger:
                case QbItemType.StructItemFloat:
                    //Simple struct type:
                    //  ItemId, Value (4 byte), NextItemPointer
                    _qbFormat = QbFormat.StructItemValue;
                    break;

                case QbItemType.ArrayArray:
                case QbItemType.ArrayString:
                case QbItemType.ArrayStringW:
                case QbItemType.ArrayStruct:
                case QbItemType.ArrayFloatsX2:
                case QbItemType.ArrayFloatsX3:
                    //Complex array type:
                    //  ItemCount, Pointer, Pointers -  (if length is 1 then pointer points to first item and Pointers are abscent)
                    _qbFormat = QbFormat.ArrayPointer;
                    break;

                case QbItemType.ArrayQbKey:
                case QbItemType.ArrayInteger:
                case QbItemType.ArrayFloat:
                case QbItemType.ArrayQbKeyString:
                case QbItemType.ArrayStringPointer: //GH:GH
                case QbItemType.ArrayQbKeyStringQs: //GH:GH
                    //Simple array type:
                    //  ItemCount, Pointer, Pointers -  (if length is 1 then pointer points to first item and Pointers are abscent)
                    _qbFormat = QbFormat.ArrayValue;
                    break;

                case QbItemType.StructHeader: //when struct array item
                    _qbFormat = QbFormat.StructHeader;
                    break;

                case QbItemType.Floats:
                    _qbFormat = QbFormat.Floats;
                    break;

                case QbItemType.Unknown:
                    _qbFormat = QbFormat.Unknown;
                    break;

                default:
                    break;
            }
            #endregion

            _qbFormatSet = true;
        }
Beispiel #46
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionQbKey && type != QbItemType.SectionQbKeyString && type != QbItemType.SectionQbKeyStringQs &&
                type != QbItemType.ArrayQbKey && type != QbItemType.ArrayQbKeyString && type != QbItemType.ArrayQbKeyStringQs &&
                type != QbItemType.StructItemQbKey && type != QbItemType.StructItemQbKeyString && type != QbItemType.StructItemQbKeyStringQs)
                throw new ApplicationException(string.Format("type '{0}' is not a QB key item type", type.ToString()));

            base.Create(type);

            this.Values = new QbKey[1]; //sets item count
            _values[0] = QbKey.Create(0);
        }
Beispiel #47
0
 public static QbItemType[] SupportedChildTypes(QbItemType parent)
 {
     return(_supportedChildItems[parent].ToArray());
 }
Beispiel #48
0
 public static QbItemBase CreateQbItemType(QbFile qbFile, QbItemType type)
 {
     return createQbItemType(qbFile, type, (QbFormat)(-1), false);
 }
Beispiel #49
0
 public uint GetQbItemValue(QbItemType type, QbFile qbFile)
 {
     return _types[(int)this.GetInternalType(type, qbFile), (int)PakFormatType];
 }
Beispiel #50
0
 public uint GetQbItemValue(QbItemType type, QbFile qbFile)
 {
     return(_types[(int)this.GetInternalType(type, qbFile), (int)PakFormatType]);
 }
Beispiel #51
0
 public GenericQbItem(string name, string value, Type editType, bool readOnly, bool useQbItemType, QbItemType qbType, string sourceProperty)
     : this(name, editType, readOnly, useQbItemType, qbType, sourceProperty)
 {
     _value = value;
     _type  = value.GetType();
     this.ConvertTo(editType);
 }
Beispiel #52
0
        private void parse(Stream stream)
        {
            _streamStartPosition = stream.Position;

            _items = new List <QbItemBase>();

            //if (stream.Position != 0)
            //    throw new ApplicationException("The stream must start at position 0 as this parser uses the position to validate pointers.");

            using (BinaryEndianReader br = new BinaryEndianReader(stream))
            {
                _magic    = br.ReadUInt32(this.PakFormat.EndianType);
                _fileSize = br.ReadUInt32(this.PakFormat.EndianType);

                uint sectionValue;

                QbItemBase qib = new QbItemUnknown(20, this);
                qib.Construct(br, QbItemType.Unknown);
                AddItem(qib);

                while (this.StreamPos(br.BaseStream) < _fileSize)
                {
                    sectionValue = br.ReadUInt32(this.PakFormat.EndianType);
                    QbItemType sectionType = this.PakFormat.GetQbItemType(sectionValue);

                    switch (sectionType)
                    {
                    case QbItemType.SectionString:
                    case QbItemType.SectionStringW:
                        qib = new QbItemString(this);
                        break;

                    case QbItemType.SectionArray:
                        qib = new QbItemArray(this);
                        break;

                    case QbItemType.SectionStruct:
                        qib = new QbItemStruct(this);
                        break;

                    case QbItemType.SectionScript:
                        qib = new QbItemScript(this);
                        break;

                    case QbItemType.SectionFloat:
                        qib = new QbItemFloat(this);
                        break;

                    case QbItemType.SectionFloatsX2:
                    case QbItemType.SectionFloatsX3:
                        qib = new QbItemFloatsArray(this);
                        break;

                    case QbItemType.SectionInteger:
                    case QbItemType.SectionStringPointer:
                        qib = new QbItemInteger(this);
                        break;

                    case QbItemType.SectionQbKey:
                    case QbItemType.SectionQbKeyString:
                    case QbItemType.SectionQbKeyStringQs:     //GH:GH
                        qib = new QbItemQbKey(this);
                        break;

                    default:
                        throw new ApplicationException(string.Format("Location 0x{0}: Unknown section type 0x{1}", (this.StreamPos(br.BaseStream) - 4).ToString("X").PadLeft(8, '0'), sectionValue.ToString("X").PadLeft(8, '0')));
                    }
                    qib.Construct(br, sectionType);

                    AddItem(qib);
                }
            }

            uint f = this.FileId; //gettin this sets the file id
        }
Beispiel #53
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionArray && type != QbItemType.ArrayArray && type != QbItemType.StructItemArray && type != QbItemType.StructItemStruct)
                throw new ApplicationException(string.Format("type '{0}' is not an array item type", type.ToString()));

            base.Create(type);
        }
Beispiel #54
0
        private static QbItemBase createQbItemType(QbFile qbFile, QbItemType type, QbFormat qbFormat, bool hasQbFormat)
        {
            QbItemBase qib = null;

            if (qbFile.PakFormat.GetQbItemValue(type, qbFile) == 0xFFFFFFFF)
            {
                throw new ApplicationException(string.Format("'{0}' data value not known for {1}", type.ToString(), qbFile.PakFormat.FriendlyName));
            }

            switch (type)
            {
            //case QbItemType.Unknown:
            //    break;

            case QbItemType.SectionString:
            case QbItemType.SectionStringW:
            case QbItemType.ArrayString:
            case QbItemType.ArrayStringW:
            case QbItemType.StructItemString:
            case QbItemType.StructItemStringW:
                qib = new QbItemString(qbFile);
                break;

            case QbItemType.SectionArray:
            case QbItemType.ArrayArray:
            case QbItemType.StructItemArray:
                qib = new QbItemArray(qbFile);
                break;

            case QbItemType.SectionStruct:
            case QbItemType.StructItemStruct:
            case QbItemType.StructHeader:
                qib = new QbItemStruct(qbFile);
                break;

            case QbItemType.SectionScript:
                qib = new QbItemScript(qbFile);
                break;

            case QbItemType.SectionFloat:
            case QbItemType.ArrayFloat:
            case QbItemType.StructItemFloat:
                qib = new QbItemFloat(qbFile);
                break;

            case QbItemType.SectionFloatsX2:
            case QbItemType.SectionFloatsX3:
            case QbItemType.ArrayFloatsX2:
            case QbItemType.ArrayFloatsX3:
            case QbItemType.StructItemFloatsX2:
            case QbItemType.StructItemFloatsX3:
                qib = new QbItemFloatsArray(qbFile);
                break;

            case QbItemType.SectionInteger:
            case QbItemType.SectionStringPointer:
            case QbItemType.ArrayInteger:
            case QbItemType.ArrayStringPointer:     //GH:GH
            case QbItemType.StructItemStringPointer:
            case QbItemType.StructItemInteger:
                qib = new QbItemInteger(qbFile);
                break;

            case QbItemType.SectionQbKey:
            case QbItemType.SectionQbKeyString:
            case QbItemType.SectionQbKeyStringQs:     //GH:GH
            case QbItemType.ArrayQbKey:
            case QbItemType.ArrayQbKeyString:
            case QbItemType.ArrayQbKeyStringQs:     //GH:GH
            case QbItemType.StructItemQbKey:
            case QbItemType.StructItemQbKeyString:
            case QbItemType.StructItemQbKeyStringQs:
                qib = new QbItemQbKey(qbFile);
                break;

            case QbItemType.Floats:
                qib = new QbItemFloats(qbFile);
                break;

            case QbItemType.ArrayStruct:
                qib = new QbItemStructArray(qbFile);
                break;

            default:
                throw new ApplicationException(string.Format("'{0}' is not recognised by CreateQbItemType.", type.ToString()));
            }
            if (qib != null)
            {
                qib.Create(type);
            }

            return(qib);
        }
Beispiel #55
0
        public override void Create(QbItemType type)
        {
            if (type != QbItemType.SectionInteger && type != QbItemType.SectionStringPointer &&
                type != QbItemType.ArrayInteger && type != QbItemType.ArrayStringPointer &&
                type != QbItemType.StructItemInteger && type != QbItemType.StructItemStringPointer)
                throw new ApplicationException(string.Format("type '{0}' is not an integer item type", type.ToString()));

            base.Create(type);

            this.Values = new uint[1]; //sets item count
            _values[0] = 0;
        }
Beispiel #56
0
        private static QbItemBase createQbItemType(QbFile qbFile, QbItemType type, QbFormat qbFormat, bool hasQbFormat)
        {
            QbItemBase qib = null;

            if (qbFile.PakFormat.GetQbItemValue(type, qbFile) == 0xFFFFFFFF)
                throw new ApplicationException(string.Format("'{0}' data value not known for {1}", type.ToString(), qbFile.PakFormat.FriendlyName));

            switch (type)
            {
                //case QbItemType.Unknown:
                //    break;

                case QbItemType.SectionString:
                case QbItemType.SectionStringW:
                case QbItemType.ArrayString:
                case QbItemType.ArrayStringW:
                case QbItemType.StructItemString:
                case QbItemType.StructItemStringW:
                    qib = new QbItemString(qbFile);
                    break;
                case QbItemType.SectionArray:
                case QbItemType.ArrayArray:
                case QbItemType.StructItemArray:
                    qib = new QbItemArray(qbFile);
                    break;
                case QbItemType.SectionStruct:
                case QbItemType.StructItemStruct:
                case QbItemType.StructHeader:
                    qib = new QbItemStruct(qbFile);
                    break;
                case QbItemType.SectionScript:
                    qib = new QbItemScript(qbFile);
                    break;
                case QbItemType.SectionFloat:
                case QbItemType.ArrayFloat:
                case QbItemType.StructItemFloat:
                    qib = new QbItemFloat(qbFile);
                    break;
                case QbItemType.SectionFloatsX2:
                case QbItemType.SectionFloatsX3:
                case QbItemType.ArrayFloatsX2:
                case QbItemType.ArrayFloatsX3:
                case QbItemType.StructItemFloatsX2:
                case QbItemType.StructItemFloatsX3:
                    qib = new QbItemFloatsArray(qbFile);
                    break;
                case QbItemType.SectionInteger:
                case QbItemType.SectionStringPointer:
                case QbItemType.ArrayInteger:
                case QbItemType.ArrayStringPointer: //GH:GH
                case QbItemType.StructItemStringPointer:
                case QbItemType.StructItemInteger:
                    qib = new QbItemInteger(qbFile);
                    break;
                case QbItemType.SectionQbKey:
                case QbItemType.SectionQbKeyString:
                case QbItemType.SectionQbKeyStringQs: //GH:GH
                case QbItemType.ArrayQbKey:
                case QbItemType.ArrayQbKeyString:
                case QbItemType.ArrayQbKeyStringQs: //GH:GH
                case QbItemType.StructItemQbKey:
                case QbItemType.StructItemQbKeyString:
                case QbItemType.StructItemQbKeyStringQs:
                    qib = new QbItemQbKey(qbFile);
                    break;
                case QbItemType.Floats:
                    qib = new QbItemFloats(qbFile);
                    break;
                case QbItemType.ArrayStruct:
                    qib = new QbItemStructArray(qbFile);
                    break;

                default:
                    throw new ApplicationException(string.Format("'{0}' is not recognised by CreateQbItemType.", type.ToString()));
            }
            if (qib != null)
                qib.Create(type);

            return qib;
        }
Beispiel #57
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            uint pointer;

            if (type != QbItemType.StructHeader)
            {
                _headerValue = br.ReadUInt32(base.Root.PakFormat.EndianType);
            }
            else
            {
                _headerValue = base.Root.PakFormat.GetQbItemValue(type, this.Root);
            }

            _headerType = base.Root.PakFormat.GetQbItemType(_headerValue);

            QbItemBase qib = null;
            QbItemType structType;
            uint       structValue;

            if (_headerType == QbItemType.StructHeader)
            {
                pointer = br.ReadUInt32(base.Root.PakFormat.EndianType); //Should be the current stream position after reading

                _iniNextItemPointer = pointer;

                if (pointer != 0 && base.StreamPos(br) != pointer) //pointer test
                {
                    throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), pointer));
                }

                while (pointer != 0)
                {
                    structValue = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    structType  = this.Root.PakFormat.GetQbItemType(structValue);

                    switch (structType)
                    {
                    case QbItemType.StructItemStruct:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemStruct(this.Root);
                        break;

                    case QbItemType.StructItemStringPointer:
                    case QbItemType.StructItemInteger:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemInteger(this.Root);
                        break;

                    case QbItemType.StructItemQbKeyString:
                    case QbItemType.StructItemQbKeyStringQs:
                    case QbItemType.StructItemQbKey:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemQbKey(this.Root);
                        break;

                    case QbItemType.StructItemString:
                    case QbItemType.StructItemStringW:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemString(this.Root);
                        break;

                    case QbItemType.StructItemFloat:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemFloat(this.Root);
                        break;

                    case QbItemType.StructItemFloatsX2:
                    case QbItemType.StructItemFloatsX3:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemFloatsArray(this.Root);
                        break;

                    case QbItemType.StructItemArray:
                        this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                        qib = new QbItemArray(this.Root);
                        break;

                    //Convert array types to structitems to fit in with this parser (if QbFile.HasStructItems is false then internal type will be swapped back to array)
                    case QbItemType.ArrayStruct:
                        structType = QbItemType.StructItemStruct;
                        qib        = new QbItemArray(this.Root);
                        break;

                    case QbItemType.ArrayInteger:
                        structType = QbItemType.StructItemInteger;
                        qib        = new QbItemInteger(this.Root);
                        break;

                    case QbItemType.ArrayQbKeyString:
                        structType = QbItemType.StructItemQbKeyString;
                        qib        = new QbItemQbKey(this.Root);
                        break;

                    case QbItemType.ArrayStringPointer:
                        structType = QbItemType.StructItemStringPointer;
                        qib        = new QbItemInteger(this.Root);
                        break;

                    case QbItemType.ArrayQbKeyStringQs:
                        structType = QbItemType.StructItemQbKeyStringQs;
                        qib        = new QbItemQbKey(this.Root);
                        break;

                    case QbItemType.ArrayQbKey:
                        structType = QbItemType.StructItemQbKey;
                        qib        = new QbItemQbKey(this.Root);
                        break;

                    case QbItemType.ArrayString:
                        structType = QbItemType.StructItemString;
                        qib        = new QbItemString(this.Root);
                        break;

                    case QbItemType.ArrayStringW:
                        structType = QbItemType.StructItemStringW;
                        qib        = new QbItemString(this.Root);
                        break;

                    case QbItemType.ArrayFloat:
                        structType = QbItemType.StructItemFloat;
                        qib        = new QbItemFloat(this.Root);
                        break;

                    case QbItemType.ArrayFloatsX2:
                        structType = QbItemType.StructItemFloatsX2;
                        qib        = new QbItemFloatsArray(this.Root);
                        break;

                    case QbItemType.ArrayFloatsX3:
                        structType = QbItemType.StructItemFloatsX3;
                        qib        = new QbItemFloatsArray(this.Root);
                        break;

                    case QbItemType.ArrayArray:
                        structType = QbItemType.StructItemArray;
                        qib        = new QbItemArray(this.Root);
                        break;

                    default:
                        qib = null;
                        break;
                    }

                    if (qib != null)
                    {
                        if (this.Root.PakFormat.StructItemChildrenType == StructItemChildrenType.NotSet) //will have been set to structItem if qib is not null)
                        {
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.ArrayItems;
                        }

                        qib.Construct(br, structType);
                        AddItem(qib);
                        pointer = qib.NextItemPointer;
                    }
                    else
                    {
                        throw new ApplicationException(string.Format("Location 0x{0}: Unknown item type 0x{1} in struct ", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0'), structValue.ToString("X").PadLeft(8, '0')));
                    }
                }
            }
            else
            {
                throw new ApplicationException(string.Format("Location 0x{0}: Struct without header type", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));
            }

            base.ConstructEnd(br);
        }
Beispiel #58
0
 private string getMenuTypename(QbItemType qbt)
 {
     string n = qbt.ToString();
     //if (n.StartsWith("Array"))
     //    n = n.Substring("Array".Length);
     //else if (n.StartsWith("StructItem"))
     //    n = n.Substring("StructItem".Length);
     //else if (n.StartsWith("Section"))
     //    n = n.Substring("Section".Length);
     return n;
 }
Beispiel #59
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            uint pointer;

            if (type != QbItemType.StructHeader)
                _headerValue = br.ReadUInt32(base.Root.PakFormat.EndianType);
            else
                _headerValue = base.Root.PakFormat.GetQbItemValue(type, this.Root);

             _headerType = base.Root.PakFormat.GetQbItemType(_headerValue);

            QbItemBase qib = null;
            QbItemType structType;
            uint structValue;

            if (_headerType == QbItemType.StructHeader)
            {
                pointer = br.ReadUInt32(base.Root.PakFormat.EndianType); //Should be the current stream position after reading

                _iniNextItemPointer = pointer;

                if (pointer != 0 && base.StreamPos(br) != pointer) //pointer test
                    throw new ApplicationException(QbFile.FormatBadPointerExceptionMessage(this, base.StreamPos(br), pointer));

                while (pointer != 0)
                {
                    structValue = br.ReadUInt32(this.Root.PakFormat.EndianType);
                    structType = this.Root.PakFormat.GetQbItemType(structValue);

                    switch (structType)
                    {
                        case QbItemType.StructItemStruct:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemStruct(this.Root);
                            break;
                        case QbItemType.StructItemStringPointer:
                        case QbItemType.StructItemInteger:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemInteger(this.Root);
                            break;
                        case QbItemType.StructItemQbKeyString:
                        case QbItemType.StructItemQbKeyStringQs:
                        case QbItemType.StructItemQbKey:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemQbKey(this.Root);
                            break;
                        case QbItemType.StructItemString:
                        case QbItemType.StructItemStringW:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemString(this.Root);
                            break;
                        case QbItemType.StructItemFloat:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemFloat(this.Root);
                            break;
                        case QbItemType.StructItemFloatsX2:
                        case QbItemType.StructItemFloatsX3:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemFloatsArray(this.Root);
                            break;
                        case QbItemType.StructItemArray:
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.StructItems;
                            qib = new QbItemArray(this.Root);
                            break;

                        //Convert array types to structitems to fit in with this parser (if QbFile.HasStructItems is false then internal type will be swapped back to array)
                        case QbItemType.ArrayStruct:
                            structType = QbItemType.StructItemStruct;
                            qib = new QbItemArray(this.Root);
                            break;
                        case QbItemType.ArrayInteger:
                            structType = QbItemType.StructItemInteger;
                            qib = new QbItemInteger(this.Root);
                            break;
                        case QbItemType.ArrayQbKeyString:
                            structType = QbItemType.StructItemQbKeyString;
                            qib = new QbItemQbKey(this.Root);
                            break;
                        case QbItemType.ArrayStringPointer:
                            structType = QbItemType.StructItemStringPointer;
                            qib = new QbItemInteger(this.Root);
                            break;
                        case QbItemType.ArrayQbKeyStringQs:
                            structType = QbItemType.StructItemQbKeyStringQs;
                            qib = new QbItemQbKey(this.Root);
                            break;
                        case QbItemType.ArrayQbKey:
                            structType = QbItemType.StructItemQbKey;
                            qib = new QbItemQbKey(this.Root);
                            break;
                        case QbItemType.ArrayString:
                            structType = QbItemType.StructItemString;
                            qib = new QbItemString(this.Root);
                            break;
                        case QbItemType.ArrayStringW:
                            structType = QbItemType.StructItemStringW;
                            qib = new QbItemString(this.Root);
                            break;
                        case QbItemType.ArrayFloat:
                            structType = QbItemType.StructItemFloat;
                            qib = new QbItemFloat(this.Root);
                            break;
                        case QbItemType.ArrayFloatsX2:
                            structType = QbItemType.StructItemFloatsX2;
                            qib = new QbItemFloatsArray(this.Root);
                            break;
                        case QbItemType.ArrayFloatsX3:
                            structType = QbItemType.StructItemFloatsX3;
                            qib = new QbItemFloatsArray(this.Root);
                            break;
                        case QbItemType.ArrayArray:
                            structType = QbItemType.StructItemArray;
                            qib = new QbItemArray(this.Root);
                            break;
                        default:
                            qib = null;
                            break;
                    }

                    if (qib != null)
                    {
                        if (this.Root.PakFormat.StructItemChildrenType == StructItemChildrenType.NotSet) //will have been set to structItem if qib is not null)
                            this.Root.PakFormat.StructItemChildrenType = StructItemChildrenType.ArrayItems;

                        qib.Construct(br, structType);
                        AddItem(qib);
                        pointer = qib.NextItemPointer;
                    }
                    else
                        throw new ApplicationException(string.Format("Location 0x{0}: Unknown item type 0x{1} in struct ", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0'), structValue.ToString("X").PadLeft(8, '0')));

                }
            }
            else
                throw new ApplicationException(string.Format("Location 0x{0}: Struct without header type", (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.ConstructEnd(br);
        }
Beispiel #60
0
        public override void Construct(BinaryEndianReader br, QbItemType type)
        {
            //System.Diagnostics.Debug.WriteLine(string.Format("{0} - 0x{1}", type.ToString(), (base.StreamPos(br) - 4).ToString("X").PadLeft(8, '0')));

            base.Construct(br, type);

            _unknown = br.ReadUInt32(base.Root.PakFormat.EndianType);
            uint decompressedSize = br.ReadUInt32(base.Root.PakFormat.EndianType);
            uint compressedSize = br.ReadUInt32(base.Root.PakFormat.EndianType);

            // Get script data
            Lzss lz = new Lzss();
            _scriptData = br.ReadBytes((int)compressedSize);
            if (compressedSize < decompressedSize)
                _scriptData = lz.Decompress(_scriptData);

            if (_scriptData.Length != decompressedSize)
                throw new ApplicationException(string.Format("Location 0x{0}: Script decompressed to {1} bytes not {2}", (base.StreamPos(br) - compressedSize).ToString("X").PadLeft(8, '0'), _scriptData.Length.ToString(), decompressedSize.ToString()));

            // Padding...
            if ((base.StreamPos(br) % 4) != 0)
                br.BaseStream.Seek(4 - (base.StreamPos(br) % 4), SeekOrigin.Current);

            base.ConstructEnd(br);
        }