warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(core): Updates to serialization (#590)

Browse source 
- [X] Adds `AdhocPersistence` which replaces RunUO `Persistence`
- [X] Fixes a few minor bugs with EntityPersistence deserialization
- [X] Reverts/updates some serialization changes
This commit is contained in:
Kamron Batman 2021-05-09 00:10:39 -07:00 • committed by GitHub
parent f0969223f7
commit 6e9477ea13
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
18 changed files with 370 additions and 248 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Projects/Server/Buffers/CircularBufferWriter.cs
View file

@ -17,7 +17,6 @@ using System.Buffers.Binary;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using Server.Network;
using Server.Text;
namespace System.Buffers

10
Projects/Server/Buffers/SpanReader.cs
View file

@ -172,7 +172,6 @@ namespace System.Buffers
var remaining = Remaining;
int size;
if (isFixedLength)
{
size = fixedLength * sizeT;
@ -183,13 +182,14 @@ namespace System.Buffers
}
else
{
// In case the remaining is not evenly divisible
size = remaining - (remaining & (sizeT - 1));
int index = _buffer.Slice(Position, size).IndexOfTerminator(sizeT);
size = index < 0 ? size : index;
}
int index = _buffer.Slice(Position, size).IndexOfTerminator(sizeT);
var span = _buffer.Slice(Position, index < 0 ? size : index);
Position += isFixedLength || index < 0 ? size : index + sizeT;
var span = _buffer.Slice(Position, size);
Position += size;
return TextEncoding.GetString(span, encoding, safeString);
}

1
Projects/Server/Buffers/SpanWriter.cs
View file

@ -21,7 +21,6 @@ using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Toolkit.HighPerformance;
using Server.Network;
using Server.Text;
namespace System.Buffers

1
Projects/Server/Buffers/ValueStringBuilder.cs
View file

@ -6,7 +6,6 @@ using System.Buffers;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Server.Network;
namespace Server.Buffers
{

66
Projects/Server/Serial.cs
View file

@ -1,3 +1,18 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2021 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: Serial.cs *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Runtime.CompilerServices;
@ -12,54 +27,73 @@ namespace Server
public uint Value { get; }
public bool IsMobile => Value > 0 && Value < World.ItemOffset;
public bool IsMobile
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => Value > 0 && Value < World.ItemOffset;
}
public bool IsItem => Value >= World.ItemOffset && Value < World.MaxItemSerial;
public bool IsItem
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => Value >= World.ItemOffset && Value < World.MaxItemSerial;
}
public bool IsValid => Value > 0;
public bool IsValid
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => this != MinusOne;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() => Value.GetHashCode();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int CompareTo(Serial other) => Value.CompareTo(other.Value);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int CompareTo(uint other) => Value.CompareTo(other);
public override bool Equals(object obj)
{
if (obj is Serial serial)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override bool Equals(object obj) =>
obj switch
{
return this == serial;
}
if (obj is uint u)
{
return Value == u;
}
return false;
}
Serial serial => this == serial,
uint u => Value == u,
_ => false
};
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(Serial l, Serial r) => l.Value == r.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(Serial l, Serial r) => l.Value != r.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator >(Serial l, Serial r) => l.Value > r.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator <(Serial l, Serial r) => l.Value < r.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator >=(Serial l, Serial r) => l.Value >= r.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator <=(Serial l, Serial r) => l.Value <= r.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString() => $"0x{Value:X8}";
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator uint(Serial a) => a.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Serial(uint a) => new(a);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(Serial other) => Value == other.Value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int ToInt32() => (int)Value;
}
}

59
Projects/Server/Serialization/AdhocPersistence.cs Normal file
View file

@ -0,0 +1,59 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2021 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: AdhocPersistence.cs *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.IO;
namespace Server
{
public static class AdhocPersistence
{
public static void Serialize(string filePath, Action<IGenericWriter> serializer)
{
var fullPath = Path.Combine(Core.BaseDirectory, filePath);
var file = new FileInfo(fullPath);
file.Directory?.Create();
using var bin = new BinaryFileWriter(fullPath, true);
serializer(bin);
}
public static void Deserialize(string filePath, Action<IGenericReader> deserializer)
{
var fullPath = Path.Combine(Core.BaseDirectory, filePath);
var file = new FileInfo(fullPath);
file.Directory?.Create();
if (!file.Exists)
{
return;
}
try
{
using FileStream fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
using var br = new BinaryFileReader(fs);
deserializer(br);
}
catch (Exception e)
{
Utility.PushColor(ConsoleColor.Red);
Console.WriteLine($"***** Bad deserialize of {file.FullName} *****");
Console.WriteLine(e.ToString());
Utility.PopColor();
}
}
}
}

