示例#1
0
        public ISpriteRun SetPixels(IDataModel model, ModelDelta token, int page, int[,] pixels)
        {
            var data = Decompress(model, Start, allowLengthErrors: true);

            page %= Pages;

            var pageLength = SpriteFormat.TileWidth * SpriteFormat.TileHeight * 8 * SpriteFormat.BitsPerPixel;

            SpriteRun.SetPixels(data, page * pageLength, pixels, SpriteFormat.BitsPerPixel);

            var newModelData = Compress(data, 0, data.Length);
            var newRun       = (ISpriteRun)model.RelocateForExpansion(token, this, newModelData.Count);

            for (int i = 0; i < newModelData.Count; i++)
            {
                token.ChangeData(model, newRun.Start + i, newModelData[i]);
            }
            for (int i = newModelData.Count; i < Length; i++)
            {
                token.ChangeData(model, newRun.Start + i, 0xFF);
            }
            newRun = new LzSpriteRun(SpriteFormat, model, newRun.Start, newRun.PointerSources);
            model.ObserveRunWritten(token, newRun);
            return(newRun);
        }
示例#2
0
        public ISpriteRun SetPixels(IDataModel model, ModelDelta token, int page, int[,] pixels)
        {
            // TODO handle the fact that pixels[,] may contain a different number of tiles compared to the existing tileset
            var data = Decompress(model, Start);

            for (int x = 0; x < pixels.GetLength(0); x++)
            {
                for (int y = 0; y < pixels.GetLength(1); y++)
                {
                    pixels[x, y] %= (int)Math.Pow(2, TilesetFormat.BitsPerPixel);
                }
            }
            SpriteRun.SetPixels(data, 0, pixels, TilesetFormat.BitsPerPixel);
            var newModelData = Compress(data, 0, data.Length);
            var newRun       = model.RelocateForExpansion(token, this, newModelData.Count);

            for (int i = 0; i < newModelData.Count; i++)
            {
                token.ChangeData(model, newRun.Start + i, newModelData[i]);
            }
            for (int i = newModelData.Count; i < Length; i++)
            {
                token.ChangeData(model, newRun.Start + i, 0xFF);
            }
            newRun = new LzTilesetRun(TilesetFormat, model, newRun.Start, newRun.PointerSources);
            model.ObserveRunWritten(token, newRun);
            return(newRun);
        }
示例#3
0
        public static ITilesetRun SetPixels(ITilesetRun run, IDataModel model, ModelDelta token, IReadOnlyList <int[, ]> tiles, Func <int, SortedSpan <int>, ITilesetRun> construct)
        {
            var tileSize = 8 * run.TilesetFormat.BitsPerPixel;
            var data     = new byte[tiles.Count * tileSize];

            for (int i = 0; i < tiles.Count; i++)
            {
                SpriteRun.SetPixels(data, i * tileSize, tiles[i], run.TilesetFormat.BitsPerPixel);
            }

            var newModelData = Compress(data, 0, data.Length);
            var newRun       = model.RelocateForExpansion(token, run, newModelData.Count);

            for (int i = 0; i < newModelData.Count; i++)
            {
                token.ChangeData(model, newRun.Start + i, newModelData[i]);
            }
            for (int i = newModelData.Count; i < run.Length; i++)
            {
                token.ChangeData(model, newRun.Start + i, 0xFF);
            }
            newRun = construct(newRun.Start, newRun.PointerSources);
            model.ObserveRunWritten(token, newRun);
            return(newRun);
        }
        public static int[,] GetPixels(byte[] mapData, byte[] tiles, TilemapFormat format, int bytesPerTile)
        {
            var tileSize = format.BitsPerPixel * 8;
            var result   = new int[format.TileWidth * 8, format.TileHeight * 8];

            for (int y = 0; y < format.TileHeight; y++)
            {
                var yStart = y * 8;
                for (int x = 0; x < format.TileWidth; x++)
                {
                    var(pal, hFlip, vFlip, tile) = ReadTileData(mapData, format.TileWidth * y + x, bytesPerTile);

                    pal <<= 4;
                    var tileStart = tile * tileSize;
                    var pixels    = SpriteRun.GetPixels(tiles, tileStart, 1, 1, format.BitsPerPixel); // TODO cache this during this method so we don't load the same tile more than once
                    var xStart    = x * 8;
                    for (int yy = 0; yy < 8; yy++)
                    {
                        for (int xx = 0; xx < 8; xx++)
                        {
                            var inX = hFlip ? 7 - xx : xx;
                            var inY = vFlip ? 7 - yy : yy;
                            result[xStart + xx, yStart + yy] = pixels[inX, inY] + pal;
                        }
                    }
                }
            }

            return(result);
        }
示例#5
0
        public ISpriteRun SetPixels(IDataModel model, ModelDelta token, int[][,] tiles)
        {
            var tileSize = 8 * Format.BitsPerPixel;
            var data     = new byte[tiles.Length * tileSize];

            for (int i = 0; i < tiles.Length; i++)
            {
                SpriteRun.SetPixels(data, i * tileSize, tiles[i], Format.BitsPerPixel);
            }

            var newModelData = Compress(data, 0, data.Length);
            var newRun       = (LzTilesetRun)model.RelocateForExpansion(token, this, newModelData.Count);

            for (int i = 0; i < newModelData.Count; i++)
            {
                token.ChangeData(model, newRun.Start + i, newModelData[i]);
            }
            for (int i = newModelData.Count; i < Length; i++)
            {
                token.ChangeData(model, newRun.Start + i, 0xFF);
            }
            newRun = new LzTilesetRun(Format, model, newRun.Start, newRun.PointerSources);
            model.ObserveRunWritten(token, newRun);
            return(newRun);
        }
