C# FileFormats.MiniYaml類代碼示例

        static void LoadSequencesForCursor(string cursorSrc, MiniYaml cursor)
        {
            Game.modData.LoadScreen.Display();

            foreach (var sequence in cursor.Nodes)
                cursors.Add(sequence.Key, new CursorSequence(cursorSrc, cursor.Value, sequence.Value));
        }

 public MappedImage(string defaultSrc, MiniYaml info)
 {
     FieldLoader.LoadField(this, "rect", info.Value);
     FieldLoader.Load(this, info);
     if (src == null)
         src = defaultSrc;
 }

        public Manifest(string[] mods)
        {
            Mods = mods;
            var yaml = new MiniYaml(null, mods
                .Select(m => MiniYaml.FromFile("mods/" + m + "/mod.yaml"))
                .Aggregate(MiniYaml.MergeLiberal)).NodesDict;

            // TODO: Use fieldloader
            Folders = YamlList(yaml, "Folders");
            Packages = YamlList(yaml, "Packages");
            Rules = YamlList(yaml, "Rules");
            ServerTraits = YamlList(yaml, "ServerTraits");
            Sequences = YamlList(yaml, "Sequences");
            Cursors = YamlList(yaml, "Cursors");
            Chrome = YamlList(yaml, "Chrome");
            Assemblies = YamlList(yaml, "Assemblies");
            ChromeLayout = YamlList(yaml, "ChromeLayout");
            Weapons = YamlList(yaml, "Weapons");
            Voices = YamlList(yaml, "Voices");
            Notifications = YamlList(yaml, "Notifications");
            Music = YamlList(yaml, "Music");
            Movies = YamlList(yaml, "Movies");
            TileSets = YamlList(yaml, "TileSets");
            ChromeMetrics = YamlList(yaml, "ChromeMetrics");

            LoadScreen = yaml["LoadScreen"];
            Fonts = yaml["Fonts"].NodesDict.ToDictionary(x => x.Key,
                x => Pair.New(x.Value.NodesDict["Font"].Value,
                    int.Parse(x.Value.NodesDict["Size"].Value)));

            if (yaml.ContainsKey("TileSize"))
                TileSize = int.Parse(yaml["TileSize"].Value);
        }

        public Sequence(string unit, string name, MiniYaml info)
        {
            var srcOverride = info.Value;
            Name = name;
            var d = info.NodesDict;

            sprites = Game.modData.SpriteLoader.LoadAllSprites(srcOverride ?? unit);
            start = int.Parse(d["Start"].Value);

            if (!d.ContainsKey("Length"))
                length = 1;
            else if (d["Length"].Value == "*")
                length = sprites.Length - Start;
            else
                length = int.Parse(d["Length"].Value);

            if(d.ContainsKey("Facings"))
                facings = int.Parse(d["Facings"].Value);
            else
                facings = 1;

            if(d.ContainsKey("Tick"))
                tick = int.Parse(d["Tick"].Value);
            else
                tick = 40;

            if (start < 0 || start + facings * length > sprites.Length)
                throw new InvalidOperationException(
                    "{6}: Sequence {0}.{1} uses frames [{2}..{3}] of SHP `{4}`, but only 0..{5} actually exist"
                    .F(unit, name, start, start + facings * length - 1, srcOverride ?? unit, sprites.Length - 1,
                    info.Nodes[0].Location));
        }

 static IEnumerable<MiniYaml> GetInheritanceChain(MiniYaml node, Dictionary<string, MiniYaml> allUnits)
 {
     while (node != null)
     {
         yield return node;
         node = GetParent(node, allUnits);
     }
 }

 static Dictionary<string, string[]> Load( MiniYaml y, string name )
 {
     return y.NodesDict.ContainsKey( name )
         ? y.NodesDict[ name ].NodesDict.ToDictionary(
             a => a.Key,
             a => FieldLoader.GetValue<string[]>( "(value)", a.Value.Value ) )
         : new Dictionary<string, string[]>();
 }

 static void LoadSequencesForUnit(string unit, MiniYaml sequences)
 {
     Game.modData.LoadScreen.Display();
     try {
         var seq = sequences.NodesDict.ToDictionary(x => x.Key, x => new Sequence(unit,x.Key,x.Value));
         units.Add(unit, seq);
     } catch (FileNotFoundException) {} // Do nothing; we can crash later if we actually wanted art
 }

        public ActorInfo( string name, MiniYaml node, Dictionary<string, MiniYaml> allUnits )
        {
            var mergedNode = MergeWithParent( node, allUnits ).NodesDict;

            Name = name;
            foreach( var t in mergedNode )
                if( t.Key != "Inherits" && !t.Key.StartsWith("-") )
                    Traits.Add( LoadTraitInfo( t.Key.Split('@')[0], t.Value ) );
        }

 static object LoadWaypoints( MiniYaml y )
 {
     var ret = new Dictionary<string, int2>();
     foreach( var wp in y.NodesDict[ "Waypoints" ].NodesDict )
     {
         string[] loc = wp.Value.Value.Split( ',' );
         ret.Add( wp.Key, new int2( int.Parse( loc[ 0 ] ), int.Parse( loc[ 1 ] ) ) );
     }
     return ret;
 }

 public MiniYaml Save()
 {
     var ret = new MiniYaml( Type );
     foreach( var init in InitDict )
     {
         var initName = init.GetType().Name;
         ret.Nodes.Add( initName.Substring( 0, initName.Length - 4 ), FieldSaver.Save( init ) );
     }
     return ret;
 }

		public MusicInfo(string key, MiniYaml value)
		{
			Title = value.Value;

			var nd = value.ToDictionary();
			if (nd.ContainsKey("Hidden"))
				bool.TryParse(nd["Hidden"].Value, out Hidden);

			var ext = nd.ContainsKey("Extension") ? nd["Extension"].Value : "aud";
			Filename = (nd.ContainsKey("Filename") ? nd["Filename"].Value : key) + "." + ext;
		}

        public VoiceInfo( MiniYaml y )
        {
            FieldLoader.Load( this, y );
            Variants = Load(y, "Variants");
            Voices = Load(y, "Voices");

            if (!Voices.ContainsKey("Attack"))
                Voices.Add("Attack", Voices["Move"]);

            Pools = Lazy.New(() => Voices.ToDictionary( a => a.Key, a => new VoicePool(a.Value) ));
        }

        public MusicInfo( string key, MiniYaml value )
        {
            Filename = key+".aud";
            Title = value.Value;

            if (!FileSystem.Exists(Filename))
                return;

            Exists = true;
            Length = (int)AudLoader.SoundLength(FileSystem.Open(Filename));
        }

        public SoundInfo( MiniYaml y )
        {
            FieldLoader.Load( this, y );
            Variants = Load(y, "Variants");
            Prefixes = Load(y, "Prefixes");
            Voices = Load(y, "Voices");
            Notifications = Load(y, "Notifications");

            VoicePools = Lazy.New(() => Voices.ToDictionary( a => a.Key, a => new SoundPool(a.Value) ));
            NotificationsPools = Lazy.New(() => Notifications.ToDictionary( a => a.Key, a => new SoundPool(a.Value) ));
        }

        public static void Initialize(string[] sequenceFiles)
        {
            cursors = new Dictionary<string, CursorSequence>();
            var sequences = new MiniYaml(null, sequenceFiles.Select(s => MiniYaml.FromFile(s)).Aggregate(MiniYaml.MergeLiberal));

            foreach (var s in sequences.NodesDict["Palettes"].Nodes)
                Game.modData.Palette.AddPalette(s.Key, new Palette(FileSystem.Open(s.Value.Value), false));

            foreach (var s in sequences.NodesDict["Cursors"].Nodes)
                LoadSequencesForCursor(s.Key, s.Value);
        }