コード例 #1
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(this, x => x.ID, "id", string.Empty);
            serializer.DataField(this, x => x.Priority, "priority", 100);
            serializer.DataField(this, x => x.MinimumRequirements, "minimumRequirements", new float[Atmospherics.TotalNumberOfGases]);
            serializer.DataField(this, x => x.MinimumTemperatureRequirement, "minimumTemperature", Atmospherics.TCMB);
            serializer.DataField(this, x => x.MinimumEnergyRequirement, "minimumEnergy", 0f);
            serializer.DataField(ref _effects, "effects", new List <IGasReactionEffect>());
        }
コード例 #2
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _name, "name", string.Empty);
            serializer.DataField(ref _result, "result", string.Empty);
            serializer.DataField(ref _ingsReagents, "reagents", new Dictionary <string, int>());
            serializer.DataField(ref _ingsSolids, "solids", new Dictionary <string, int>());
            serializer.DataField(ref _cookTime, "time", 5);
        }
コード例 #3
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _name, "name", string.Empty);
            serializer.DataField(ref _description, "description", string.Empty);
            serializer.DataField <double>(ref _animationDuration, "animationDuration", 0);
            serializer.DataField(ref _spriteName, "spriteName", string.Empty);
            serializer.DataField(ref _startingInventory, "startingInventory", new Dictionary <string, uint>());
        }
コード例 #4
0
            public override object NodeToType(Type type, YamlNode node, YamlObjectSerializer serializer)
            {
                var args = node.ToString().Split(',');

                var b = float.Parse(args[0], CultureInfo.InvariantCulture);
                var l = float.Parse(args[1], CultureInfo.InvariantCulture);
                var t = float.Parse(args[2], CultureInfo.InvariantCulture);
                var r = float.Parse(args[3], CultureInfo.InvariantCulture);

                return(new Box2(l, b, r, t));
            }
コード例 #5
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _itemId, "itemId", string.Empty);
            serializer.DataField(ref _price, "price", 5);
            serializer.DataField(ref _category, "category", UplinkCategory.Utility);
            serializer.DataField(ref _desc, "description", string.Empty);
            serializer.DataField(ref _name, "listingName", string.Empty);
        }
コード例 #6
0
        public override void ExposeData(ObjectSerializer serializer)
        {
            if (!_didRegisterSerializer)
            {
                YamlObjectSerializer.RegisterTypeSerializer(typeof(AppearanceVisualizer),
                                                            new VisualizerTypeSerializer(_reflectionManager));
                _didRegisterSerializer = true;
            }

            serializer.DataField(ref Visualizers, "visuals", new List <AppearanceVisualizer>());
        }
コード例 #7
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _name, "name", string.Empty);
            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _description, "description", string.Empty);
            serializer.DataField(ref _icon, "icon", SpriteSpecifier.Invalid);
            serializer.DataField(ref _requiredPoints, "requiredpoints", 0);
            serializer.DataField(ref _requiredTechnologies, "requiredtechnologies", new List <string>());
            serializer.DataField(ref _unlockedRecipes, "unlockedrecipes", new List <string>());
        }
コード例 #8
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            _name = serializer.ReadDataField <string>("name");

            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _description, "description", string.Empty);
            serializer.DataField(ref _icon, "icon", SpriteSpecifier.Invalid);
            serializer.DataField(ref _result, "result", null);
            serializer.DataField(ref _hacked, "hacked", false);
            serializer.DataField(ref _latheType, "lathetype", "default");
        }
コード例 #9
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(this, x => ID, "id", string.Empty);
            serializer.DataField(this, x => Name, "name", string.Empty);
            serializer.DataField(this, x => OverlayPath, "overlayPath", string.Empty);
            serializer.DataField(this, x => SpecificHeat, "specificHeat", 0f);
            serializer.DataField(this, x => GasMolesVisible, "gasMolesVisible", 0.25f);
            serializer.DataField(this, x => GasOverlayTexture, "gasOverlayTexture", string.Empty);
            serializer.DataField(this, x => GasOverlaySprite, "gasOverlaySprite", string.Empty);
            serializer.DataField(this, x => GasOverlayState, "gasOverlayState", string.Empty);
        }
