first commit

2026-09-03 04:45:36 +03:00
commit d5f52cc3d3
1038 changed files with 169579 additions and 0 deletions
@@ -0,0 +1,149 @@
+#region License
+
+// Copyright (C) 2020 Reetus
+// 
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace ClassicAssist.UO.Data
+{
+    public class Statics
+    {
+        private static string _dataPath;
+
+        private static readonly Lazy<StaticRecord[][]>[] _staticData = new Lazy<StaticRecord[][]>[6];
+
+        private static int[,] _defaultMapSize { get; } =
+        {
+            { 7168, 4096 }, { 7168, 4096 }, { 2304, 1600 }, { 2560, 2048 }, { 1448, 1448 }, { 1280, 4096 }
+        };
+
+        internal static void Initialize( string dataPath )
+        {
+            _dataPath = dataPath;
+
+            for ( int i = 0; i < 6; i++ )
+            {
+                int map = i;
+                _staticData[i] = new Lazy<StaticRecord[][]>( () => LoadStatics( map ) );
+            }
+        }
+
+        private static StaticRecord[][] LoadStatics( int map )
+        {
+            string staticIndexFile = Path.Combine( _dataPath, $"staidx{map}.mul" );
+            string staticMulFile = Path.Combine( _dataPath, $"statics{map}.mul" );
+
+            if ( !File.Exists( staticIndexFile ) )
+            {
+                return null;
+            }
+
+            if ( !File.Exists( staticMulFile ) )
+            {
+                return null;
+            }
+
+            byte[] indexBytes = File.ReadAllBytes( staticIndexFile );
+
+            StaticRecord[][] staticItems = new StaticRecord[indexBytes.Length / 12][];
+
+            using ( FileStream fileStream =
+                new FileStream( staticMulFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ) )
+            {
+                using ( BinaryReader binaryReader = new BinaryReader( fileStream ) )
+                {
+                    for ( int x = 0; x < indexBytes.Length / 12; x++ )
+                    {
+                        int offset = x * 12;
+                        int start = BitConverter.ToInt32( indexBytes, offset );
+                        int length = BitConverter.ToInt32( indexBytes, offset + 4 );
+
+                        if ( start == -1 )
+                        {
+                            continue;
+                        }
+
+                        fileStream.Seek( start, SeekOrigin.Begin );
+
+                        staticItems[x] = new StaticRecord[length / 7];
+
+                        for ( int y = 0; y < length / 7; y++ )
+                        {
+                            staticItems[x][y].ID = binaryReader.ReadUInt16();
+                            staticItems[x][y].X = binaryReader.ReadByte();
+                            staticItems[x][y].Y = binaryReader.ReadByte();
+                            staticItems[x][y].Z = binaryReader.ReadSByte();
+                            staticItems[x][y].Hue = binaryReader.ReadUInt16();
+                        }
+                    }
+                }
+            }
+
+            return staticItems;
+        }
+
+        public static StaticTile[] GetStatics( int map, int x, int y )
+        {
+            if ( _staticData?[map]?.Value == null )
+            {
+                return null;
+            }
+
+            int blockIndex = x / 8 * ( _defaultMapSize[map, 1] / 8 ) + y / 8;
+
+            int cellX = x % 8;
+            int cellY = y % 8;
+
+            StaticRecord[] blockStatics = _staticData[map].Value[blockIndex];
+
+            if ( blockStatics == null )
+            {
+                return null;
+            }
+
+            IEnumerable<StaticRecord> statics = blockStatics.Where( i => i.X == cellX && i.Y == cellY );
+
+            List<StaticTile> tiles = new List<StaticTile>();
+
+            foreach ( StaticRecord staticRecord in statics )
+            {
+                StaticTile tile = TileData.GetStaticTile( staticRecord.ID );
+                tile.X = x;
+                tile.Y = y;
+                tile.Z = staticRecord.Z;
+                tile.Hue = staticRecord.Hue;
+
+                tiles.Add( tile );
+            }
+
+            return tiles.ToArray();
+        }
+
+        private struct StaticRecord
+        {
+            public ushort ID { get; set; }
+            public byte X { get; set; }
+            public byte Y { get; set; }
+            public sbyte Z { get; set; }
+            public int Hue { get; set; }
+        }
+    }
+}