111
Projects/Server/Serialization/BinaryFileReader.cs Normal file
View file

@ -0,0 +1,111 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2021 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: BinaryFileReader.cs *
* *
* 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.IO;
using System.Net;
namespace Server
{
public class BinaryFileReader : IGenericReader, IDisposable
{
private readonly BinaryReader _reader;
public BinaryFileReader(BinaryReader br) => _reader = br;
public BinaryFileReader(Stream stream) => _reader = new BinaryReader(stream);
public void Close() => _reader.Close();
public string ReadString(bool intern = false)
{
var str = _reader.ReadString();
return intern ? Utility.Intern(str) : str;
}
public DateTime ReadDateTime() => new(_reader.ReadInt64(), DateTimeKind.Utc);
public TimeSpan ReadTimeSpan() => new(_reader.ReadInt64());
public DateTime ReadDeltaTime() => new(_reader.ReadInt64() + DateTime.UtcNow.Ticks, DateTimeKind.Utc);
public decimal ReadDecimal() => _reader.ReadDecimal();
public long ReadLong() => _reader.ReadInt64();
public ulong ReadULong() => _reader.ReadUInt64();
public int ReadInt() => _reader.ReadInt32();
public uint ReadUInt() => _reader.ReadUInt32();
public short ReadShort() => _reader.ReadInt16();
public ushort ReadUShort() => _reader.ReadUInt16();
public double ReadDouble() => _reader.ReadDouble();
public float ReadFloat() => _reader.ReadSingle();
public byte ReadByte() => _reader.ReadByte();
public sbyte ReadSByte() => _reader.ReadSByte();
public bool ReadBool() => _reader.ReadBoolean();
public int ReadEncodedInt()
{
int v = 0, shift = 0;
byte b;
do
{
b = _reader.ReadByte();
v |= (b & 0x7F) << shift;
shift += 7;
}
while (b >= 0x80);
return v;
}
public IPAddress ReadIPAddress()
{
byte length = ReadByte();
// Either 2 ushorts, or 8 ushorts
Span<byte> integer = stackalloc byte[length];
Read(integer);
return Utility.Intern(new IPAddress(integer));
}
public Point3D ReadPoint3D() => new(ReadInt(), ReadInt(), ReadInt());
public Point2D ReadPoint2D() => new(ReadInt(), ReadInt());
public Rectangle2D ReadRect2D() => new(ReadPoint2D(), ReadPoint2D());
public Rectangle3D ReadRect3D() => new(ReadPoint3D(), ReadPoint3D());
public Map ReadMap() => Map.Maps[ReadByte()];
public Race ReadRace() => Race.Races[ReadByte()];
public int Read(Span<byte> buffer) => _reader.Read(buffer);
public long Seek(long offset, SeekOrigin origin) => _reader.BaseStream.Seek(offset, origin);
public void Dispose() => Close();
}
}

5
Projects/Server/Serialization/BinaryFileWriter.cs
View file

@ -66,9 +66,6 @@ namespace Server
return _position = _file.Seek(offset, origin);
}
public void Dispose()
{
Close();
}
public void Dispose() => Close();
}
}

182
Projects/Server/Serialization/BufferReader.cs
View file