コード例 #10
0
        public void DeserializeFiveFlagTest()
        {
            // Arrange
            var data       = 0;
            var rootNode   = YamlObjectSerializer_Test.YamlTextToNode(SerializedFiveFlag);
            var serializer = YamlObjectSerializer.NewReader(rootNode);

            // Act
            serializer.DataField(ref data, "generic_flags", 0, WithFormat.Flags <GenericFlagTag>());

            // Assert
            Assert.That(data, Is.EqualTo((int)GenericFlags.Five));
        }
コード例 #11
0
        public void DeserializeLegacyFormatTest()
        {
            // Arrange
            var data       = 0;
            var rootNode   = YamlObjectSerializer_Test.YamlTextToNode(SerializedThree);
            var serializer = YamlObjectSerializer.NewReader(rootNode);

            // Act
            serializer.DataField(ref data, "generic_constants", 0, WithFormat.Constants <GenericConstantTag>());

            // Assert
            Assert.That(data, Is.EqualTo((int)GenericConstants.Three));
        }
コード例 #12
0
        public void DeserializeListAsReadOnlyCollectionTest()
        {
            // Arrange
            IReadOnlyCollection <int> data = null !;
            var rootNode   = YamlTextToNode(SerializedListYaml);
            var serializer = YamlObjectSerializer.NewReader(rootNode);

            // Act
            serializer.DataField(ref data, "datalist", Array.Empty <int>());

            // Assert
            Assert.That(data, Is.EquivalentTo(SerializableList));
        }
コード例 #13
0
        public void DeserializeZeroWithFlagTest()
        {
            // Arrange
            var data       = 0;
            var rootNode   = YamlObjectSerializer_Test.YamlTextToNode(SerializedZeroFlag);
            var serializer = YamlObjectSerializer.NewReader(rootNode);

            // Act
            serializer.DataField(ref data, "generic_flags_with_zero", 0, WithFormat.Flags <GenericFlagWithZeroTag>());

            // Assert
            Assert.That(data, Is.EqualTo(0));
        }
コード例 #14
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _name, "name", string.Empty);
            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _description, "description", string.Empty);
            serializer.DataField(ref _icon, "icon", SpriteSpecifier.Invalid);
            serializer.DataField(ref _product, "product", null);
            serializer.DataField(ref _pointCost, "cost", 0);
            serializer.DataField(ref _category, "category", string.Empty);
            serializer.DataField(ref _group, "group", string.Empty);
        }
コード例 #15
0
        public virtual void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataReadFunction("name", string.Empty,
                                        s => Name = FormattedMessage.FromMarkup(s));
            serializer.DataReadFunction("description", string.Empty,
                                        s => Description = FormattedMessage.FromMarkup(s));

            serializer.DataField(this, x => x.Requires, "requires", null);
            serializer.DataField(this, x => x.Icon, "icon", SpriteSpecifier.Invalid);
            serializer.DataField(this, x => x.IconOn, "iconOn", SpriteSpecifier.Invalid);

            // client needs to know what type of behavior it is even if the actual implementation is only
            // on server side. If we wanted to avoid this we'd need to always add a shared or clientside interface
            // for each action even if there was only server-side logic, which would be cumbersome
            serializer.DataField(this, x => x.BehaviorType, "behaviorType", BehaviorType.None);
            if (BehaviorType == BehaviorType.None)
            {
                Logger.ErrorS("action", "Missing behaviorType for action with name {0}", Name);
            }

            if (BehaviorType != BehaviorType.Toggle && IconOn != SpriteSpecifier.Invalid)
            {
                Logger.ErrorS("action", "for action {0}, iconOn was specified but behavior" +
                              " type was {1}. iconOn is only supported for Toggle behavior type.", Name);
            }

            serializer.DataField(this, x => x.Repeat, "repeat", false);
            if (Repeat && BehaviorType != BehaviorType.TargetEntity && BehaviorType != BehaviorType.TargetPoint)
            {
                Logger.ErrorS("action", " action named {0} used repeat: true, but this is only supported for" +
                              " TargetEntity and TargetPoint behaviorType and its behaviorType is {1}",
                              Name, BehaviorType);
            }

            serializer.DataField(this, x => x.DeselectOnCooldown, "deselectOnCooldown", false);
            serializer.DataField(this, x => x.DeselectWhenEntityNotClicked, "deselectWhenEntityNotClicked", false);

            serializer.DataReadFunction("filters", new List <string>(),
                                        rawTags =>
            {
                Filters = rawTags.Select(rawTag => rawTag.Trim()).ToList();
            });

            serializer.DataReadFunction("keywords", new List <string>(),
                                        rawTags =>
            {
                Keywords = rawTags.Select(rawTag => rawTag.Trim()).ToList();
            });
        }
