Exemplo n.º 1
0
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.FULL:
            {
                this.MarkField(1);
                this._FullName = reader.ReadLocalizedString();
                break;
            }

            case FieldType.LNAM:
            {
                this._Ids.Add(reader.ReadValueU32());
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.FULL:
            {
                this.MarkField(1);
                this._FullName = reader.ReadLocalizedString();
                break;
            }

            case FieldType.DESC:
            {
                this.MarkField(2);
                this._Description = reader.ReadLocalizedString();
                break;
            }

            case FieldType.MODL:
            {
                this.MarkField(3);
                break;
            }

            case FieldType.MODT:
            {
                this.MarkField(4);
                break;
            }

            case FieldType.DATA:
            {
                this.MarkField(5);
                this._Data = reader.ReadObject <ObjectMod.Data>();
                break;
            }

            case FieldType.MNAM:
            {
                this.MarkField(6);
                Debug.Assert(size > 0 && (size % 4) == 0);
                var keywordIds = new uint[size / 4];
                for (int i = 0; i < keywordIds.Length; i++)
                {
                    keywordIds[i] = reader.ReadValueU32();
                }
                this._KeywordIds.Clear();
                this._KeywordIds.AddRange(keywordIds);
                break;
            }

            case FieldType.LNAM:
            {
                this.MarkField(7);
                Debug.Assert(size == 4);
                this._LNAM = reader.ReadValueU32();
                break;
            }

            case FieldType.NAM1:
            {
                this.MarkField(8);
                break;
            }

            case FieldType.FLTR:
            {
                this.MarkField(9);
                this._EditorFilter = reader.ReadString(260);
                break;
            }

            case FieldType.FNAM:
            {
                this.MarkField(10);
                break;
            }

            case FieldType.MODS:
            {
                this.MarkField(11);
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }
Exemplo n.º 3
0
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.FULL:
            {
                this._FullName = reader.ReadLocalizedString();
                break;
            }

            case FieldType.DESC:
            {
                this.MarkField(2);
                this._Description = reader.ReadLocalizedString();
                break;
            }

            case FieldType.OBND:
            {
                this.MarkField(3);
                Debug.Assert(size == 12);
                break;
            }

            case FieldType.PTRN:
            {
                this.MarkField(4);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.MOD2:
            {
                this.MarkField(5);
                this._ModelMale = reader.ReadString(260);
                break;
            }

            case FieldType.MO2T:
            {
                this.MarkField(6);
                break;
            }

            case FieldType.BOD2:
            {
                this.MarkField(7);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.RNAM:
            {
                this.MarkField(8);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.KSIZ:
            {
                this.MarkField(9);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.KWDA:
            {
                this.MarkField(10);
                break;
            }

            case FieldType.INRD:
            {
                this.MarkField(11);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.INDX:
            {
                //this.MarkField(12);
                Debug.Assert(size == 2);
                break;
            }

            case FieldType.MODL:
            {
                //this.MarkField(13);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.DATA:
            {
                this.MarkField(14);
                Debug.Assert(size == 12);
                break;
            }

            case FieldType.FNAM:
            {
                this.MarkField(15);
                Debug.Assert(size == 8);
                break;
            }

            case FieldType.DAMA:
            {
                this.MarkField(16);
                Debug.Assert(size == 8 || size == 16);
                break;
            }

            case FieldType.APPR:
            {
                this.MarkField(17);
                Debug.Assert(size == 4 || size == 8 || size == 16 || size == 28);
                break;
            }

            case FieldType.OBTE:
            {
                this.MarkField(18);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.OBTS:
            {
                //this.MarkField(19);
                //0x32 0x1D
                break;
            }

            case FieldType.OBTF:
            {
                //this.MarkField(20);
                Debug.Assert(size == 0);
                break;
            }

            case FieldType.STOP:
            {
                this.MarkField(21);
                Debug.Assert(size == 0);
                break;
            }

            case FieldType.EITM:
            {
                this.MarkField(22);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.MOD4:
            {
                this.MarkField(23);
                this._ModelFemale = reader.ReadString(260);
                break;
            }

            case FieldType.MO4T:
            {
                this.MarkField(24);
                break;
            }

            case FieldType.ETYP:
            {
                this.MarkField(25);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.MO2S:
            {
                this.MarkField(26);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.YNAM:
            {
                this.MarkField(27);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.ZNAM:
            {
                this.MarkField(28);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.MO4S:
            {
                this.MarkField(29);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.VMAD:
            {
                this.MarkField(30);
                break;
            }

            case FieldType.BAMT:
            {
                this.MarkField(31);
                Debug.Assert(size == 4);
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }
Exemplo n.º 4
0
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.FULL:
            {
                this.MarkField(1);
                this._FullName = reader.ReadLocalizedString();
                break;
            }

            case FieldType.DESC:
            {
                this.MarkField(2);
                this._Description = reader.ReadLocalizedString();
                break;
            }

            case FieldType.OBND:
            {
                this.MarkField(3);
                Debug.Assert(size == 12);
                break;
            }

            case FieldType.MODL:
            {
                this.MarkField(4);
                this._Model = reader.ReadString(0);
                break;
            }

            case FieldType.MODT:
            {
                this.MarkField(5);
                break;
            }

            case FieldType.DNAM:
            {
                this.MarkField(6);
                Debug.Assert((reader.Version >= 107 && size == 16) || (reader.Version < 107 && size == 8));

                var value1 = reader.ReadValueF32();
                var value2 = reader.ReadValueU32();
                if (reader.Version >= 107)
                {
                    var value3 = reader.ReadValueF32();
                    var value4 = reader.ReadValueF32();
                }
                else
                {
                }

                break;
            }

            case FieldType.MNAM:
            {
                this.MarkField(7);
                Debug.Assert(size == 1040);
                break;
            }

            case FieldType.PRPS:
            {
                this.MarkField(8);
                //Assert(size == 8);
                break;
            }

            case FieldType.PTRN:
            {
                this.MarkField(9);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.MODS:
            {
                this.MarkField(10);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.NVNM:
            {
                this.MarkField(11);
                //Assert(size == 720);
                break;
            }

            case FieldType.MODC:
            {
                this.MarkField(12);
                Debug.Assert(size == 4);
                break;
            }

            case FieldType.VMAD:
            {
                this.MarkField(13);
                Debug.Assert(size == 36);
                break;
            }

            case FieldType.FTYP:
            {
                this.MarkField(14);
                Debug.Assert(size == 4);
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }
Exemplo n.º 5
0
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.FULL:
            {
                this._FullName = reader.ReadLocalizedString();
                break;
            }

            case FieldType.CNAM:
            {
                this.MarkField(2);
                Debug.Assert(size == 4);
                this._CNAM = reader.ReadValueU32();
                break;
            }

            case FieldType.TNAM:
            {
                this.MarkField(3);
                Debug.Assert(size == 4);
                this._TNAM = reader.ReadValueU32();
                break;
            }

            case FieldType.DNAM:
            {
                this.MarkField(4);
                this._DNAM = reader.ReadString(0);
                break;
            }

            case FieldType.DATA:
            {
                this.MarkField(5);
                Debug.Assert(size == 4);
                this._DATA = reader.ReadValueU32();
                break;
            }

            case FieldType.NNAM:
            {
                this.MarkField(6);
                this._NNAM = reader.ReadString(260);
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.DESC:
            {
                this.MarkField(1);
                this._Description = reader.ReadLocalizedString();
                break;
            }

            case FieldType.FVPA:
            {
                this.MarkField(2);
                Debug.Assert(size > 0 && (size % 8) == 0);
                var ingredients = new Ingredient[size / 8];
                for (int i = 0; i < ingredients.Length; i++)
                {
                    var inputId  = reader.ReadValueU32();
                    var quantity = reader.ReadValueS32();
                    ingredients[i] = new Ingredient(inputId, quantity);
                }
                this._Ingredients.Clear();
                this._Ingredients.AddRange(ingredients);
                break;
            }

            case FieldType.CTDA:
            {
                Debug.Assert(size == 32);
                this._Conditions.Add(ConditionData.Read(reader));
                break;
            }

            case FieldType.CNAM:
            {
                this.MarkField(4);
                Debug.Assert(size == 4);
                this._OutputId = reader.ReadValueU32();
                break;
            }

            case FieldType.INTV:
            {
                this.MarkField(5);
                if (size == 4)
                {
                    this._OutputCount = reader.ReadValueU32();
                }
                else if (size == 2)
                {
                    this._OutputCount = reader.ReadValueU16();
                }
                else
                {
                    throw new FormatException();
                }
                break;
            }

            case FieldType.BNAM:
            {
                this.MarkField(6);
                Debug.Assert(size == 4);
                this._BenchKeywordId = reader.ReadValueU32();
                break;
            }

            case FieldType.FNAM:
            {
                this.MarkField(7);
                Debug.Assert(size > 0 && (size % 4) == 0);
                var ids = new uint[size / 4];
                for (int i = 0; i < ids.Length; i++)
                {
                    ids[i] = reader.ReadValueU32();
                }
                this._FilterKeywordIds.Clear();
                this._FilterKeywordIds.AddRange(ids);
                break;
            }

            case FieldType.YNAM:
            {
                this.MarkField(8);
                Debug.Assert(size == 4);
                this._PickupSoundId = reader.ReadValueU32();
                break;
            }

            case FieldType.ZNAM:
            {
                this.MarkField(9);
                Debug.Assert(size == 4);
                this._PutdownSoundId = reader.ReadValueU32();
                break;
            }

            case FieldType.ANAM:
            {
                this.MarkField(11);
                Debug.Assert(size == 4);
                this._ArtId = reader.ReadValueU32();
                break;
            }

            case FieldType.NAM1:
            case FieldType.NAM2:
            case FieldType.NAM3:
            {
                // deprecated
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }