C# IValueReader.ReadManyNodes方法代码示例

        /// <summary>
        /// Reads the values for this <see cref="NPCChatConditionalCollectionItemBase"/> from an <see cref="IValueReader"/>.
        /// </summary>
        /// <param name="reader"><see cref="IValueReader"/> to read the values from.</param>
        /// <exception cref="ArgumentException">The read <see cref="NPCChatConditionalBase"/> was invalid.</exception>
        protected void Read(IValueReader reader)
        {
            var not = reader.ReadBool("Not");
            var conditionalName = reader.ReadString("ConditionalName");
            var parameters = reader.ReadManyNodes("Parameters", NPCChatConditionalParameter.Read);

            var conditional = NPCChatConditionalBase.GetConditional(conditionalName);
            if (conditional == null)
            {
                const string errmsg = "Failed to get conditional `{0}`.";
                throw new ArgumentException(string.Format(errmsg, conditionalName), "reader");
            }

            SetReadValues(conditional, not, parameters);
        }

        void LoadRefractionEffects(IValueReader reader)
        {
            reader = reader.ReadNode(_refractionEffectsNodeName);

            _refractionEffects.Clear();

            var loadedFx = reader.ReadManyNodes(_refractionEffectListNodeName, RefractionEffectFactory.Read);

            _refractionEffects.AddRange(loadedFx);

            foreach (var fx in loadedFx)
            {
                fx.Tag = this;
            }
        }

        void LoadLighting(IValueReader reader)
        {
            reader = reader.ReadNode(_lightingNodeName);

            AmbientLight = reader.ReadColor("Ambient");

            _lights.Clear();

            var loadedLights = reader.ReadManyNodes(_lightsNodeName, x => new Light(x));
            _lights.AddRange(loadedLights);

            foreach (var light in loadedLights)
            {
                light.Tag = this;
            }
        }

        void LoadGrhs(IValueReader reader)
        {
            reader = reader.ReadNode(_mapGrhsNodeName);

            // Used GrhIndexes
            var usedGrhIndexes = reader.ReadMany(_usedIndiciesNodeName, ((r, key) => r.ReadGrhIndex(key)));
            BuildAtlas(usedGrhIndexes);

            // MapGrhs
            var currentTime = GetTime();
            var loadedMapGrhs = reader.ReadManyNodes(_mapGrhsNodeName, x => new MapGrh(x, currentTime));
            foreach (var mapGrh in loadedMapGrhs)
            {
                AddMapGrh(mapGrh);
            }
        }

        void LoadBackgroundImages(IValueReader r)
        {
            var loadedBGImages = r.ReadManyNodes<BackgroundImage>(_bgImagesNodeName, x => new BackgroundLayer(this, this, x));

            // Add the loaded background images
            foreach (var bgImage in loadedBGImages)
            {
                AddBackgroundImage(bgImage);
            }
        }

 /// <summary>
 /// Reads the state of the object from an <see cref="IValueReader"/>. Values should be read in the exact
 /// same order as they were written.
 /// </summary>
 /// <param name="reader">The <see cref="IValueReader"/> to read the values from.</param>
 public void ReadState(IValueReader reader)
 {
     _questDescriptions.Clear();
     var nodes = reader.ReadManyNodes(_questDescriptionsNodeName, r => new QuestDescription(r));
     foreach (var n in nodes)
     {
         _questDescriptions.Insert(n.QuestID.GetRawValue(), n);
     }
 }

 public void Read(IValueReader reader, ContentPaths contentPath)
 {
     var loadedFrames = reader.ReadManyNodes(_framesNodeName, x => new SkeletonFrame(x, contentPath));
     _keyFrames = loadedFrames;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ColumnSchema"/> class.
 /// </summary>
 /// <param name="reader">The <see cref="IValueReader"/> to read the values from.</param>
 public ColumnSchema(IValueReader reader)
 {
     var values = reader.ReadManyNodes(_valuesNodeName, ReadKVP);
     _values = values.ToDictionary(x => x.Key, x => x.Value);
 }

        /// <summary>
        /// Reads the state of the object from an <see cref="IValueReader"/>. Values should be read in the exact
        /// same order as they were written.
        /// </summary>
        /// <param name="reader">The <see cref="IValueReader"/> to read the values from.</param>
        public override void ReadState(IValueReader reader)
        {
            base.ReadState(reader);

            CreateSlots();

            var slotValues = reader.ReadManyNodes("QuickBarItems", QuickBarSlotValues.Read);

            foreach (var sv in slotValues)
            {
                if (sv.Slot < _slots.Length)
                    _slots[sv.Slot].SetQuickBar(sv.Type, sv.Value);
            }
        }

        /// <summary>
        /// Reads the state of the object from an <see cref="IValueReader"/>. Values should be read in the exact
        /// same order as they were written.
        /// </summary>
        /// <param name="reader">The <see cref="IValueReader"/> to read the values from.</param>
        public void ReadState(IValueReader reader)
        {
            reader = reader.ReadNode(_particleEffectNodeName);

            // Clear the emitters
            foreach (var e in _emitters.ToImmutable())
            {
                e.Dispose();
            }

            Debug.Assert(_emitters.IsEmpty());
            _emitters.Clear();

            // Read the effect properties
            PersistableHelper.Read(this, reader);

            // Read the emitters
            var readEmitters = reader.ReadManyNodes(_emittersNodeName, r => ParticleEmitterFactory.Read(r, this));

            Debug.Assert(readEmitters.All(x => x.Owner == this));
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="TableSchema"/> class.
 /// </summary>
 /// <param name="reader">The <see cref="IValueReader"/> to read the values from.</param>
 public TableSchema(IValueReader reader)
 {
     _tableName = reader.ReadString(_tableNameValueKey);
     _columns = reader.ReadManyNodes(_columnsNodeName, r => new ColumnSchema(r)).ToCompact();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SchemaReader"/> class.
 /// </summary>
 /// <param name="reader">The <see cref="IValueReader"/> to read the values from.</param>
 public SchemaReader(IValueReader reader)
 {
     _tableSchemas = reader.ReadManyNodes(_tablesNodeName, r => new TableSchema(r)).ToCompact();
 }

        /// <summary>
        /// Reads the <see cref="BodyInfoManager"/> data from an <see cref="IValueReader"/>.
        /// </summary>
        /// <param name="reader">The <see cref="IValueReader"/> to read the <see cref="BodyInfoManager"/> data from.</param>
        public void Read(IValueReader reader)
        {
            var bodies = reader.ReadManyNodes(_bodyNodeName, BodyInfo.Read);
            _bodies.Clear();

            foreach (var body in bodies)
            {
                _bodies.Add(body.ID, body);
            }
        }

 public void Read(IValueReader reader)
 {
     _items = reader.ReadManyNodes(_itemsNodeName, x => new SkeletonBodyItemInfo(x));
 }

        /// <summary>
        /// Reads the values for this NPCChatDialogItemBase from an IValueReader.
        /// </summary>
        /// <param name="reader">IValueReader to read the values from.</param>
        protected void Read(IValueReader reader)
        {
            var id = reader.ReadNPCChatDialogItemID("ID");
            var title = reader.ReadString("Title");
            var text = reader.ReadString("Text");
            var isBranch = reader.ReadBool("IsBranch");

            var responses = reader.ReadManyNodes("Responses", CreateResponse);

            NPCChatConditionalCollectionBase conditionals = null;
            if (isBranch)
            {
                var cReader = reader.ReadNode("Conditionals");
                var hasConditionals = cReader.ReadBool("HasConditionals");
                if (hasConditionals)
                {
                    conditionals = CreateConditionalCollection();
                    if (conditionals != null)
                        conditionals.Read(cReader);
                }
            }

            SetReadValues(id, title, text, isBranch, responses, conditionals);

            AssertBranchHasTwoResponses();
            AssertNonBranchHasNoConditionals();
            AssertResponsesHaveValidValues();
        }