コード例 #16
0
        public void SerializedEqualDictTest()
        {
            var dict = new Dictionary <string, string>
            {
                ["A"] = "B",
                ["C"] = "W",
                ["D"] = "G",
                ["E"] = "J"
            };

            var dict2 = new Dictionary <string, string>(dict);

            Assert.That(YamlObjectSerializer.IsSerializedEqual(dict, dict2), Is.True);
        }
コード例 #17
0
        public void SerializeListAsReadOnlyCollectionTest()
        {
            // Arrange
            IReadOnlyCollection <int> data = SerializableList;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "datalist", Array.Empty <int>());

            // Assert
            var result = NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedListYaml));
        }
コード例 #18
0
        public void SerializeZeroWithoutFlagTest()
        {
            // Arrange
            var data       = 0;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "generic_flags", 0, WithFormat.Flags <GenericFlagTag>(), alwaysWrite: true);

            // Assert
            var result = YamlObjectSerializer_Test.NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedZeroNum));
        }
コード例 #19
0
        public void SerializeTypeTest()
        {
            ITestType?type    = new TestTypeOne();
            var       mapping = new YamlMappingNode();
            var       writer  = YamlObjectSerializer.NewWriter(mapping);

            writer.DataField(ref type, "type", null !);

            Assert.IsNotEmpty(mapping.Children);
            Assert.IsInstanceOf <YamlScalarNode>(mapping.Children[0].Key);

            var scalar = (YamlScalarNode)mapping.Children[0].Key;

            Assert.That(scalar.Value, Is.EqualTo("type"));
        }
コード例 #20
0
        public void SerializeNonZeroWithZeroFlagDoesntShowZeroTest()
        {
            // Arrange
            var data       = (int)FlagsWithZero.Two;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "generic_flags_with_zero", 0, WithFormat.Flags <GenericFlagWithZeroTag>());

            // Assert
            var result = YamlObjectSerializer_Test.NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedTwoWithZeroFlag));
        }
コード例 #21
0
            public override YamlNode TypeToNode(object obj, YamlObjectSerializer serializer)
            {
                switch (obj)
                {
                case SpriteSpecifier.Texture tex:
                    return(tex.TexturePath.ToString());

                case SpriteSpecifier.Rsi rsi:
                    var mapping = new YamlMappingNode();
                    mapping.Add("sprite", rsi.RsiPath.ToString());
                    mapping.Add("state", rsi.RsiState);
                    return(mapping);
                }
                throw new NotImplementedException();
            }
コード例 #22
0
        public void SerializeOneConstantTest()
        {
            // Arrange
            var data       = (int)GenericConstants.One;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "generic_constants", 0, WithFormat.Constants <GenericConstantTag>());

            // Assert
            var result = YamlObjectSerializer_Test.NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedOneConstant));
        }
コード例 #23
0
        public virtual void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _coefficients, "coefficients", null);
            serializer.DataField(ref _flatReductions, "flatReductions", null);

            Resistances = new Dictionary <DamageType, ResistanceSetSettings>();
            foreach (var damageType in (DamageType[])Enum.GetValues(typeof(DamageType)))
            {
                Resistances.Add(damageType,
                                new ResistanceSetSettings(_coefficients[damageType], _flatReductions[damageType]));
            }
        }
コード例 #24
0
        public void SerializeFiveFlagTest()
        {
            // Arrange
            var data       = (int)GenericFlags.Five;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "generic_flags", 0, WithFormat.Flags <GenericFlagTag>());

            // Assert
            var result = YamlObjectSerializer_Test.NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedOneFourFlag));
        }
コード例 #25
0
        public void DeserializeExpressionTest()
        {
            var dummy = new DummyClass();

            var rootNode   = YamlTextToNode("foo: 5\nbar: \"baz\"");
            var serializer = YamlObjectSerializer.NewReader(rootNode);

            serializer.DataField(dummy, d => d.Foo, "foo", 4);
            serializer.DataField(dummy, d => d.Bar, "bar", "honk");
            serializer.DataField(dummy, d => d.Baz, "baz", Color.Black);

            Assert.That(dummy.Foo, Is.EqualTo(5));
            Assert.That(dummy.Bar, Is.EqualTo("baz"));
            Assert.That(dummy.Baz, Is.EqualTo(Color.Black));
        }
コード例 #26
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var srz = YamlObjectSerializer.NewReader(mapping);
            ID = srz.ReadDataField<string>("id");
            Name = Loc.GetString(srz.ReadDataField<string>("name"));
            StartingGear = srz.ReadDataField<string>("startingGear");
            Departments = srz.ReadDataField<List<string>>("departments");
            TotalPositions = srz.ReadDataField<int>("positions");

            srz.DataField(this, p => p.SpawnPositions, "spawnPositions", TotalPositions);
            srz.DataField(this, p => p.IsHead, "head", false);
            srz.DataField(this, p => p.Access, "access", Array.Empty<string>());
            srz.DataField(this, p => p.Icon, "icon", string.Empty);
            srz.DataField(this, p => p.Special, "special", null);
        }
コード例 #27
0
        public void SerializeDictTest()
        {
            // Arrange
            var data       = SerializableDict;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "datadict", new Dictionary <string, int>(0));

            // Assert
            var result = NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedDictYaml));
        }
コード例 #28
0
        public void SerializeListTest()
        {
            // Arrange
            var data       = SerializableList;
            var mapping    = new YamlMappingNode();
            var serializer = YamlObjectSerializer.NewWriter(mapping);

            // Act
            serializer.DataField(ref data, "datalist", new List <int>(0));

            // Assert
            var result = NodeToYamlText(mapping);

            Assert.That(result, Is.EqualTo(SerializedListYaml));
        }
コード例 #29
0
        public void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(this, x => ID, "id", string.Empty);
            serializer.DataField(this, x => Name, "name", string.Empty);
            serializer.DataField(this, x => OverlayPath, "overlayPath", string.Empty);
            serializer.DataField(this, x => SpecificHeat, "specificHeat", 0f);
            serializer.DataField(this, x => HeatCapacityRatio, "heatCapacityRatio", 1.4f);
            serializer.DataField(this, x => MolarMass, "molarMass", 1f);
            serializer.DataField(this, x => GasMolesVisible, "gasMolesVisible", 0.25f);
            serializer.DataField(this, x => GasOverlayTexture, "gasOverlayTexture", string.Empty);
            serializer.DataField(this, x => GasOverlaySprite, "gasOverlaySprite", string.Empty);
            serializer.DataField(this, x => GasOverlayState, "gasOverlayState", string.Empty);
            serializer.DataField(this, x => Color, "color", string.Empty);
        }
コード例 #30
0
        public virtual void LoadFrom(YamlMappingNode mapping)
        {
            var serializer = YamlObjectSerializer.NewReader(mapping);

            serializer.DataField(ref _id, "id", string.Empty);
            serializer.DataField(ref _name, "name", string.Empty);
            serializer.DataField(ref _description, "description", string.Empty);
            serializer.DataField(ref _examineMessage, "examineMessage", string.Empty);
            serializer.DataField(ref _rsiPath, "rsiPath", string.Empty);
            serializer.DataField(ref _rsiState, "rsiState", string.Empty);
            serializer.DataField(ref _durability, "durability", 0);
            serializer.DataField(ref _destroyThreshold, "destroyThreshold", 0);
            serializer.DataField(ref _resistance, "resistance", 0);
            serializer.DataField(ref _size, "size", 2);
            serializer.DataField(ref _compatibility, "compatibility", BodyPartCompatibility.Universal);
        }