Пример #1
0
        internal static IntValue Read(IFieldReader reader)
        {
            var value1 = reader.ReadValueS32();
            var value2 = reader.ReadValueS32();

            return(new IntValue(value1, value2));
        }
Пример #2
0
 internal override void Read(IFieldReader reader)
 {
     this.Version      = reader.ReadValueF32();
     this.RecordCount  = reader.ReadValueS32();
     this.NextRecordId = reader.ReadValueU32();
 }
        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();
            }
            }
        }