C# FileFormats.Map类代码示例

        public static int[,] Extract(Map m, Func<int, int, int> f)
        {
            var result = new int[m.MapSize, m.MapSize];
            var types = new int[m.MapSize, m.MapSize];
            var d = new Dictionary<int, Node>();
            var n = 1;

            for( var j = m.YOffset; j < m.YOffset + m.Height; j++ )
                for (var i = m.XOffset; i < m.XOffset + m.Width; i++)
                {
                    types[i, j] = f(i, j);

                    var k = n;

                    foreach (var a in Neighbors)
                        if (types[i + a.X, j + a.Y] == types[i, j])
                            k = (k == n)
                                ? result[i + a.X, j + a.Y]
                                : Union( d, k, result[i+a.X, j+a.Y] );

                    result[i,j] = k;
                    if (k == n) MakeSet(d, n++);
                }

            for (var j = m.YOffset; j < m.YOffset + m.Height; j++)
                for (var i = m.XOffset; i < m.XOffset + m.Width; i++)
                    result[i, j] = Find(d, result[i, j]);

            return result;
        }

        public TerrainRenderer(World world, WorldRenderer wr)
        {
            this.world = world;
            this.map = world.Map;

            var tileSize = new Size( Game.CellSize, Game.CellSize );
            var tileMapping = new Cache<TileReference<ushort,byte>, Sprite>(
                x => Game.modData.SheetBuilder.Add(world.TileSet.GetBytes(x), tileSize));

            var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];

            terrainSheet = tileMapping[map.MapTiles.Value[map.Bounds.Left, map.Bounds.Top]].sheet;

            int nv = 0;

            var terrainPalette = wr.Palette("terrain").Index;

            for( int j = map.Bounds.Top; j < map.Bounds.Bottom; j++ )
                for( int i = map.Bounds.Left; i < map.Bounds.Right; i++ )
                {
                    var tile = tileMapping[map.MapTiles.Value[i, j]];
                    // TODO: move GetPaletteIndex out of the inner loop.
                    Util.FastCreateQuad(vertices, Game.CellSize * new float2(i, j), tile, terrainPalette, nv, tile.size);
                    nv += 4;

                    if (tileMapping[map.MapTiles.Value[i, j]].sheet != terrainSheet)
                        throw new InvalidOperationException("Terrain sprites span multiple sheets");
                }

            vertexBuffer = Game.Renderer.Device.CreateVertexBuffer( vertices.Length );
            vertexBuffer.SetData( vertices, nv );
        }

        void MapList_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (MapList.SelectedItems.Count == 1)
            {
                txtNew.Text = MapList.SelectedItems[0].Text;
                txtNew.Tag = MapList.SelectedItems[0].Tag;

                var map = new Map(txtNew.Tag as string);
                txtTitle.Text = map.Title;
                txtAuthor.Text = map.Author;
                txtTheater.Text = map.Tileset;
                txtDesc.Text = map.Description;
                pbMinimap.Image = null;

                try
                {
                    pbMinimap.Image = Minimap.AddStaticResources(map, Minimap.TerrainBitmap(map, true));
                }
                catch (Exception ed)
                {
                    Console.WriteLine("No map preview image found: {0}", ed.ToString());
                }
                finally { }
            }
        }

        public UnitInfluence( World world )
        {
            map = world.Map;
            influence = new InfluenceNode[world.Map.MapSize.X, world.Map.MapSize.Y];

            world.ActorRemoved += a => Remove( a, a.TraitOrDefault<IOccupySpace>() );
        }

        public SmudgeRenderer( Renderer renderer, Map map )
        {
            this.spriteRenderer = new SpriteRenderer( renderer, true );
            this.map = map;

            smudgeSprites = smudgeSpriteNames.SelectMany(f => SpriteSheetBuilder.LoadAllSprites(f)).ToArray();
        }

 protected MapPreviewWidget(MapPreviewWidget other)
     : base(other)
 {
     lastMap = other.lastMap;
     Map = other.Map;
     SpawnColors = other.SpawnColors;
 }

        // Add the static resources defined in the map; if the map lives
        // in a world use AddCustomTerrain instead
        public static Bitmap AddStaticResources(Map map, Bitmap terrainBitmap)
        {
            Bitmap terrain = new Bitmap(terrainBitmap);
            var tileset = Rules.TileSets[map.Tileset];

            var bitmapData = terrain.LockBits(new Rectangle(0, 0, terrain.Width, terrain.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);

            unsafe
            {
                int* c = (int*)bitmapData.Scan0;

                for (var x = 0; x < map.Bounds.Width; x++)
                    for (var y = 0; y < map.Bounds.Height; y++)
                    {
                        var mapX = x + map.Bounds.Left;
                        var mapY = y + map.Bounds.Top;
                        if (map.MapResources.Value[mapX, mapY].type == 0)
                            continue;

                        var res = Rules.Info["world"].Traits.WithInterface<ResourceTypeInfo>()
                                .Where(t => t.ResourceType == map.MapResources.Value[mapX, mapY].type)
                                .Select(t => t.TerrainType).FirstOrDefault();
                        if (res == null)
                            continue;

                        *(c + (y * bitmapData.Stride >> 2) + x) = tileset.Terrain[res].Color.ToArgb();
                    }
            }
            terrain.UnlockBits(bitmapData);

            return terrain;
        }

		public void Bind(Map m, TileSet ts, Palette p)
		{
			Map = m;
			TileSet = ts;
			Palette = p;
			Brush = null;
			Chunks.Clear();
		}

		public void Bind(Map m, TileSet ts, Palette p)
		{
			Map = m;
			TileSet = ts;
			Palette = p;
			PlayerPalettes = null;
			Chunks.Clear();
			Tool = null;
		}

 public static Dictionary<int2, Color> GetSpawnColors(OrderManager orderManager, Map map)
 {
     var spawns = map.GetSpawnPoints();
     return orderManager.LobbyInfo.Clients
         .Where( c => c.SpawnPoint != 0 )
         .ToDictionary(
             c => spawns[c.SpawnPoint - 1],
             c => c.ColorRamp.GetColor(0));
 }

 public static Dictionary<int2, Session.Client> GetSpawnClients(OrderManager orderManager, Map map)
 {
     var spawns = map.GetSpawnPoints();
     return orderManager.LobbyInfo.Clients
         .Where(c => c.SpawnPoint != 0)
             .ToDictionary(
                 c => spawns[c.SpawnPoint - 1],
                 c => c);
 }

        internal MapChooserLogic(Widget widget, string initialMap, Action onExit, Action<Map> onSelect)
        {
            map = Game.modData.AvailableMaps[WidgetUtils.ChooseInitialMap(initialMap)];

            widget.Get<ButtonWidget>("BUTTON_OK").OnClick = () => { Ui.CloseWindow(); onSelect(map); };
            widget.Get<ButtonWidget>("BUTTON_CANCEL").OnClick = () => { Ui.CloseWindow(); onExit(); };

            scrollpanel = widget.Get<ScrollPanelWidget>("MAP_LIST");
            scrollpanel.ScrollVelocity = 40f;
            scrollpanel.Layout = new GridLayout(scrollpanel);

            itemTemplate = scrollpanel.Get<ScrollItemWidget>("MAP_TEMPLATE");

            var gameModeDropdown = widget.GetOrNull<DropDownButtonWidget>("GAMEMODE_FILTER");
            if (gameModeDropdown != null)
            {
                var selectableMaps = Game.modData.AvailableMaps.Where(m => m.Value.Selectable).ToList();
                var gameModes = selectableMaps
                    .GroupBy(m => m.Value.Type)
                    .Select(g => Pair.New(g.Key, g.Count())).ToList();

                // 'all game types' extra item
                gameModes.Insert(0, Pair.New(null as string, selectableMaps.Count()));

                Func<Pair<string, int>, string> showItem =
                    x => "{0} ({1})".F(x.First ?? "All Game Types", x.Second);

                Func<Pair<string, int>, ScrollItemWidget, ScrollItemWidget> setupItem = (ii, template) =>
                {
                    var item = ScrollItemWidget.Setup(template,
                        () => gameMode == ii.First,
                        () => { gameMode = ii.First; EnumerateMaps(onSelect); });
                    item.Get<LabelWidget>("LABEL").GetText = () => showItem(ii);
                    return item;
                };

                gameModeDropdown.OnClick = () =>
                    gameModeDropdown.ShowDropDown("LABEL_DROPDOWN_TEMPLATE", 210, gameModes, setupItem);

                gameModeDropdown.GetText = () => showItem(gameModes.First(m => m.First == gameMode));
            }

            var randomMapButton = widget.GetOrNull<ButtonWidget>("RANDOMMAP_BUTTON");
            if (randomMapButton != null)
            {
                randomMapButton.OnClick = () =>
                {
                    var kv = visibleMaps.Random(Game.CosmeticRandom);
                    map = kv.Value;
                    scrollpanel.ScrollToItem(kv.Key);
                };
                randomMapButton.IsDisabled = () => visibleMaps == null || visibleMaps.Count == 0;
            }

            EnumerateMaps(onSelect);
        }

        public static void UpgradeMap(string[] args)
        {
            var map = new Map(args[1]);
            var engineDate = Exts.ParseIntegerInvariant(args[2]);

            Game.modData = new ModData(map.RequiresMod);
            UpgradeWeaponRules(engineDate, ref map.WeaponDefinitions, null, 0);
            UpgradeActorRules(engineDate, ref map.RuleDefinitions, null, 0);
            map.Save(args[1]);
        }

 public static void Initialize( Map map )
 {
     exts = new[] {
         "." + map.Theater.Substring( 0, 3 ).ToLowerInvariant(),
         ".shp",
         ".tem",
         ".sno",
         ".int" };
     sprites = new Cache<string, Sprite[]>( LoadSprites );
 }

 protected MapPreviewWidget(MapPreviewWidget other)
     : base(other)
 {
     lastMap = other.lastMap;
     Map = other.Map;
     SpawnClients = other.SpawnClients;
     ShowSpawnPoints = other.ShowSpawnPoints;
     TooltipTemplate = other.TooltipTemplate;
     TooltipContainer = other.TooltipContainer;
     tooltipContainer = Lazy.New(() => Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
 }