Example #1
0
        private unsafe HuedTile[][][] ReadStaticBlock(int x, int y)
        {
            _reader.BaseStream.Seek(((x * _blockHeight) + y) * 12, SeekOrigin.Begin);

            int lookup = _reader.ReadInt32();
            int length = _reader.ReadInt32();

            if (lookup < 0 || length <= 0)
            {
                return _emptyStaticBlock;
            }

            int count = length / 7;

            _staticsStream.Seek(lookup, SeekOrigin.Begin);

            StaticTile[] staTiles = new StaticTile[count];

            fixed (StaticTile* pTiles = staTiles)
            {
                NativeMethods._lread(_staticsStream.SafeFileHandle, pTiles, length);

                if (_hueTileLists == null)
                {
                    _hueTileLists = new HuedTileList[8][];

                    for (int i = 0; i < 8; ++i)
                    {
                        _hueTileLists[i] = new HuedTileList[8];

                        for (int j = 0; j < 8; ++j)
                            _hueTileLists[i][j] = new HuedTileList();
                    }
                }

                HuedTileList[][] lists = _hueTileLists;

                StaticTile* pCur = pTiles, pEnd = pTiles + count;

                while (pCur < pEnd)
                {
                    lists[pCur->X & 0x7][pCur->Y & 0x7].Add((short)((pCur->Id & 0x3FFF) + 0x4000), pCur->Hue, pCur->Z);
                    ++pCur;
                }

                HuedTile[][][] tiles = new HuedTile[8][][];

                for (int i = 0; i < 8; ++i)
                {
                    tiles[i] = new HuedTile[8][];

                    for (int j = 0; j < 8; ++j)
                        tiles[i][j] = lists[i][j].ToArray();
                }

                return tiles;
            }
        }
Example #2
0
        private unsafe HuedTile[][][] ReadStaticBlock(int x, int y)
        {
            _reader.BaseStream.Seek(((x * _blockHeight) + y) * 12, SeekOrigin.Begin);

            int lookup = _reader.ReadInt32();
            int length = _reader.ReadInt32();

            if (lookup < 0 || length <= 0)
            {
                return(_emptyStaticBlock);
            }

            int count = length / 7;

            _staticsStream.Seek(lookup, SeekOrigin.Begin);

            StaticTile[] staTiles = new StaticTile[count];

            fixed(StaticTile *pTiles = staTiles)
            {
                NativeMethods._lread(_staticsStream.SafeFileHandle, pTiles, length);

                if (_hueTileLists == null)
                {
                    _hueTileLists = new HuedTileList[8][];

                    for (int i = 0; i < 8; ++i)
                    {
                        _hueTileLists[i] = new HuedTileList[8];

                        for (int j = 0; j < 8; ++j)
                        {
                            _hueTileLists[i][j] = new HuedTileList();
                        }
                    }
                }

                HuedTileList[][] lists = _hueTileLists;

                StaticTile *pCur = pTiles, pEnd = pTiles + count;

                while (pCur < pEnd)
                {
                    lists[pCur->X & 0x7][pCur->Y & 0x7].Add((short)((pCur->Id & 0x3FFF) + 0x4000), pCur->Hue, pCur->Z);
                    ++pCur;
                }

                HuedTile[][][] tiles = new HuedTile[8][][];

                for (int i = 0; i < 8; ++i)
                {
                    tiles[i] = new HuedTile[8][];

                    for (int j = 0; j < 8; ++j)
                    {
                        tiles[i][j] = lists[i][j].ToArray();
                    }
                }

                return(tiles);
            }
        }
