public void Send <T, U>(T packet, U[] slices) where T : IPacketHeader where U : IDataSlice
{
if (IsConnecting == false && IsConnected == false)
{
return;
}
int headerSize = ClassSerializer.GetProfile(typeof(T)).BufferLength;
int sliceSize = ClassSerializer.GetProfile(typeof(U)).BufferLength;
byte[] datagram = new byte[headerSize + (sliceSize * slices.Length)];
byte[] header = ClassSerializer.Serialize(packet);
ByteUtil.Put(0, header, ref datagram);
for (int i = 0; i < slices.Length; i++)
{
byte[] slicedata = ClassSerializer.Serialize(slices[i]);
ByteUtil.Put(headerSize + (i * sliceSize), slicedata, ref datagram);
}
ByteUtil.DumpNum(datagram);
try {
DataCountOut += datagram.Length;
DataTotalOut += datagram.Length;
udpClient.Send(datagram, datagram.Length);
} catch (SocketException exception) {
Console.WriteLine(exception.ToString());
// Error codes:
// https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
}
}
public void Send <T, U>(INetworkPeer peer, T packet, U[] slices) where T : IPacketHeader where U : IDataSlice
{
//int headerSize = Marshal.SizeOf(typeof(T));
//int sliceSize = Marshal.SizeOf(typeof(U));
int headerSize = ClassSerializer.GetProfile(typeof(T)).BufferLength;
int sliceSize = ClassSerializer.GetProfile(typeof(U)).BufferLength;
byte[] datagram = new byte[headerSize + (sliceSize * slices.Length)];
byte[] header = ClassSerializer.Serialize(packet);
ByteUtil.Put(0, header, ref datagram);
for (int i = 0; i < slices.Length; i++)
{
byte[] slicedata = ClassSerializer.Serialize(slices[i]);
ByteUtil.Put(headerSize + (i * sliceSize), slicedata, ref datagram);
}
ByteUtil.DumpNum(datagram);
try {
udpClient.Send(datagram, datagram.Length, peer.IPAddress);
} catch (SocketException exception) {
Console.WriteLine("Exception:" + exception.ToString());
// Error codes:
// https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
}
}
public void SerializeFieldToStringTest()
{
ClassSerializer target = new ClassSerializer(); // TODO: Initialize to an appropriate value
DBField field = new DBField();
field.DbName = "myname";
string result = target.SerializeToString(field);
string expected = @"<?xml version=""1.0""?>
<DBField xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
<Isn>0</Isn>
<IndexInRecord>0</IndexInRecord>
<Attr>0</Attr>
<AllowNull>false</AllowNull>
<DefaultNull>false</DefaultNull>
<Length>0</Length>
<DiffUpdate>0</DiffUpdate>
<Dec>0</Dec>
<Whole>0</Whole>
<PartOfDateTime>0</PartOfDateTime>
<DefaultStorage>false</DefaultStorage>
<DbName>myname</DbName>
</DBField>";
Assert.AreEqual(expected, result);
}
/// <summary>Adds an object to the packet.</summary>
/// <param name="_value">The object to add.</param>
public void Write <T>(T _value)
{
byte[] _objectByteArray = ClassSerializer.ObjectToByteArray(_value); //serialize object and convert it to byte array
Write(_objectByteArray.Length); // Add the length of the object byte array to the packet
Write(_objectByteArray); // Add the object byte array itself
}
public void MissingProperty()
{
var cs = new ClassSerializer(typeof(EmptyClass));
var r = new Reader("!Test.EmptyClass{MissingProp:1}");
var result = cs.Read(r, null, null) as EmptyClass;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
}
public void SortedProperties()
{
var value = new SortedPropertyClass();
var w = new Writer();
var cs = new ClassSerializer(typeof(DerivedClass));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.SortedPropertyClass{MyString1Property:?null,MyString2Property:?null,MyString3Property:?null}", w.ToString());
}
public void AddListener <T>(Protocol code, Callback <T> method) where T : new()
{
OnServerMessage += (bytedata) => {
if (bytedata[0] == (byte)code)
{
method(ClassSerializer.Deserialize <T>(bytedata));
}
};
}
public void AnticipateTypeDefinition()
{
var r = new Reader("!Test.PropertyClassGuid{MyGuid:fb82b37ccc56415ebaea773f4bbe7203}");
var anticipated = ClassSerializer.AnticipateType(r);
Assert.AreEqual(new Guid("fb82b37ccc56415ebaea773f4bbe7203"), anticipated.guid);
Assert.AreEqual(typeof(PropertyClassGuid), anticipated.type);
Assert.IsNull(anticipated.instance);
Assert.IsNotNull(r.ReadType <PropertyClassGuid>(null, null));
}
public void Send <T>(INetworkPeer peer, T packet) where T : IPacket
{
byte[] data = ClassSerializer.Serialize(packet);
ByteUtil.DumpNum(data);
try {
udpClient.Send(data, data.Length, peer.IPAddress);
} catch (SocketException exception) {
Console.WriteLine("ERR: " + exception.ToString());
// Error codes:
// https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
}
}
/// <summary>Reads an object from the packet.</summary>
/// <param name="_moveReadPos">Whether or not to move the buffer's read position.</param>
public T ReadObject <T>(bool _moveReadPos = true)
{
try
{
int _length = ReadInt(_moveReadPos); // Get the length of the object bytes array
byte[] _objectByteArray = ReadBytes(_length, _moveReadPos); // Get the object byte array
return((T)ClassSerializer.ByteArrayToObject(_objectByteArray)); // Convert the byte array and return the object
}
catch
{
throw new Exception("Could not read value of type 'object'!");
}
}
public void SerializeToStringTest()
{
ClassSerializer target = new ClassSerializer(); // TODO: Initialize to an appropriate value
SampleClass s = new SampleClass()
{
A = "value a", B = 5
};
string result = target.SerializeToString(s);
string expected = "<?xml version=\"1.0\"?>\r\n<SampleClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\r\n <A>value a</A>\r\n <B>5</B>\r\n</SampleClass>";
Assert.AreEqual(expected, result);
}
public void MissingClass()
{
var r = new Reader("!Test.CascadedClass{MyEmptyClass:!Test.UnknownClass{},MyPropertyClass:!Test.PropertyClass{MyStringProperty:\"Hello World!\"}}");
var cs = new ClassSerializer(typeof(CascadedClass));
var context = new SerializationContext();
var result = cs.Read(r, null, context) as CascadedClass;
Assert.IsNotNull(result);
Assert.IsTrue(context.HasErrors);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsNull(result.MyEmptyClass);
Assert.IsInstanceOf(typeof(PropertyClass), result.MyPropertyClass);
Assert.AreEqual("Hello World!", result.MyPropertyClass.MyStringProperty);
}
public void CustomPropertyReader()
{
var cs = new ClassSerializer(typeof(CustomPropertySerializerClass));
var r = new Reader("!Test.CustomPropertySerializerClass{UseReader:False,TestString:\"Test\"}");
var result = cs.Read(r, null, null) as CustomPropertySerializerClass;
Assert.IsNotNull(result);
Assert.AreEqual("Test", result.TestString);
r = new Reader("!Test.CustomPropertySerializerClass{UseReader:True,TestString:\"Test\"}");
result = cs.Read(r, null, null) as CustomPropertySerializerClass;
Assert.IsNotNull(result);
Assert.AreEqual("TEST", result.TestString);
}
public static IAxSerializer WriteClass <T>(this IAxSerializer s, T source) where T : class
{
Delegate @delegate;
bool flag = !Delegates.TryGetValue(typeof(T), out @delegate);
if (flag)
{
@delegate = Serializer.GetDynamicSerializer(typeof(T)).CreateDelegate(typeof(ClassSerializer <T>));
}
ClassSerializer <T> classSerializer = (ClassSerializer <T>)@delegate;
classSerializer(s, source);
return(s);
}
//--------------------------------------------------------------------------------------------------
bool DeserializeBody(Reader reader, SerializationContext context)
{
var model = context.GetInstance <Model>();
bool reuseModelBodies = false;
Body.CloneOptions cloneOptions = default;
switch (context.Scope)
{
case SerializationScope.UndoRedo:
reuseModelBodies = true;
break;
case SerializationScope.CopyPaste:
context.TryGetInstance(out cloneOptions);
reuseModelBodies = true; // ask later
break;
}
if (!reuseModelBodies || model == null)
{
return(false); // Use standard serializer
}
// Try to find referenced body shapes in current model
var anticipated = ClassSerializer.AnticipateType(reader);
if (anticipated.type != null && typeof(Body).IsAssignableFrom(anticipated.type))
{
// Try finding body in model?
var body = model.FindInstance(anticipated.guid) as Body;
if (body != null)
{
// Ask if options are available, otherwise assume re-using
if (!(cloneOptions?.CloneReferencedBodies ?? false))
{
// operand already in model, use this
Body = body;
reader.SkipListOrMapValue();
return(true);
}
}
}
// Not in Model
Body = reader.ReadType <Body>(null, context);
return(true);
}
public void ArrayReferenced()
{
var value = new ArrayClassReferenced(true);
var w = new Writer();
var cs = new ClassSerializer(typeof(ArrayClassReferenced));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.ArrayClassReferenced{Array1:[11,42,65],Array2:[11,42,65]}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as ArrayClassReferenced;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsFalse(value.IsSame(result)); // Reference has been lost
}
public void ArrayAlreadyInstantiated()
{
var value = new ArrayClassInitialized(true);
var w = new Writer();
var cs = new ClassSerializer(typeof(ArrayClassInitialized));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.ArrayClassInitialized{Array1:[11,42,65]}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as ArrayClassInitialized;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsTrue(value.IsSame(result), "Read back value is not the same.");
}
public void EmptyArray()
{
var value = new ArrayClass(false);
var w = new Writer();
var cs = new ClassSerializer(typeof(ArrayClass));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.ArrayClass{Array1:[]}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as ArrayClass;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsTrue(value.IsSame(result), "Read back value is not the same.");
}
public void AddListener <T>(Protocol code, Callback <T> method) where T : IPacket, new()
{
OnUserMessage += (sender, bytedata) => {
if (bytedata[0] == (byte)code)
{
T payload;
try {
payload = ClassSerializer.Deserialize <T>(bytedata);
} catch (Exception) {
return;
}
method(sender, payload);
}
};
}
public void NullReferencedClass()
{
var value = new CascadedClass(null);
var w = new Writer();
var cs = new ClassSerializer(typeof(CascadedClass));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.CascadedClass{MyEmptyClass:!Test.EmptyClass{},MyPropertyClass:?null}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as CascadedClass;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsTrue(value.IsSame(result), "Read back value is not the same.");
}
public void DictReferenced()
{
var value = new DictionaryClassReferenced(true);
var w = new Writer();
var cs = new ClassSerializer(typeof(DictionaryClassReferenced));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.DictionaryClassReferenced{Dict1:{\"11\":11,\"42\":42,\"65\":65},Dict2:{\"11\":11,\"42\":42,\"65\":65}}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as DictionaryClassReferenced;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsFalse(value.IsSame(result), "Read back value is not the same.");
}
public void DictIsNull()
{
var value = new DictionaryClass();
var w = new Writer();
var cs = new ClassSerializer(typeof(DictionaryClass));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.DictionaryClass{Dict1:?null}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as DictionaryClass;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsTrue(value.IsSame(result), "Read back value is not the same.");
}
public void CustomPropertyWriter()
{
var cs = new ClassSerializer(typeof(CustomPropertySerializerClass));
var obj = new CustomPropertySerializerClass();
var w = new Writer();
Assert.IsTrue(cs.Write(w, obj, null));
Assert.AreEqual("!Test.CustomPropertySerializerClass{UseReader:False,TestString:\"Test\"}", w.ToString());
obj = new CustomPropertySerializerClass {
UseWriter = true
};
w = new Writer();
Assert.IsTrue(cs.Write(w, obj, null));
Assert.AreEqual("!Test.CustomPropertySerializerClass{UseReader:False,TestString:\"TEST\"}", w.ToString());
}
public void ListReferenced()
{
var value = new IntListClassReferenced(true);
var w = new Writer();
var cs = new ClassSerializer(typeof(IntListClassReferenced));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.IntListClassReferenced{List1:[11,42,65],List2:[11,42,65]}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as IntListClassReferenced;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsFalse(value.IsSame(result), "Read back value is not the same.");
}
public void AnticipateTypeReference()
{
var ctx = new SerializationContext();
var r = new Reader("!Test.PropertyClassGuid{MyGuid:fb82b37ccc56415ebaea773f4bbe7203}?fb82b37ccc56415ebaea773f4bbe7203");
var obj = r.ReadType <PropertyClassGuid>(null, null);
Assert.IsNotNull(obj);
var anticipated = ClassSerializer.AnticipateType(r, ctx);
Assert.AreEqual(new Guid("fb82b37ccc56415ebaea773f4bbe7203"), anticipated.Guid);
Assert.AreEqual(typeof(PropertyClassGuid), anticipated.Type);
Assert.AreSame(obj, anticipated.Instance);
Assert.AreSame(obj, r.ReadType <PropertyClassGuid>(null, null));
}
public void SerializableCallback()
{
var value = new CallbackClass();
var w = new Writer();
var cs = new ClassSerializer(typeof(CallbackClass));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.CallbackClass{}", w.ToString());
Assert.True(value.AllSerializeCallbacksTriggered());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as CallbackClass;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsTrue(result.AllDeserializeCallbacksTriggered());
}
/**
* public void OnPreEnable()
* {
* if (PluginManager.Obj.GetPlugin<Asphalt.Api.Asphalt>() == null)
* Disable("Dependency 'Asphalt-MDK' not found!");
* }
**/
public void OnEnable()
{
Instance = this;
if (IsDisabled())
{
return;
}
OldWarpsStorage = ClassSerializer <Warps> .Deserialize(Path.Combine(ServiceHelper.GetServerPluginFolder(this), "storage", "old_warps.json"));
OldHomesStorage = ClassSerializer <Homes> .Deserialize(Path.Combine(ServiceHelper.GetServerPluginFolder(this), "storage", "old_homes.json"));
BackPos = new Dictionary <string, Vector3>();
EventManager.RegisterListener(new AdvTpEventListener());
}
public ModDataHandler(string caminhoDoJogo, string caminhoDaPastaDeMods, string caminhoDaPastaDeManifestos)
{
string loaderModOWPath = "";
try
{
loaderModOWPath = DirectorySearchTools.GetFilePathInDirectory(loaderModOWFile, caminhoDoJogo);
}
catch { ConsoleWindowHelper.Warning(string.Format("{0} couldn't be found, the mod loader probrabilly hasn't been installed yet.", loaderModOWFile)); }
ModEnabledList = new ModFolderAndList()
{
ModFolder = "", ModList = new string[] { }
};
try
{
ClassSerializer.ReadFromFile(loaderModOWPath, ModEnabledList);
}
catch
{
ConsoleWindowHelper.Exception(string.Format("{0} couldn't be read, the problem can be fixed by pressing save.", loaderModOWFile));
}
string[] todosOsJsons = Directory.GetFiles(caminhoDaPastaDeManifestos, "*manifest.json", SearchOption.AllDirectories);
List <ModManifestJson> manifests = new List <ModManifestJson>();
for (int i = 0; i < todosOsJsons.Length; i++)
{
var modData = JsonReader.ReadFromJson <ModManifestJson>(todosOsJsons[i]);
if (modData.FileName != dimowaModLoaderFile)
{
manifests.Add(modData);
}
else
{
ManifestDoLoader = modData;
}
}
if (string.IsNullOrEmpty(ManifestDoLoader.FileName))
{
ConsoleWindowHelper.FatalException("DIMOWAModLoader.dll needs to be inside the mods folder with its manifest.json, make sure that it is in there.");
}
ManifestsDosMods = manifests.ToArray();
DIMOWALoaderInstaller = new DIMOWALoaderInstaller(caminhoDoJogo, caminhoDaPastaDeMods);
}
public void AnticipateSkippedTypeReference()
{
var ctx = new SerializationContext();
var r = new Reader("[!Test.PropertyClassGuid{MyGuid:fb82b37ccc56415ebaea773f4bbe7203},?fb82b37ccc56415ebaea773f4bbe7203]");
Assume.That(r.BeginList());
Assume.That(r.BeginListValue());
var anticipated = ClassSerializer.AnticipateType(r, ctx);
Assert.AreEqual(new Guid("fb82b37ccc56415ebaea773f4bbe7203"), anticipated.Guid);
Assert.AreEqual(typeof(PropertyClassGuid), anticipated.Type);
r.SkipListOrMapValue();
Assume.That(r.BeginListValue());
anticipated = ClassSerializer.AnticipateType(r, ctx);
Assert.AreEqual(new Guid("fb82b37ccc56415ebaea773f4bbe7203"), anticipated.Guid);
Assert.AreEqual(typeof(PropertyClassGuid), anticipated.Type);
}
public void Property()
{
var value = new PropertyClass
{
MyStringProperty = "Hello World!"
};
var w = new Writer();
var cs = new ClassSerializer(typeof(PropertyClass));
Assert.True(cs.Write(w, value, null));
Assert.AreEqual("!Test.PropertyClass{MyStringProperty:\"Hello World!\"}", w.ToString());
var r = new Reader(w.ToString());
var result = cs.Read(r, null, null) as PropertyClass;
Assert.IsNotNull(result);
Assert.IsFalse(r.AnyLeft, "Any characters left.");
Assert.IsTrue(value.IsSame(result), "Read back value is not the same.");
}
