コード例 #1
0
 public MultiComponentList(BinaryReader reader, int count)
 {
     this.m_Min = this.m_Max = Point.Empty;
       MultiComponentList.MultiTileEntry[] multiTileEntryArray = new MultiComponentList.MultiTileEntry[count];
       for (int index = 0; index < count; ++index)
       {
     multiTileEntryArray[index].m_ItemID = reader.ReadInt16();
     multiTileEntryArray[index].m_OffsetX = reader.ReadInt16();
     multiTileEntryArray[index].m_OffsetY = reader.ReadInt16();
     multiTileEntryArray[index].m_OffsetZ = reader.ReadInt16();
     multiTileEntryArray[index].m_Flags = reader.ReadInt32();
     MultiComponentList.MultiTileEntry multiTileEntry = multiTileEntryArray[index];
     if ((int) multiTileEntry.m_OffsetX < this.m_Min.X)
       this.m_Min.X = (int) multiTileEntry.m_OffsetX;
     if ((int) multiTileEntry.m_OffsetY < this.m_Min.Y)
       this.m_Min.Y = (int) multiTileEntry.m_OffsetY;
     if ((int) multiTileEntry.m_OffsetX > this.m_Max.X)
       this.m_Max.X = (int) multiTileEntry.m_OffsetX;
     if ((int) multiTileEntry.m_OffsetY > this.m_Max.Y)
       this.m_Max.Y = (int) multiTileEntry.m_OffsetY;
       }
       this.m_Center = new Point(-this.m_Min.X, -this.m_Min.Y);
       this.m_Width = this.m_Max.X - this.m_Min.X + 1;
       this.m_Height = this.m_Max.Y - this.m_Min.Y + 1;
       TileList[][] tileListArray = new TileList[this.m_Width][];
       this.m_Tiles = new Tile[this.m_Width][][];
       for (int index1 = 0; index1 < this.m_Width; ++index1)
       {
     tileListArray[index1] = new TileList[this.m_Height];
     this.m_Tiles[index1] = new Tile[this.m_Height][];
     for (int index2 = 0; index2 < this.m_Height; ++index2)
       tileListArray[index1][index2] = new TileList();
       }
       for (int index1 = 0; index1 < multiTileEntryArray.Length; ++index1)
       {
     int index2 = (int) multiTileEntryArray[index1].m_OffsetX + this.m_Center.X;
     int index3 = (int) multiTileEntryArray[index1].m_OffsetY + this.m_Center.Y;
     tileListArray[index2][index3].Add((short) (((int) multiTileEntryArray[index1].m_ItemID & 16383) + 16384), (sbyte) multiTileEntryArray[index1].m_OffsetZ);
       }
       for (int index1 = 0; index1 < this.m_Width; ++index1)
       {
     for (int index2 = 0; index2 < this.m_Height; ++index2)
     {
       this.m_Tiles[index1][index2] = tileListArray[index1][index2].ToArray();
       if (this.m_Tiles[index1][index2].Length > 1)
     Array.Sort((Array) this.m_Tiles[index1][index2]);
     }
       }
 }
コード例 #2
0
        public void Add(short id, sbyte z)
        {
            if (this.m_Count + 1 > (int)this.m_Tiles.Length)
            {
                Tile[] mTiles = this.m_Tiles;
                this.m_Tiles = new Tile[(int)mTiles.Length * 2];
                for (int i = 0; i < (int)mTiles.Length; i++)
                {
                    this.m_Tiles[i] = mTiles[i];
                }
            }
            Tile[]   tileArray = this.m_Tiles;
            TileList tileList  = this;
            int      mCount    = tileList.m_Count;
            int      num       = mCount;

            tileList.m_Count = mCount + 1;
            tileArray[num].Set(id, z);
        }