Example #3
0
        private static unsafe int PatchStatics(TileMatrix matrix, string dataPath, string indexPath, string lookupPath)
        {
            using (FileStream fsData = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                using (FileStream fsIndex = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                    using (FileStream fsLookup = new FileStream(lookupPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        BinaryReader indexReader  = new BinaryReader(fsIndex);
                        BinaryReader lookupReader = new BinaryReader(fsLookup);

                        int count = (int)(indexReader.BaseStream.Length / 4);

                        HuedTileList[][] lists = new HuedTileList[8][];

                        for (int x = 0; x < 8; ++x)
                        {
                            lists[x] = new HuedTileList[8];

                            for (int y = 0; y < 8; ++y)
                            {
                                lists[x][y] = new HuedTileList();
                            }
                        }

                        for (int i = 0; i < count; ++i)
                        {
                            int blockID = indexReader.ReadInt32();
                            int blockX  = blockID / matrix.BlockHeight;
                            int blockY  = blockID % matrix.BlockHeight;

                            int offset = lookupReader.ReadInt32();
                            int length = lookupReader.ReadInt32();
                            lookupReader.ReadInt32(); // Extra

                            if (offset < 0 || length <= 0)
                            {
                                matrix.SetStaticBlock(blockX, blockY, matrix.EmptyStaticBlock);
                                continue;
                            }

                            fsData.Seek(offset, SeekOrigin.Begin);

                            int tileCount = length / 7;

                            StaticTile[] staTiles = new StaticTile[tileCount];

                            fixed(StaticTile *pTiles = staTiles)
                            {
                                NativeMethods._lread(fsData.SafeFileHandle, pTiles, length);

                                StaticTile *pCur = pTiles, pEnd = pTiles + tileCount;

                                while (pCur < pEnd)
                                {
                                    lists[pCur->X & 0x7][pCur->Y & 0x7].Add((short)((pCur->Id & 0x3FFF) + 0x4000), pCur->Hue, pCur->Z);
                                    ++pCur;
                                }

                                HuedTile[][][] tiles = new HuedTile[8][][];

                                for (int x = 0; x < 8; ++x)
                                {
                                    tiles[x] = new HuedTile[8][];

                                    for (int y = 0; y < 8; ++y)
                                    {
                                        tiles[x][y] = lists[x][y].ToArray();
                                    }
                                }

                                matrix.SetStaticBlock(blockX, blockY, tiles);
                            }
                        }

                        return(count);
                    }
        }
        private static unsafe int PatchStatics(TileMatrix matrix, string dataPath, string indexPath, string lookupPath)
        {
            using (FileStream fsData = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            using (FileStream fsIndex = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            using (FileStream fsLookup = new FileStream(lookupPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                BinaryReader indexReader = new BinaryReader(fsIndex);
                BinaryReader lookupReader = new BinaryReader(fsLookup);

                int count = (int)(indexReader.BaseStream.Length / 4);

                HuedTileList[][] lists = new HuedTileList[8][];

                for (int x = 0; x < 8; ++x)
                {
                    lists[x] = new HuedTileList[8];

                    for (int y = 0; y < 8; ++y)
                        lists[x][y] = new HuedTileList();
                }

                for (int i = 0; i < count; ++i)
                {
                    int blockID = indexReader.ReadInt32();
                    int blockX = blockID / matrix.BlockHeight;
                    int blockY = blockID % matrix.BlockHeight;

                    int offset = lookupReader.ReadInt32();
                    int length = lookupReader.ReadInt32();
                    lookupReader.ReadInt32(); // Extra

                    if (offset < 0 || length <= 0)
                    {
                        matrix.SetStaticBlock(blockX, blockY, matrix.EmptyStaticBlock);
                        continue;
                    }

                    fsData.Seek(offset, SeekOrigin.Begin);

                    int tileCount = length / 7;

                    StaticTile[] staTiles = new StaticTile[tileCount];

                    fixed (StaticTile* pTiles = staTiles)
                    {
                        NativeMethods._lread(fsData.SafeFileHandle, pTiles, length);

                        StaticTile* pCur = pTiles, pEnd = pTiles + tileCount;

                        while (pCur < pEnd)
                        {
                            lists[pCur->X & 0x7][pCur->Y & 0x7].Add((short)((pCur->Id & 0x3FFF) + 0x4000), pCur->Hue, pCur->Z);
                            ++pCur;
                        }

                        HuedTile[][][] tiles = new HuedTile[8][][];

                        for (int x = 0; x < 8; ++x)
                        {
                            tiles[x] = new HuedTile[8][];

                            for (int y = 0; y < 8; ++y)
                                tiles[x][y] = lists[x][y].ToArray();
                        }

                        matrix.SetStaticBlock(blockX, blockY, tiles);
                    }
                }

                return count;
            }
        }