Exemplo n.º 1
0
        private 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 )
                            {
                                _lread( fsData.Handle, pTiles, length );

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

                                while ( pCur < pEnd )
                                {
                                    lists[pCur->m_X & 0x7][pCur->m_Y & 0x7].Add( (short)((pCur->m_ID & 0x3FFF) + 0x4000), pCur->m_Hue, pCur->m_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;
                    }
                }
            }
        }
Exemplo n.º 2
0
        private unsafe HuedTile[][][] ReadStaticBlock( int x, int y )
        {
            m_IndexReader.BaseStream.Seek( ((x * m_BlockHeight) + y) * 12, SeekOrigin.Begin );

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

            if ( lookup < 0 || length <= 0 )
            {
                return m_EmptyStaticBlock;
            }
            else
            {
                int count = length / 7;

                m_Statics.Seek( lookup, SeekOrigin.Begin );

                StaticTile[] staTiles = new StaticTile[count];

                fixed ( StaticTile *pTiles = staTiles )
                {
                    _lread( m_Statics.Handle, pTiles, length );

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

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

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

                    HuedTileList[][] lists = m_Lists;

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

                    while ( pCur < pEnd )
                    {
                        lists[pCur->m_X & 0x7][pCur->m_Y & 0x7].Add( (short)((pCur->m_ID & 0x3FFF) + 0x4000), pCur->m_Hue, pCur->m_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;
                }
            }
        }
Exemplo n.º 3
0
        private unsafe HuedTile[][][] ReadStaticBlock(int x, int y)
        {
            m_IndexReader.BaseStream.Seek(((x * m_BlockHeight) + y) * 12, SeekOrigin.Begin);

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

            if (lookup < 0 || length <= 0)
            {
                return(m_EmptyStaticBlock);
            }
            else
            {
                int count = length / 7;

                m_Statics.Seek(lookup, SeekOrigin.Begin);

                StaticTile[] staTiles = new StaticTile[count];

                fixed(StaticTile *pTiles = staTiles)
                {
                    _lread(m_Statics.Handle, pTiles, length);

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

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

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

                    HuedTileList[][] lists = m_Lists;

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

                    while (pCur < pEnd)
                    {
                        lists[pCur->m_X & 0x7][pCur->m_Y & 0x7].Add((short)((pCur->m_ID & 0x3FFF) + 0x4000), pCur->m_Hue, pCur->m_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);
                }
            }
        }