コード例 #3
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            m_Min = m_Max = Point.Empty;

            MultiTileEntry[] allTiles = new MultiTileEntry[count];

            for (int i = 0; i < count; ++i)
            {
                allTiles[i].m_ItemID  = reader.ReadInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();
                allTiles[i].m_Flags   = reader.ReadInt32();

                MultiTileEntry e = allTiles[i];

                if (e.m_OffsetX < m_Min.X)
                {
                    m_Min.X = e.m_OffsetX;
                }

                if (e.m_OffsetY < m_Min.Y)
                {
                    m_Min.Y = e.m_OffsetY;
                }

                if (e.m_OffsetX > m_Max.X)
                {
                    m_Max.X = e.m_OffsetX;
                }

                if (e.m_OffsetY > m_Max.Y)
                {
                    m_Max.Y = e.m_OffsetY;
                }
            }

            m_Center = new Point(-m_Min.X, -m_Min.Y);
            m_Width  = (m_Max.X - m_Min.X) + 1;
            m_Height = (m_Max.Y - m_Min.Y) + 1;

            TileList[][] tiles = new TileList[m_Width][];
            m_Tiles = new Tile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x]   = new TileList[m_Height];
                m_Tiles[x] = new Tile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                int xOffset = allTiles[i].m_OffsetX + m_Center.X;
                int yOffset = allTiles[i].m_OffsetY + m_Center.Y;

                tiles[xOffset][yOffset].Add((short)((allTiles[i].m_ItemID & 0x3FFF) + 0x4000), (sbyte)allTiles[i].m_OffsetZ);
            }

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();

                    if (m_Tiles[x][y].Length > 1)
                    {
                        Array.Sort(m_Tiles[x][y]);
                    }
                }
            }
        }
コード例 #4
0
ファイル: Multis.cs プロジェクト: greeduomacro/divinity
        public MultiComponentList( BinaryReader reader, int count )
        {
            m_Min = m_Max = Point.Empty;

            MultiTileEntry[] allTiles = new MultiTileEntry[count];

            for ( int i = 0; i < count; ++i )
            {
                allTiles[i].m_ItemID = reader.ReadInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();
                allTiles[i].m_Flags = reader.ReadInt32();

                MultiTileEntry e = allTiles[i];

                if ( e.m_OffsetX < m_Min.X )
                    m_Min.X = e.m_OffsetX;

                if ( e.m_OffsetY < m_Min.Y )
                    m_Min.Y = e.m_OffsetY;

                if ( e.m_OffsetX > m_Max.X )
                    m_Max.X = e.m_OffsetX;

                if ( e.m_OffsetY > m_Max.Y )
                    m_Max.Y = e.m_OffsetY;
            }

            m_Center = new Point( -m_Min.X, -m_Min.Y );
            m_Width = (m_Max.X - m_Min.X) + 1;
            m_Height = (m_Max.Y - m_Min.Y) + 1;

            TileList[][] tiles = new TileList[m_Width][];
            m_Tiles = new Tile[m_Width][][];

            for ( int x = 0; x < m_Width; ++x )
            {
                tiles[x] = new TileList[m_Height];
                m_Tiles[x] = new Tile[m_Height][];

                for ( int y = 0; y < m_Height; ++y )
                    tiles[x][y] = new TileList();
            }

            for ( int i = 0; i < allTiles.Length; ++i )
            {
                int xOffset = allTiles[i].m_OffsetX + m_Center.X;
                int yOffset = allTiles[i].m_OffsetY + m_Center.Y;

                tiles[xOffset][yOffset].Add( (short)((allTiles[i].m_ItemID & 0x3FFF) + 0x4000), (sbyte)allTiles[i].m_OffsetZ );
            }

            for ( int x = 0; x < m_Width; ++x )
            {
                for ( int y = 0; y < m_Height; ++y )
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();

                    if ( m_Tiles[x][y].Length > 1 )
                        Array.Sort( m_Tiles[x][y] );
                }
            }
        }
