public void CreateMValueNil(out MValueConst mValue)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Nil, Library.Shared.Core_CreateMValueNil(NativePointer));
}
}
public void CreateMValueInt(out MValueConst mValue, long value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Int, Library.Shared.Core_CreateMValueInt(NativePointer, value));
}
}
public object Call(params object[] args)
{
var length = args.Length;
var mValues = new MValueConst[length];
Alt.Server.CreateMValues(mValues, args);
var argsPointers = Marshal.AllocHGlobal(length * IntPtr.Size);
for (var i = 0; i < length; i++)
{
Marshal.WriteIntPtr(argsPointers, mValues[i].nativePointer);
}
var result = function(argsPointers, length);
for (var i = 0; i < length; i++)
{
mValues[i].Dispose();
}
Marshal.FreeHGlobal(argsPointers);
var resultMValue = new MValueConst(result);
var resultObj = resultMValue.ToObject();
resultMValue.Dispose();
return(resultObj);
}
public override void GetMetaData(string key, out MValueConst value)
{
var stringPtr = AltNative.StringUtils.StringToHGlobalUtf8(key);
value = new MValueConst(AltNative.Player.Player_GetMetaData(NativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
public static bool EmitLocked(this IPlayer player, string eventName, params object[] args)
{
var size = args.Length;
var mValues = new MValueConst[size];
MValueConstLocked.CreateFromObjectsLocked(args, mValues);
var eventNamePtr = AltNative.StringUtils.StringToHGlobalUtf8(eventName);
var successfully = true;
lock (player)
{
if (player.Exists)
{
Alt.Server.TriggerClientEvent(player, eventNamePtr, mValues);
}
else
{
successfully = false;
}
}
for (var i = 0; i < size; i++)
{
mValues[i].Dispose();
}
Marshal.FreeHGlobal(eventNamePtr);
return(successfully);
}
public void CreateMValueDouble(out MValueConst mValue, double value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Double,
Library.Shared.Core_CreateMValueDouble(NativePointer, value));
}
}
public void CreateMValueVector2(out MValueConst mValue, Vector2 value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Vector2,
Library.Shared.Core_CreateMValueVector2(NativePointer, value));
}
}
public void CreateMValueString(out MValueConst mValue, string value)
{
var valuePtr = AltNative.StringUtils.StringToHGlobalUtf8(value);
mValue = new MValueConst(MValueConst.Type.String,
AltNative.Server.Core_CreateMValueString(NativePointer, valuePtr));
Marshal.FreeHGlobal(valuePtr);
}
public void CreateMValueRgba(out MValueConst mValue, Rgba value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Rgba,
Library.Shared.Core_CreateMValueRgba(NativePointer, value));
}
}
public void CreateMValueBaseObject(out MValueConst mValue, ISharedBaseObject value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.BaseObject,
Library.Shared.Core_CreateMValueBaseObject(NativePointer, value.BaseObjectNativePointer));
}
}
public void CreateMValueFunction(out MValueConst mValue, IntPtr value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Function,
Library.Shared.Core_CreateMValueFunction(NativePointer, value));
}
}
public void GetSyncedMetaData(string key, out MValueConst value)
{
CheckIfCallIsValid();
var stringPtr = AltNative.StringUtils.StringToHGlobalUtf8(key);
value = new MValueConst(AltNative.Server.Server_GetSyncedMetaData(NativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
public void CreateMValueBool(out MValueConst mValue, bool value)
{
unsafe
{
mValue = new MValueConst(this, MValueConst.Type.Bool,
Library.Shared.Core_CreateMValueBool(NativePointer, value ? (byte)1 : (byte)0));
}
}
public void GetLocalMetaData(string key, out MValueConst value)
{
unsafe
{
var stringPtr = AltNative.StringUtils.StringToHGlobalUtf8(key);
value = new MValueConst(Core, Core.Library.Server.Player_GetLocalMetaData(PlayerNativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
}
public void Get(string key, out MValueConst value)
{
unsafe
{
var stringPtr = MemoryUtils.StringToHGlobalUtf8(key);
value = new MValueConst(core, core.Library.Client.LocalStorage_GetKey(nativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
}
public void GetMetaData(string key, out MValueConst value)
{
unsafe
{
var stringPtr = MemoryUtils.StringToHGlobalUtf8(key);
value = new MValueConst(Core, Core.Library.Shared.BaseObject_GetMetaData(BaseObjectNativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
}
public override void OnServerEventEvent(string name, IntPtr[] args, MValueConst[] mValues, object[] objects)
{
base.OnServerEventEvent(name, args, mValues, objects);
var length = args.Length;
if (asyncEventBusServer.Count != 0 && asyncEventBusServer.TryGetValue(name, out var eventHandlersServer))
{
if (mValues == null)
{
mValues = new MValueConst[length];
for (var i = 0; i < length; i++)
{
mValues[i] = new MValueConst(args[i]);
}
}
if (objects == null)
{
objects = new object[length];
for (var i = 0; i < length; i++)
{
objects[i] = mValues[i].ToObject();
}
}
Task.Factory.StartNew(async obj =>
{
var(taskObjects, taskEventHandlers, taskName) =
(ValueTuple <object[], HashSet <Function>, string>)obj;
foreach (var eventHandler in taskEventHandlers)
{
var invokeValues = eventHandler.CalculateInvokeValues(taskObjects);
if (invokeValues != null)
{
try
{
var task = eventHandler.InvokeTaskOrNull(invokeValues);
if (task != null)
{
await task;
}
}
catch (Exception e)
{
AltAsync.Log($"Execution of {taskName} threw an error: {e}");
}
}
else
{
AltAsync.Log("Wrong function params for " + taskName);
}
}
}, new ValueTuple <object[], HashSet <Function>, string>(objects, eventHandlersServer, name));
}
}
public void CreateMValueString(out MValueConst mValue, string value)
{
unsafe
{
var valuePtr = MemoryUtils.StringToHGlobalUtf8(value);
mValue = new MValueConst(this, MValueConst.Type.String,
Library.Shared.Core_CreateMValueString(NativePointer, valuePtr));
Marshal.FreeHGlobal(valuePtr);
}
}
public void GetSyncedMetaData(string key, out MValueConst value)
{
CheckIfEntityExists();
unsafe
{
var stringPtr = MemoryUtils.StringToHGlobalUtf8(key);
value = new MValueConst(Core, Core.Library.Shared.Entity_GetSyncedMetaData(EntityNativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
}
public void CreateMValueByteArray(out MValueConst mValue, byte[] value)
{
var size = value.Length;
var dataPtr = Marshal.AllocHGlobal(size);
Marshal.Copy(value, 0, dataPtr, size);
mValue = new MValueConst(MValueConst.Type.Entity,
AltNative.Server.Core_CreateMValueByteArray(NativePointer, (ulong)size, dataPtr));
Marshal.FreeHGlobal(dataPtr);
}
public void CreateMValueByteArray(out MValueConst mValue, byte[] value)
{
unsafe
{
var size = value.Length;
var dataPtr = Marshal.AllocHGlobal(size);
Marshal.Copy(value, 0, dataPtr, size);
mValue = new MValueConst(this, MValueConst.Type.ByteArray,
Library.Shared.Core_CreateMValueByteArray(NativePointer, (ulong)size, dataPtr));
Marshal.FreeHGlobal(dataPtr);
}
}
public void CreateMValueDict(out MValueConst mValue, string[] keys, MValueConst[] val, ulong size)
{
var pointers = new IntPtr[size];
for (ulong i = 0; i < size; i++)
{
pointers[i] = val[i].nativePointer;
}
mValue = new MValueConst(MValueConst.Type.Dict,
AltNative.Server.Core_CreateMValueDict(NativePointer, keys, pointers, size));
}
public static void CreateLocked(IPlayer player, out MValueConst mValue)
{
lock (player)
{
if (!player.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Core.CreateMValueBaseObject(out mValue, player);
}
}
public static void CreateLocked(IVehicle vehicle, out MValueConst mValue)
{
lock (vehicle)
{
if (!vehicle.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Core.CreateMValueBaseObject(out mValue, vehicle);
}
}
public static void CreateLocked(ICheckpoint checkpoint, out MValueConst mValue)
{
lock (checkpoint)
{
if (!checkpoint.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Server.CreateMValueCheckpoint(out mValue, checkpoint);
}
}
public static void CreateLocked(IBlip blip, out MValueConst mValue)
{
lock (blip)
{
if (!blip.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Server.CreateMValueBlip(out mValue, blip);
}
}
public static void CreateLocked(IVehicle vehicle, out MValueConst mValue)
{
lock (vehicle)
{
if (!vehicle.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Server.CreateMValueVehicle(out mValue, vehicle);
}
}
public static void CreateLocked(IPlayer player, out MValueConst mValue)
{
lock (player)
{
if (!player.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Server.CreateMValuePlayer(out mValue, player);
}
}
public static void CreateLocked(IBlip blip, out MValueConst mValue)
{
lock (blip)
{
if (!blip.Exists)
{
mValue = MValueConst.Nil;
return;
}
Alt.Core.CreateMValueBaseObject(out mValue, blip);
}
}
public bool ToMValue(object obj, Type type, out MValueConst mValue)
{
if (adapters.TryGetValue(type, out var adapter))
{
var writer = new MValueWriter2(this);
adapter.ToMValue(obj, writer);
writer.ToMValue(out mValue);
return(true);
}
mValue = default;
return(false);
}