@ -15,14 +15,10 @@
using System;
using System.Buffers.Binary;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text;
using Server.Guilds;
using Server.Network;
using Server.Text;
namespace Server
@ -33,25 +29,23 @@ namespace Server
private byte[] _buffer;
private int _position;
public int Position => _position;
public long Position => _position;
public byte[] Buffer => _buffer;
public BufferReader(byte[] buffer)
public BufferReader(byte[] buffer, Encoding encoding = null)
{
_buffer = buffer;
_encoding = TextEncoding.UTF8;
_encoding = encoding ?? TextEncoding.UTF8;
}
public void SwapBuffers(byte[] newBuffer, out byte[] oldBuffer)
public void Reset(byte[] newBuffer, out byte[] oldBuffer)
{
oldBuffer = _buffer;
_buffer = newBuffer;
_position = 0;
}
[Obsolete("RunUO backward compatible method that should be replaced.")]
public string ReadString()
// Compatible with BinaryReader.ReadString()
public string ReadString(bool intern = false)
{
if (!ReadBool())
{
@ -59,146 +53,76 @@ namespace Server
}
var length = ReadEncodedInt();
return length <= 0 ? "" : ReadString(_encoding, false, length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadString(Encoding encoding, bool safeString = false, int fixedLength = -1)
{
int sizeT = TextEncoding.GetByteLengthForEncoding(encoding);
bool isFixedLength = fixedLength > -1;
var remaining = _buffer.Length - _position;
int size;
if (isFixedLength)
if (length <= 0)
{
size = fixedLength * sizeT;
if (size > remaining)
{
throw new OutOfMemoryException();
}
}
else
{
size = remaining - (remaining & (sizeT - 1));
return intern ? Utility.Intern("") : "";
}
var buffer = _buffer.AsSpan(Position, size);
int index = buffer.IndexOfTerminator(sizeT);
var span = buffer[..(index < 0 ? size : index)];
_position += isFixedLength || index < 0 ? size : index + sizeT;
return TextEncoding.GetString(span, encoding, safeString);
var str = TextEncoding.GetString(_buffer.AsSpan(_position, length), _encoding);
_position += length;
return intern ? Utility.Intern(str) : str;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadLittleUniSafe(int fixedLength) => ReadString(TextEncoding.UnicodeLE, true, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadLittleUniSafe() => ReadString(TextEncoding.UnicodeLE, true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadLittleUni(int fixedLength) => ReadString(TextEncoding.UnicodeLE, false, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadLittleUni() => ReadString(TextEncoding.UnicodeLE);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadBigUniSafe(int fixedLength) => ReadString(TextEncoding.Unicode, true, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadBigUniSafe() => ReadString(TextEncoding.Unicode, true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadBigUni(int fixedLength) => ReadString(TextEncoding.Unicode, false, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadBigUni() => ReadString(TextEncoding.Unicode);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadUTF8Safe(int fixedLength) => ReadString(TextEncoding.UTF8, true, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadUTF8Safe() => ReadString(TextEncoding.UTF8, true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadUTF8() => ReadString(TextEncoding.UTF8);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadAsciiSafe(int fixedLength) => ReadString(Encoding.ASCII, true, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadAsciiSafe() => ReadString(Encoding.ASCII, true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadAscii(int fixedLength) => ReadString(Encoding.ASCII, false, fixedLength);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadAscii() => ReadString(Encoding.ASCII);
public DateTime ReadDateTime() => new(ReadLong(), DateTimeKind.Utc);
public TimeSpan ReadTimeSpan() => new(ReadLong());
public DateTime ReadDeltaTime() => new(ReadLong() + DateTime.UtcNow.Ticks, DateTimeKind.Utc);
public decimal ReadDecimal() => new(new[] { ReadInt(), ReadInt(), ReadInt(), ReadInt() });
public decimal ReadDecimal() => new(stackalloc int[4] { ReadInt(), ReadInt(), ReadInt(), ReadInt() });
public long ReadLong()
{
var v = BinaryPrimitives.ReadInt64LittleEndian(_buffer.AsSpan(Position, 8));
var v = BinaryPrimitives.ReadInt64LittleEndian(_buffer.AsSpan(_position, 8));
_position += 8;
return v;
}
public ulong ReadULong()
{
var v = BinaryPrimitives.ReadUInt64LittleEndian(_buffer.AsSpan(Position, 8));
var v = BinaryPrimitives.ReadUInt64LittleEndian(_buffer.AsSpan(_position, 8));
_position += 8;
return v;
}
public int ReadInt()
{
var v = BinaryPrimitives.ReadInt32LittleEndian(_buffer.AsSpan(Position, 4));
var v = BinaryPrimitives.ReadInt32LittleEndian(_buffer.AsSpan(_position, 4));
_position += 4;
return v;
}
public uint ReadUInt()
{
var v = BinaryPrimitives.ReadUInt32LittleEndian(_buffer.AsSpan(Position, 4));
var v = BinaryPrimitives.ReadUInt32LittleEndian(_buffer.AsSpan(_position, 4));
_position += 4;
return v;
}
public short ReadShort()
{
var v = BinaryPrimitives.ReadInt16LittleEndian(_buffer.AsSpan(Position, 2));
var v = BinaryPrimitives.ReadInt16LittleEndian(_buffer.AsSpan(_position, 2));
_position += 2;
return v;
}
public ushort ReadUShort()
{
var v = BinaryPrimitives.ReadUInt16LittleEndian(_buffer.AsSpan(Position, 2));
var v = BinaryPrimitives.ReadUInt16LittleEndian(_buffer.AsSpan(_position, 2));
_position += 2;
return v;
}
public double ReadDouble()
{
var v = BinaryPrimitives.ReadDoubleLittleEndian(_buffer.AsSpan(Position, 8));
var v = BinaryPrimitives.ReadDoubleLittleEndian(_buffer.AsSpan(_position, 8));
_position += 8;
return v;
}
public float ReadFloat()
{
var v = BinaryPrimitives.ReadSingleLittleEndian(_buffer.AsSpan(Position, 4));
var v = BinaryPrimitives.ReadSingleLittleEndian(_buffer.AsSpan(_position, 4));
_position += 4;
return v;
}
@ -230,7 +154,7 @@ namespace Server
// Either 2 ushorts, or 8 ushorts
Span<byte> integer = stackalloc byte[length];
Read(integer);
return new IPAddress(integer);
return Utility.Intern(new IPAddress(integer));
}
public Point3D ReadPoint3D() => new(ReadInt(), ReadInt(), ReadInt());
@ -243,71 +167,22 @@ namespace Server
public Map ReadMap() => Map.Maps[ReadByte()];
public T ReadEntity<T>() where T : class, ISerializable
{
Serial serial = ReadUInt();
// Special case for now:
if (typeof(T).IsAssignableTo(typeof(BaseGuild)))
{
return World.FindGuild(serial) as T;
}
return World.FindEntity(serial) as T;
}
public List<T> ReadEntityList<T>() where T : class, ISerializable
{
var count = ReadInt();
var list = new List<T>(count);
for (var i = 0; i < count; ++i)
{
var entity = ReadEntity<T>();
if (entity != null)
{
list.Add(entity);
}
}
return list;
}
public HashSet<T> ReadEntitySet<T>() where T : class, ISerializable
{
var count = ReadInt();
var set = new HashSet<T>(count);
for (var i = 0; i < count; ++i)
{
var entity = ReadEntity<T>();
if (entity != null)
{
set.Add(entity);
}
}
return set;
}
public Race ReadRace() => Race.Races[ReadByte()];
public int Read(Span<byte> buffer)
{
var length = buffer.Length;
if (length > _buffer.Length - Position)
if (length > _buffer.Length - _position)
{
throw new OutOfMemoryException();
}
_buffer.AsSpan(Position, length).CopyTo(buffer);
_buffer.AsSpan(_position, length).CopyTo(buffer);
_position += length;
return length;
}
public virtual int Seek(int offset, SeekOrigin origin)
public virtual long Seek(long offset, SeekOrigin origin)
{
Debug.Assert(
origin != SeekOrigin.End || offset <= 0 && offset > -_buffer.Length,
@ -322,12 +197,19 @@ namespace Server
"Attempting to seek to an invalid position using SeekOrigin.Current"
);
return _position = Math.Max(0, origin switch
var position = Math.Max(0L, origin switch
{
SeekOrigin.Current => _position + offset,
SeekOrigin.End => _buffer.Length + offset,
_ => offset // Begin
});
if (position > int.MaxValue)
{
throw new ArgumentException($"BufferReader does not support {nameof(offset)} beyond Int32.MaxValue");
}
return _position;
}
}
}

31
Projects/Server/Serialization/BufferWriter.cs
View file

@ -14,13 +14,11 @@
*************************************************************************/
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text;
using Server.Network;
using Server.Text;
namespace Server
@ -387,35 +385,6 @@ namespace Server
Write((byte)(value?.RaceIndex ?? 0xFF));
}
public void Write(ISerializable value)
{
Write(value?.Deleted != false ? Serial.MinusOne : value.Serial);
}
public void Write<T>(ICollection<T> coll) where T : class, ISerializable
{
Write(coll.Count);
foreach (var entry in coll)
{
Write(entry);
}
}
public void Write<T>(ICollection<T> coll, Action<IGenericWriter, T> action) where T : class, ISerializable
{
if (coll == null)
{
Write(0);
return;
}
Write(coll.Count);
foreach (var entry in coll)
{
action(this, entry);
}
}
internal void InternalWriteString(string value)
{
var remaining = m_Encoding.GetByteCount(value);

8
Projects/Server/Serialization/GenericPersistence.cs
View file

@ -53,7 +53,6 @@ namespace Server
void Deserialize(string savePath)
{
var path = Path.Combine(savePath, name);
AssemblyHandler.EnsureDirectory(path);
string binPath = Path.Combine(path, $"{name}.bin");
@ -65,10 +64,9 @@ namespace Server
try
{
using FileStream bin = new FileStream(binPath, FileMode.Open, FileAccess.Read, FileShare.Read);
var buffer = GC.AllocateUninitializedArray<byte>((int)bin.Length);
bin.Read(buffer);
deserializer(new BufferReader(buffer));
using FileStream fs = new FileStream(binPath, FileMode.Open, FileAccess.Read, FileShare.Read);
using var br = new BinaryFileReader(fs);
deserializer(br);
}
catch (Exception e)
{

8
Projects/Server/Serialization/IGenericReader.cs
View file

@ -14,14 +14,14 @@
*************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
namespace Server
{
public interface IGenericReader
{
string ReadString();
string ReadString(bool intern = false);
DateTime ReadDateTime();
TimeSpan ReadTimeSpan();
DateTime ReadDeltaTime();
@ -44,10 +44,8 @@ namespace Server
Rectangle2D ReadRect2D();
Rectangle3D ReadRect3D();
Map ReadMap();
T ReadEntity<T>() where T : class, ISerializable;
List<T> ReadEntityList<T>() where T : class, ISerializable;
HashSet<T> ReadEntitySet<T>() where T : class, ISerializable;
Race ReadRace();
int Read(Span<byte> buffer);
long Seek(long offset, SeekOrigin origin);
}
}

3
Projects/Server/Serialization/IGenericWriter.cs
View file

@ -14,7 +14,6 @@
*************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
@ -47,9 +46,7 @@ namespace Server
void Write(Rectangle2D value);
void Write(Rectangle3D value);
void Write(Map value);
void Write(ISerializable value);
void Write(Race value);
void Write<T>(ICollection<T> list) where T : class, ISerializable;
void Write(ReadOnlySpan<byte> bytes);
long Seek(long offset, SeekOrigin origin);

1
Projects/Server/Text/StringHelpers.cs
View file

@ -18,7 +18,6 @@ using System.Buffers;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Server.Network;
namespace Server
{

34
Projects/Server/TileData.cs
View file

@ -16,6 +16,8 @@
using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using Server.Text;
namespace Server
{
@ -261,14 +263,12 @@ namespace Server
Load();
}
private static void Load()
private unsafe static void Load()
{
var filePath = Core.FindDataFile("tiledata.mul");
using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
var buffer = GC.AllocateUninitializedArray<byte>((int)fs.Length);
fs.Read(buffer);
var bin = new BufferReader(buffer);
using var bin = new BinaryReader(fs);
bool is64BitFlags;
const int landLength = 0x4000;
@ -290,39 +290,47 @@ namespace Server
itemLength = 0x4000;
}
Span<byte> buffer = stackalloc byte[20];
for (var i = 0; i < landLength; i++)
{
if (is64BitFlags ? i == 1 || i > 0 && (i & 0x1F) == 0 : (i & 0x1F) == 0)
{
bin.ReadInt(); // header
bin.ReadInt32(); // header
}
var flags = (TileFlag)(is64BitFlags ? bin.ReadULong() : bin.ReadUInt());
bin.ReadShort(); // skip 2 bytes -- textureID
var flags = (TileFlag)(is64BitFlags ? bin.ReadUInt64() : bin.ReadUInt32());
bin.ReadInt16(); // skip 2 bytes -- textureID
LandTable[i] = new LandData(bin.ReadAscii(20), flags);
bin.Read(buffer);
var terminator = buffer.IndexOfTerminator(1);
var name = Encoding.ASCII.GetString(buffer[..(terminator < 0 ? buffer.Length : terminator)]);
LandTable[i] = new LandData(Utility.Intern(name), flags);
}
for (var i = 0; i < itemLength; i++)
{
if ((i & 0x1F) == 0)
{
bin.ReadInt(); // header
bin.ReadInt32(); // header
}
var flags = (TileFlag)(is64BitFlags ? bin.ReadULong() : bin.ReadUInt());
var flags = (TileFlag)(is64BitFlags ? bin.ReadUInt64() : bin.ReadUInt32());
int weight = bin.ReadByte();
int quality = bin.ReadByte();
int animation = bin.ReadUShort();
int animation = bin.ReadUInt16();
bin.ReadByte();
int quantity = bin.ReadByte();
bin.ReadInt();
bin.ReadInt32();
bin.ReadByte();
int value = bin.ReadByte();
int height = bin.ReadByte();
bin.Read(buffer);
var terminator = buffer.IndexOfTerminator(1);
var name = Encoding.ASCII.GetString(buffer[..(terminator < 0 ? buffer.Length : terminator)]);
ItemTable[i] = new ItemData(
bin.ReadAscii(20),
Utility.Intern(name),
flags,
weight,
quality,

1
Projects/Server/Utilities/Utility.cs
View file

@ -10,7 +10,6 @@ using System.Text;
using System.Xml;
using Microsoft.Toolkit.HighPerformance;
using Server.Buffers;
using Server.Network;
using Server.Random;
namespace Server

13
Projects/Server/World/EntityPersistence.cs
View file

@ -126,14 +126,12 @@ namespace Server
continue;
}
T t;
ConstructorInfo ctor = objs.Item1;
I indexer = indexInfo.CreateIndex(number);
ctorArgs[0] = indexer;
t = ctor.Invoke(ctorArgs) as T;
if (t != null)
if (ctor.Invoke(ctorArgs) is T t)
{
entities.Add(new EntityIndex<T>(t, typeID, pos, length));
map[indexer] = t;
@ -162,19 +160,18 @@ namespace Server
}
using FileStream bin = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read);
BufferReader br = null;
foreach (var entry in entities)
{
T t = entry.Entity;
var position = bin.Position;
var position = entry.Position;
bin.Seek(position, SeekOrigin.Begin);
// Skip this entry
if (t == null)
{
bin.Seek(entry.Length, SeekOrigin.Current);
continue;
}
@ -185,7 +182,7 @@ namespace Server
}
else
{
br.SwapBuffers(buffer, out _);
br.Reset(buffer, out _);
}
bin.Read(buffer.AsSpan());
@ -221,8 +218,6 @@ namespace Server
}
t.Delete();
// Skip this entry
bin.Seek(position + entry.Length, SeekOrigin.Begin);
}
}
}

83
Projects/Server/World/World.cs
View file

@ -153,6 +153,7 @@ namespace Server
m_DiskWriteHandle.WaitOne();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void EnqueueForDecay(Item item)
{
if (WorldState != WorldState.Saving)
@ -468,8 +469,6 @@ namespace Server
Broadcast(0x35, true, "The world is saving, please wait.");
var now = DateTime.UtcNow;
logger.Information("Saving world");
var watch = Stopwatch.StartNew();
@ -645,5 +644,85 @@ namespace Server
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void RemoveGuild(BaseGuild guild) => Guilds.Remove(guild.Serial);
private struct TypeOf<T> { }
public static T ReadEntity<T>(this IGenericReader reader) where T : class, ISerializable
{
Serial serial = reader.ReadUInt();
return default(TypeOf<T>) switch
{
TypeOf<BaseGuild> => FindGuild(serial) as T,
TypeOf<IEntity> => FindEntity<IEntity>(serial) as T,
_ => default
};
}
public static List<T> ReadEntityList<T>(this IGenericReader reader) where T : class, ISerializable
{
var count = reader.ReadInt();
var list = new List<T>(count);
for (var i = 0; i < count; ++i)
{
var entity = reader.ReadEntity<T>();
if (entity != null)
{
list.Add(entity);
}
}
return list;
}
public static HashSet<T> ReadEntitySet<T>(this IGenericReader reader) where T : class, ISerializable
{
var count = reader.ReadInt();
var set = new HashSet<T>(count);
for (var i = 0; i < count; ++i)
{
var entity = reader.ReadEntity<T>();
if (entity != null)
{
set.Add(entity);
}
}
return set;
}
public static void Write(this IGenericWriter writer, ISerializable value)
{
writer.Write(value?.Deleted != false ? Serial.MinusOne : value.Serial);
}
public static void Write<T>(this IGenericWriter writer, ICollection<T> coll) where T : class, ISerializable
{
writer.Write(coll.Count);
foreach (var entry in coll)
{
writer.Write(entry);
}
}
public static void Write<T>(
this IGenericWriter writer, ICollection<T> coll, Action<IGenericWriter, T> action
) where T : class, ISerializable
{
if (coll == null)
{
writer.Write(0);
return;
}
writer.Write(coll.Count);
foreach (var entry in coll)
{
action(writer, entry);
}
}
}
}