public static int size(MValue value, double dim)
{
Contract.Requires(value != null);
var shape = value.Shape;
return(shape.GetDimensionSize(PseudoBuiltins.ToInt(dim) - 1));
}
//TODO: make call async because it doesnt matter there is no concurrent problems inside
//TODO: write function parser in cpp so it can do that natively without any native calls for mvalues (experimental)
//TODO: register event callbacks to cpp as dynamic function pointers with void** so cpp knows the types it needs to check
//TODO: add support for nullable args, these are reducing the required length, add support for default values as well
internal MValue Call(IBaseBaseObjectPool baseBaseObjectPool, MValue[] values)
{
var length = values.Length;
if (length != args.Length)
{
return(MValue.Nil);
}
//var watch = System.Diagnostics.Stopwatch.StartNew();
var invokeValues = new object[length];
for (var i = 0; i < length; i++)
{
invokeValues[i] = parsers[i](ref values[i], args[i], baseBaseObjectPool, typeInfos[i]);
}
//watch.Stop();
//var elapsedMs = watch.ElapsedMilliseconds;
//Alt.Log("ms:" + elapsedMs);
var result = @delegate.DynamicInvoke(invokeValues);
if (returnType == FunctionTypes.Void)
{
return(MValue.Nil);
}
return(MValue.CreateFromObject(result));
}
public static void Export <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(
string key,
Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> value) =>
Module.CSharpNativeResource.SetExport(key,
MValue.Create(Function
.Create <Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> >(value)
.call));
public override void SetMetaData(string key, ref MValue value)
{
var stringPtr = AltNative.StringUtils.StringToHGlobalUtf8(key);
AltNative.VoiceChannel.VoiceChannel_SetMetaData(NativePointer, stringPtr, ref value);
Marshal.FreeHGlobal(stringPtr);
}
public void TriggerClientEvent(IPlayer player, string eventName, params object[] args)
{
var mValues = MValue.CreateFromObjects(args);
TriggerClientEvent(player, eventName, mValues);
MValue.Dispose(mValues);
}
public void SetMetaData(string key, object value)
{
CheckIfEntityExists();
var mValue = MValue.CreateFromObject(value);
SetMetaData(key, ref mValue);
}
public override void GetSyncedMetaData(string key, ref MValue value)
{
var stringPtr = AltNative.StringUtils.StringToHGlobalUtf8(key);
AltNative.Player.Player_GetSyncedMetaData(NativePointer, stringPtr, ref value);
Marshal.FreeHGlobal(stringPtr);
}
//TODO: make call async because it doesnt matter there is no concurrent problems inside
//TODO: write function parser in cpp so it can do that natively without any native calls for mvalues (experimental)
//TODO: register event callbacks to cpp as dynamic function pointers with void** so cpp knows the types it needs to check
//TODO: add support for nullable args, these are reducing the required length, add support for default values as well
//TODO: maybe cache var invokeValues = new object[length];
internal MValue Call(IBaseBaseObjectPool baseBaseObjectPool, MValue[] values)
{
var length = values.Length;
if (length < requiredArgsCount)
{
return(MValue.Nil);
}
var argsLength = args.Length;
var invokeValues = new object[argsLength];
var parserValuesLength = Math.Min(argsLength, length);
for (var i = 0; i < parserValuesLength; i++)
{
invokeValues[i] = parsers[i](ref values[i], args[i], baseBaseObjectPool, typeInfos[i]);
}
for (var i = parserValuesLength; i < argsLength; i++)
{
invokeValues[i] = typeInfos[i].DefaultValue;
}
//TODO: fill remaining values in event params
var result = @delegate.DynamicInvoke(invokeValues);
if (returnType == FunctionTypes.Void)
{
return(MValue.Nil);
}
return(MValue.CreateFromObject(result));
}
public void RemoveVoice(MVoice voice)
{
for (int i = this._assignedParameters.Count - 1; i >= 0; i--)
{
MValue val = this._assignedParameters[i];
List <MVoice> voices;
if (this._valueAssignments.TryGetValue(val, out voices) == true)
{
voices.Remove(voice);
if (voices.Count == 0)
{
this._assignedParameters.Remove(val);
}
}
}
if (this._mods.ContainsKey(voice))
{
this._mods.Remove(voice);
}
if (this._triggers.ContainsKey(voice))
{
this._triggers.Remove(voice);
}
}
public void UpdateEntityData(INetworkingEntity entity, string key, MValue value)
{
lock (entity.StreamedInClients)
{
if (entity.StreamedInClients.Count <= 0)
{
return;
}
var entityDataChangeEvent = new EntityDataChangeEvent {
Id = entity.Id, Key = key, Value = value
};
var serverEvent = new ServerEvent {
DataChange = entityDataChangeEvent
};
var bytes = serverEvent.ToByteArray();
foreach (var streamedInClient in entity.StreamedInClients)
{
lock (streamedInClient)
{
if (streamedInClient.Exists)
{
streamedInClient.WebSocket?.SendAsync(bytes, true);
}
}
}
}
}
public void TriggerClientEvent(IPlayer player, string eventName, ref MValue args)
{
var mValueArray = MValueArray.Nil;
AltNative.MValueGet.MValue_GetList(ref args, ref mValueArray);
Alt.Module.OnClientEvent(player?.NativePointer ?? IntPtr.Zero, eventName, ref mValueArray);
}
public override void SetMetaData(string key, object value)
{
CheckIfEntityExists();
var mValue = MValue.CreateFromObject(value);
AltNative.Blip.Blip_SetMetaData(NativePointer, key, ref mValue);
}
public void TriggerClientEvent(IPlayer player, string eventName, ref MValue args)
{
var eventNamePtr = AltNative.StringUtils.StringToHGlobalUtf8(eventName);
TriggerClientEvent(player, eventNamePtr, ref args);
Marshal.FreeHGlobal(eventNamePtr);
}
public override void SafeAwake()
{
base.SafeAwake();
AddSpeedKey = /*BB.*/ AddKey(LanguageManager.Instance.CurrentLanguage.AddSpeed, "Add Speed", KeyCode.Equals);
ReduceSpeedKey = /*BB.*/ AddKey(LanguageManager.Instance.CurrentLanguage.ReduceSpeed, "Reduce Speed", KeyCode.Minus);
ChangeSpeedValue = /*BB.*/ AddValue(LanguageManager.Instance.CurrentLanguage.ChangeSpeed, "Change Speed", 0.1f);
}
public void TriggerServerEvent(string eventName, params object[] args)
{
var mValues = MValue.CreateFromObjects(args);
TriggerServerEvent(eventName, mValues);
MValue.Dispose(mValues);
}
public void TriggerServerEvent(string eventName, ref MValue args)
{
var eventNamePtr = AltNative.StringUtils.StringToHGlobalUtf8(eventName);
TriggerServerEvent(eventNamePtr, ref args);
Marshal.FreeHGlobal(eventNamePtr);
}
public override int GetHashCode()
{
int hashCode = -1007052003;
if (Id != null)
{
hashCode += Id.GetHashCode();
}
if (Type != null)
{
hashCode += Type.GetHashCode();
}
if (MValue != null)
{
hashCode += MValue.GetHashCode();
}
if (CreatedAt != null)
{
hashCode += CreatedAt.GetHashCode();
}
return(hashCode);
}
internal MValue Call(IPlayer player, IBaseBaseObjectPool baseBaseObjectPool, MValue[] values)
{
var length = values.Length;
if (length + 1 != args.Length)
{
return(MValue.Nil);
}
if (!typeInfos[0].IsPlayer)
{
return(MValue.Nil);
}
var invokeValues = new object[length + 1];
invokeValues[0] = player;
for (var i = 0; i < length; i++)
{
invokeValues[i + 1] =
parsers[i + 1](ref values[i], args[i + 1], baseBaseObjectPool, typeInfos[i + 1]);
}
var result = @delegate.DynamicInvoke(invokeValues);
if (returnType == FunctionTypes.Void)
{
return(MValue.Nil);
}
return(MValue.CreateFromObject(result));
}
public void TriggerServerEvent(string eventName, ref MValue args)
{
var mValueArray = MValueArray.Nil;
AltNative.MValueGet.MValue_GetList(ref args, ref mValueArray);
Alt.Module.OnServerEvent(eventName, ref mValueArray);
}
private static MValue ImportCall(MValue mValue, object[] args)
{
var mValueArgs = MValue.CreateFromObject(args);
var result = MValue.Nil;
AltNative.MValueCall.MValue_CallFunctionValue(ref mValue, ref mValueArgs, ref result);
return(result);
}
public void SetExport(string key, object value)
{
var stringPtr = AltNative.StringUtils.StringToHGlobalUtf8(key);
var mValue = MValue.CreateFromObject(value);
AltNative.Resource.Resource_SetExport(NativePointer, stringPtr, ref mValue);
Marshal.FreeHGlobal(stringPtr);
mValue.Dispose();
}
public static bool Import(string resourceName, string key, MValue.Type type, out MValue mValue)
{
if (Import(resourceName, key, out mValue) && mValue.type == type)
{
return(true);
}
throw new InvalidImportException(
$"Resource: '{resourceName}.{key}' with type: '{mValue.type}' doesn't matches the expected export type: '{type}'.");
}
internal MValue Invoke(object[] invokeValues)
{
var result = @delegate.DynamicInvoke(invokeValues);
if (returnType == FunctionTypes.Void)
{
return(MValue.Nil);
}
return(MValue.CreateFromObject(result));
}
public void RemoveValue(MValue val)
{
if (this._assignedParameters.Contains(val) == true)
{
this._assignedParameters.Remove(val);
// TODO: check if a voice has no assigned parameters anymore
_valueAssignments.Remove(val);
}
}
public void TriggerClientEvent(IPlayer player, string eventName, params object[] args)
{
if (args == null)
{
throw new ArgumentException("Arguments array should not be null.");
}
var mValues = MValue.CreateFromObjects(args);
TriggerClientEvent(player, eventName, mValues);
MValue.Dispose(mValues);
}
public bool GetExport(string key, ref MValue value)
{
var result = AltNative.Resource.Resource_GetExport(NativePointer, key, ref value);
if (!result)
{
return(false);
}
value.Dispose();
return(true);
}
public void TriggerServerEvent(IntPtr eventNamePtr, params object[] args)
{
if (args == null)
{
throw new ArgumentException("Arguments array should not be null.");
}
var mValues = MValue.CreateFromObjects(args);
TriggerServerEvent(eventNamePtr, mValues);
MValue.Dispose(mValues);
}
internal static MValue[] CreateFromObjectsLocked(object[] objects)
{
var length = objects.Length;
var mValues = new MValue[length];
for (var i = 0; i < length; i++)
{
mValues[i] = CreateFromObjectLocked(objects[i]);
}
return(mValues);
}
public MRef Create(string name, MValue init) // create a reference to *core reference*.
{
// When create someting, we create a reference to *core reference*,
// or directly create a *core reference*.
// Notice MRef itself is reference type.
var t = init is MRef r ? r.downref : new MRef()
{
target = init
};
Add(name, t);
return(t);
}
public MValue[] ToArray()
{
var value = data;
var values = new MValue[Size];
for (var i = 0; i < values.Length; i++)
{
values[i] = Marshal.PtrToStructure <MValue>(value);
value += MValue.Size;
}
return(values);
}