示例#6
0
        public int[,] GetPixels(IDataModel model, int page, int preferredTileWidth)
        {
            var data                = Decompress(model, Start);
            var tileSize            = TilesetFormat.BitsPerPixel * 8;
            var tileCount           = data.Length / tileSize;
            var preferredTileHeight = (int)Math.Ceiling((double)tileCount / preferredTileWidth);

            return(SpriteRun.GetPixels(data, 0, preferredTileWidth, preferredTileHeight, TilesetFormat.BitsPerPixel));
        }
示例#7
0
        public int[,] GetPixels(IDataModel model, int page)
        {
            var data = Decompress(model, Start, AllowLengthErrors);

            if (data == null)
            {
                return(null);
            }
            return(SpriteRun.GetPixels(data, SpriteFormat.ExpectedByteLength * page, SpriteFormat.TileWidth, SpriteFormat.TileHeight, SpriteFormat.BitsPerPixel));
        }
示例#8
0
        public int[,] GetPixels(IDataModel model, int page)
        {
            var(width, height) = (SpriteFormat.TileWidth, SpriteFormat.TileHeight);
            var data = new byte[Length];

            Array.Copy(model.RawData, Start, data, 0, Length);
            var pixels = SpriteRun.GetPixels(data, 0, width, height, TilesetFormat.BitsPerPixel);

            return(pixels);
        }
        public int[,] GetPixels(IDataModel model, int page)
        {
            var data = Decompress(model, Start);

            if (data == null)
            {
                return(null);
            }
            return(SpriteRun.GetPixels(data, 0, Width, Height, TilesetFormat.BitsPerPixel));
        }
示例#10
0
        public ISpriteRun SetPixels(IDataModel model, ModelDelta token, int page, int[,] pixels)
        {
            var data = new byte[Length];

            SpriteRun.SetPixels(data, 0, pixels, TilesetFormat.BitsPerPixel);
            for (int i = 0; i < Length; i++)
            {
                token.ChangeData(model, Start + i, data[i]);
            }
            return(this);
        }
示例#11
0
        public static IReadOnlyList <int[, ]> Tilize(byte[] rawData, int bitsPerPixel)
        {
            var results  = new List <int[, ]>();
            var tileSize = 8 * bitsPerPixel;

            for (int i = 0; i < rawData.Length; i += tileSize)
            {
                results.Add(SpriteRun.GetPixels(rawData, i, 1, 1, bitsPerPixel));
            }
            return(results);
        }
        public int[,] GetPixels(IDataModel model, int page)
        {
            var result = new int[Format.TileWidth * 8, Format.TileHeight * 8];

            var mapData        = Decompress(model, Start);
            var tilesetAddress = model.GetAddressFromAnchor(new NoDataChangeDeltaModel(), -1, Format.MatchingTileset);
            var tileset        = model.GetNextRun(tilesetAddress) as ISpriteRun;

            if (tileset == null)
            {
                tileset = model.GetNextRun(arrayTilesetAddress) as ISpriteRun;
            }

            if (tileset == null || !(tileset is LZRun))
            {
                return(result);                                     // relax the conditions slightly: if the run we found is an LZSpriteRun, that's close enough, we can use it as a tileset.
            }
            var tiles = Decompress(model, tileset.Start);

            var tileSize = tileset is LzTilesetRun lztsRun ? lztsRun.Format.BitsPerPixel * 8 : tileset.SpriteFormat.BitsPerPixel * 8;

            for (int y = 0; y < Format.TileHeight; y++)
            {
                var yStart = y * 8;
                for (int x = 0; x < Format.TileWidth; x++)
                {
                    var map  = mapData.ReadMultiByteValue((Format.TileWidth * y + x) * 2, 2);
                    var tile = map & 0x3FF;

                    var tileStart = tile * tileSize;
                    var pixels    = SpriteRun.GetPixels(tiles, tileStart, 1, 1, Format.BitsPerPixel); // TODO cache this during this method so we don't load the same tile more than once
                    var hFlip     = (map >> 10) & 0x1;
                    var vFlip     = (map >> 11) & 0x1;
                    var pal       = (map >> 12) & 0xF;
                    pal <<= 4;
                    var xStart = x * 8;
                    for (int yy = 0; yy < 8; yy++)
                    {
                        for (int xx = 0; xx < 8; xx++)
                        {
                            var inX = hFlip == 1 ? 7 - xx : xx;
                            var inY = vFlip == 1 ? 7 - yy : yy;
                            result[xStart + xx, yStart + yy] = pixels[inX, inY] + pal;
                        }
                    }
                }
            }

            return(result);
        }
        public int[,] GetPixels(IDataModel model, int page)
        {
            var data = Decompress(model, Start);

            return(SpriteRun.GetPixels(data, SpriteFormat.ExpectedByteLength * page, SpriteFormat.TileWidth, SpriteFormat.TileHeight, SpriteFormat.BitsPerPixel));
        }
示例#14
0
        public int[,] GetPixels(IDataModel model, int page)
        {
            var data = Decompress(model, Start);

            return(SpriteRun.GetPixels(data, 0, Width, Height, Format.BitsPerPixel));
        }