コード例 #5
0
 public MultiComponentList(BinaryReader reader, int count)
 {
     Point empty = Point.Empty;
     Point point = empty;
     this.m_Max = empty;
     this.m_Min = point;
     MultiComponentList.MultiTileEntry[] multiTileEntryArray = new MultiComponentList.MultiTileEntry[count];
     for (int i = 0; i < count; i++)
     {
         multiTileEntryArray[i].m_ItemID = reader.ReadInt16();
         multiTileEntryArray[i].m_OffsetX = reader.ReadInt16();
         multiTileEntryArray[i].m_OffsetY = reader.ReadInt16();
         multiTileEntryArray[i].m_OffsetZ = reader.ReadInt16();
         multiTileEntryArray[i].m_Flags = reader.ReadInt32();
         MultiComponentList.MultiTileEntry multiTileEntry = multiTileEntryArray[i];
         if (multiTileEntry.m_OffsetX < this.m_Min.X)
         {
             this.m_Min.X = multiTileEntry.m_OffsetX;
         }
         if (multiTileEntry.m_OffsetY < this.m_Min.Y)
         {
             this.m_Min.Y = multiTileEntry.m_OffsetY;
         }
         if (multiTileEntry.m_OffsetX > this.m_Max.X)
         {
             this.m_Max.X = multiTileEntry.m_OffsetX;
         }
         if (multiTileEntry.m_OffsetY > this.m_Max.Y)
         {
             this.m_Max.Y = multiTileEntry.m_OffsetY;
         }
     }
     this.m_Center = new Point(-this.m_Min.X, -this.m_Min.Y);
     this.m_Width = this.m_Max.X - this.m_Min.X + 1;
     this.m_Height = this.m_Max.Y - this.m_Min.Y + 1;
     TileList[][] tileList = new TileList[this.m_Width][];
     this.m_Tiles = new Tile[this.m_Width][][];
     for (int j = 0; j < this.m_Width; j++)
     {
         tileList[j] = new TileList[this.m_Height];
         this.m_Tiles[j] = new Tile[this.m_Height][];
         for (int k = 0; k < this.m_Height; k++)
         {
             tileList[j][k] = new TileList();
         }
     }
     for (int l = 0; l < (int)multiTileEntryArray.Length; l++)
     {
         int mOffsetX = multiTileEntryArray[l].m_OffsetX + this.m_Center.X;
         int mOffsetY = multiTileEntryArray[l].m_OffsetY + this.m_Center.Y;
         tileList[mOffsetX][mOffsetY].Add((short)((multiTileEntryArray[l].m_ItemID & 16383) + 16384), (sbyte)multiTileEntryArray[l].m_OffsetZ);
     }
     for (int m = 0; m < this.m_Width; m++)
     {
         for (int n = 0; n < this.m_Height; n++)
         {
             this.m_Tiles[m][n] = tileList[m][n].ToArray();
             if ((int)this.m_Tiles[m][n].Length > 1)
             {
                 Array.Sort(this.m_Tiles[m][n]);
             }
         }
     }
 }
コード例 #6
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            Point empty = Point.Empty;
            Point point = empty;

            this.m_Max = empty;
            this.m_Min = point;
            MultiComponentList.MultiTileEntry[] multiTileEntryArray = new MultiComponentList.MultiTileEntry[count];
            for (int i = 0; i < count; i++)
            {
                multiTileEntryArray[i].m_ItemID  = reader.ReadInt16();
                multiTileEntryArray[i].m_OffsetX = reader.ReadInt16();
                multiTileEntryArray[i].m_OffsetY = reader.ReadInt16();
                multiTileEntryArray[i].m_OffsetZ = reader.ReadInt16();
                multiTileEntryArray[i].m_Flags   = reader.ReadInt32();
                MultiComponentList.MultiTileEntry multiTileEntry = multiTileEntryArray[i];
                if (multiTileEntry.m_OffsetX < this.m_Min.X)
                {
                    this.m_Min.X = multiTileEntry.m_OffsetX;
                }
                if (multiTileEntry.m_OffsetY < this.m_Min.Y)
                {
                    this.m_Min.Y = multiTileEntry.m_OffsetY;
                }
                if (multiTileEntry.m_OffsetX > this.m_Max.X)
                {
                    this.m_Max.X = multiTileEntry.m_OffsetX;
                }
                if (multiTileEntry.m_OffsetY > this.m_Max.Y)
                {
                    this.m_Max.Y = multiTileEntry.m_OffsetY;
                }
            }
            this.m_Center = new Point(-this.m_Min.X, -this.m_Min.Y);
            this.m_Width  = this.m_Max.X - this.m_Min.X + 1;
            this.m_Height = this.m_Max.Y - this.m_Min.Y + 1;
            TileList[][] tileList = new TileList[this.m_Width][];
            this.m_Tiles = new Tile[this.m_Width][][];
            for (int j = 0; j < this.m_Width; j++)
            {
                tileList[j]     = new TileList[this.m_Height];
                this.m_Tiles[j] = new Tile[this.m_Height][];
                for (int k = 0; k < this.m_Height; k++)
                {
                    tileList[j][k] = new TileList();
                }
            }
            for (int l = 0; l < (int)multiTileEntryArray.Length; l++)
            {
                int mOffsetX = multiTileEntryArray[l].m_OffsetX + this.m_Center.X;
                int mOffsetY = multiTileEntryArray[l].m_OffsetY + this.m_Center.Y;
                tileList[mOffsetX][mOffsetY].Add((short)((multiTileEntryArray[l].m_ItemID & 16383) + 16384), (sbyte)multiTileEntryArray[l].m_OffsetZ);
            }
            for (int m = 0; m < this.m_Width; m++)
            {
                for (int n = 0; n < this.m_Height; n++)
                {
                    this.m_Tiles[m][n] = tileList[m][n].ToArray();
                    if ((int)this.m_Tiles[m][n].Length > 1)
                    {
                        Array.Sort(this.m_Tiles[m][n]);
                    }
                }
            }
        }
コード例 #7
0
 public MultiComponentList(BinaryReader reader, int count)
 {
     this.m_Min = this.m_Max = Point.Empty;
     MultiComponentList.MultiTileEntry[] multiTileEntryArray = new MultiComponentList.MultiTileEntry[count];
     for (int index = 0; index < count; ++index)
     {
         multiTileEntryArray[index].m_ItemID  = reader.ReadInt16();
         multiTileEntryArray[index].m_OffsetX = reader.ReadInt16();
         multiTileEntryArray[index].m_OffsetY = reader.ReadInt16();
         multiTileEntryArray[index].m_OffsetZ = reader.ReadInt16();
         multiTileEntryArray[index].m_Flags   = reader.ReadInt32();
         MultiComponentList.MultiTileEntry multiTileEntry = multiTileEntryArray[index];
         if ((int)multiTileEntry.m_OffsetX < this.m_Min.X)
         {
             this.m_Min.X = (int)multiTileEntry.m_OffsetX;
         }
         if ((int)multiTileEntry.m_OffsetY < this.m_Min.Y)
         {
             this.m_Min.Y = (int)multiTileEntry.m_OffsetY;
         }
         if ((int)multiTileEntry.m_OffsetX > this.m_Max.X)
         {
             this.m_Max.X = (int)multiTileEntry.m_OffsetX;
         }
         if ((int)multiTileEntry.m_OffsetY > this.m_Max.Y)
         {
             this.m_Max.Y = (int)multiTileEntry.m_OffsetY;
         }
     }
     this.m_Center = new Point(-this.m_Min.X, -this.m_Min.Y);
     this.m_Width  = this.m_Max.X - this.m_Min.X + 1;
     this.m_Height = this.m_Max.Y - this.m_Min.Y + 1;
     TileList[][] tileListArray = new TileList[this.m_Width][];
     this.m_Tiles = new Tile[this.m_Width][][];
     for (int index1 = 0; index1 < this.m_Width; ++index1)
     {
         tileListArray[index1] = new TileList[this.m_Height];
         this.m_Tiles[index1]  = new Tile[this.m_Height][];
         for (int index2 = 0; index2 < this.m_Height; ++index2)
         {
             tileListArray[index1][index2] = new TileList();
         }
     }
     for (int index1 = 0; index1 < multiTileEntryArray.Length; ++index1)
     {
         int index2 = (int)multiTileEntryArray[index1].m_OffsetX + this.m_Center.X;
         int index3 = (int)multiTileEntryArray[index1].m_OffsetY + this.m_Center.Y;
         tileListArray[index2][index3].Add((short)(((int)multiTileEntryArray[index1].m_ItemID & 16383) + 16384), (sbyte)multiTileEntryArray[index1].m_OffsetZ);
     }
     for (int index1 = 0; index1 < this.m_Width; ++index1)
     {
         for (int index2 = 0; index2 < this.m_Height; ++index2)
         {
             this.m_Tiles[index1][index2] = tileListArray[index1][index2].ToArray();
             if (this.m_Tiles[index1][index2].Length > 1)
             {
                 Array.Sort((Array)this.m_Tiles[index1][index2]);
             }
         }
     }
 }