private void OnChatMessageParser(IPlayer player, ref MValueArray mValueArray,
Action <IPlayer, string> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
if (!reader.GetNext(out string message))
{
return;
}
/*if (!reader.GetNext(out MValueArray mValueArgs)) return;
* var argsCount = (int) mValueArgs.Size;
* var args = new string[argsCount];
* var argsReader = mValueArgs.Reader();
* for (var i = 0; i < argsCount; i++)
* {
* if (!argsReader.GetNext(out string currArg)) return;
* args[i] = currArg;
* }*/
func(player, message);
}
public bool GetNext(out StringViewArray keys, out MValueArray values)
{
if (size == 0)
{
keys = default;
values = default;
return(false);
}
var mValue = Marshal.PtrToStructure <MValue>(data);
data += MValue.Size;
size--;
if (mValue.type != MValue.Type.DICT)
{
keys = default;
values = default;
return(false);
}
var stringViewArray = StringViewArray.Nil;
var valueArrayRef = MValueArray.Nil;
AltNative.MValueGet.MValue_GetDict(ref mValue, ref stringViewArray, ref valueArrayRef);
keys = stringViewArray;
values = valueArrayRef;
return(true);
}
public MValueObjectReader(StringArray stringArray, MValueArray mValueArray)
{
this.stringArray = stringArray;
this.mValueArray = mValueArray;
mValueArrayBuffer = mValueArray.Reader();
stringArrayOffset = this.stringArray.data;
size = this.stringArray.size;
}
public void MyParser6(IPlayer player, ref MValueArray mValueArray, Action <IPlayer, IMyVehicle> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
if (!reader.GetNext(out IMyVehicle vehicle))
{
return;
}
func(player, vehicle);
}
public void MyServerEventParser(ref MValueArray mValueArray, Action <string> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
if (!reader.GetNext(out string value))
{
return;
}
func(value);
}
public void MyServerEventParserAsync(ref MValueArray mValueArray, Action <IMyVehicle> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
if (!reader.GetNext(out IMyVehicle vehicle))
{
return;
}
Task.Run(() => func(vehicle));
}
public void MyParser4(IPlayer player, ref MValueArray mValueArray, Action <IPlayer, string> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
if (!reader.GetNext(out string value))
{
return;
}
func(player, value);
}
public void MyParser(IPlayer player, ref MValueArray mValueArray, Action <IPlayer, string> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
var mValue = reader.GetNext();
if (mValue.type != MValue.Type.STRING)
{
return;
}
func(player, mValue.GetString());
}
public void MyParser5(IPlayer player, ref MValueArray mValueArray, Action <IPlayer, string[]> func)
{
if (mValueArray.Size != 1)
{
return;
}
var reader = mValueArray.Reader();
if (!reader.GetNext(out MValueArray values))
{
return;
}
var strings = new string[values.Size];
var valuesReader = values.Reader();
var i = 0;
while (valuesReader.GetNext(out string value))
{
strings[i++] = value;
}
func(player, strings);
}
public bool GetNext(out MValueArray values)
{
if (size == 0)
{
values = default;
return(false);
}
var mValue = Marshal.PtrToStructure <MValue>(data);
data += MValue.Size;
size--;
if (mValue.type != MValue.Type.LIST)
{
values = default;
return(false);
}
var valueArrayRef = MValueArray.Nil;
AltNative.MValueGet.MValue_GetList(ref mValue, ref valueArrayRef);
values = valueArrayRef;
return(true);
}
public virtual void OnServerEventEvent(string name, ref MValueArray args, MValue[] mValues, object[] objects)
{
}
public void OnServerEvent(string name, ref MValueArray args)
{
if (parserServerEventHandlers.Count != 0 &&
parserServerEventHandlers.TryGetValue(name, out var parserEventHandlers))
{
foreach (var parserEventHandler in parserEventHandlers)
{
parserEventHandler.Call(ref args);
}
}
MValue[] argArray = null;
if (this.eventHandlers.Count != 0 && this.eventHandlers.TryGetValue(name, out var eventHandlers))
{
argArray = args.ToArray();
foreach (var eventHandler in eventHandlers)
{
try
{
eventHandler.Call(BaseBaseObjectPool, argArray);
}
catch (TargetInvocationException exception)
{
Alt.Log("exception at event:" + name + ":" + exception.InnerException);
}
catch (Exception exception)
{
Alt.Log("exception at event:" + name + ":" + exception);
}
}
}
object[] argObjects = null;
if (eventDelegateHandlers.Count != 0 && eventDelegateHandlers.TryGetValue(name, out var eventDelegates))
{
if (argArray == null)
{
argArray = args.ToArray();
}
var length = argArray.Length;
argObjects = new object[length];
for (var i = 0; i < length; i++)
{
argObjects[i] = argArray[i].ToObject(BaseBaseObjectPool);
}
foreach (var eventHandler in eventDelegates)
{
eventHandler(argObjects);
}
}
if (ServerEventEventHandler.HasEvents())
{
if (argArray == null)
{
argArray = args.ToArray();
}
if (argObjects == null)
{
var length = argArray.Length;
argObjects = new object[length];
for (var i = 0; i < length; i++)
{
argObjects[i] = argArray[i].ToObject(BaseBaseObjectPool);
}
}
foreach (var eventHandler in ServerEventEventHandler.GetEvents())
{
eventHandler(name, argObjects);
}
}
if (ServerCustomEventEventHandler.HasEvents())
{
foreach (var eventHandler in ServerCustomEventEventHandler.GetEvents())
{
eventHandler(name, ref args);
}
}
OnServerEventEvent(name, ref args, argArray, argObjects);
}
public void Call(IPlayer player, ref MValueArray mValueArray)
{
clientEventParser(player, ref mValueArray, @delegate);
}
public override void OnClientEventEvent(IPlayer player, string name, ref MValueArray args, MValue[] mValues,
object[] objects)
{
base.OnClientEventEvent(player, name, ref args, mValues, objects);
if (AsyncEventHandlers.Count != 0 && AsyncEventHandlers.TryGetValue(name, out var eventHandlers))
{
if (mValues == null)
{
mValues = args.ToArray();
}
if (objects == null)
{
var length = mValues.Length;
objects = new object[length];
for (var i = 0; i < length; i++)
{
objects[i] = mValues[i].ToObject(BaseBaseObjectPool);
}
}
Task.Run(() =>
{
foreach (var eventHandler in eventHandlers)
{
var invokeValues = eventHandler.CalculateInvokeValues(objects);
if (invokeValues != null)
{
eventHandler.InvokeNoResult(invokeValues);
}
else
{
AltAsync.Log("Wrong function params for " + name);
}
}
});
}
if (clientEventAsyncDelegateHandlers.Count != 0 &&
clientEventAsyncDelegateHandlers.TryGetValue(name, out var eventDelegates))
{
if (mValues == null)
{
mValues = args.ToArray();
}
if (objects == null)
{
var length = mValues.Length;
objects = new object[length];
for (var i = 0; i < length; i++)
{
objects[i] = mValues[i].ToObject(BaseBaseObjectPool);
}
}
Task.Run(() =>
{
foreach (var eventHandler in eventDelegates)
{
AsyncEventHandler <ClientEventAsyncDelegate> .ExecuteEventAsyncWithoutTask(eventHandler,
@delegate => @delegate(player, objects));
}
});
}
if (PlayerClientEventAsyncEventHandler.HasEvents())
{
if (mValues == null)
{
mValues = args.ToArray();
}
if (objects == null)
{
var length = mValues.Length;
objects = new object[length];
for (var i = 0; i < length; i++)
{
objects[i] = mValues[i].ToObject(BaseBaseObjectPool);
}
}
Task.Run(() =>
{
foreach (var eventHandler in PlayerClientEventAsyncEventHandler.GetEvents())
{
AsyncEventHandler <PlayerClientEventAsyncDelegate> .ExecuteEventAsyncWithoutTask(eventHandler,
@delegate => @delegate(player, name, objects));
}
});
}
}
public MValueArrayReader(MValueArray mValueArray)
{
this.mValueArray = mValueArray;
mValueArrayBuffer = mValueArray.Reader();
size = mValueArrayBuffer.size;
}
public void BeginArray()
{
var currentArr = new MValueArray(new List <object>());
currents.Push(currentArr);
}
public static void OnClientEvent(IntPtr playerPointer, string name, ref MValueArray args)
{
_module.OnClientEvent(playerPointer, name, ref args);
}
public void GetList(ref MValueArray mValueArray)
{
AltNative.MValueGet.MValue_GetList(ref this, ref mValueArray);
}
public virtual void OnClientEventEvent(IPlayer player, string name, ref MValueArray args, MValue[] mValues,
object[] objects)
{
}
public static void OnServerEvent(string name, ref MValueArray args)
{
_module.OnServerEvent(name, ref args);
}
public void Call(ref MValueArray mValueArray)
{
serverEventParser(ref mValueArray, @delegate);
}
public override void OnServerEventEvent(string name, ref MValueArray args, MValue[] mValues, object[] objects)
{
base.OnServerEventEvent(name, ref args, mValues, objects);
if (AsyncEventHandlers.Count != 0 && AsyncEventHandlers.TryGetValue(name, out var eventHandlers))
{
if (mValues == null)
{
mValues = args.ToArray();
}
if (objects == null)
{
var length = mValues.Length;
objects = new object[length];
for (var i = 0; i < length; i++)
{
objects[i] = mValues[i].ToObject(BaseBaseObjectPool);
}
}
Task.Run(async() =>
{
foreach (var eventHandler in eventHandlers)
{
var invokeValues = eventHandler.CalculateInvokeValues(objects);
if (invokeValues != null)
{
try
{
var task = eventHandler.InvokeTaskOrNull(invokeValues);
if (task != null)
{
await task;
}
}
catch (Exception e)
{
AltAsync.Log($"Execution of {name} threw an error: {e}");
}
}
else
{
AltAsync.Log("Wrong function params for " + name);
}
}
});
}
if (serverEventAsyncDelegateHandlers.Count != 0 &&
serverEventAsyncDelegateHandlers.TryGetValue(name, out var eventDelegates))
{
if (mValues == null)
{
mValues = args.ToArray();
}
if (objects == null)
{
var length = mValues.Length;
objects = new object[length];
for (var i = 0; i < length; i++)
{
objects[i] = mValues[i].ToObject(BaseBaseObjectPool);
}
}
Task.Run(() =>
{
foreach (var eventHandler in eventDelegates)
{
AsyncEventHandler <ServerEventAsyncDelegate> .ExecuteEventAsyncWithoutTask(eventHandler,
@delegate => @delegate(objects));
}
});
}
}
public void OnClientEvent(IntPtr playerPointer, string name, ref MValueArray args)
{
if (!PlayerPool.GetOrCreate(playerPointer, out var player))
{
return;
}
if (parserClientEventHandlers.Count != 0 &&
parserClientEventHandlers.TryGetValue(name, out var parserEventHandlers))
{
foreach (var parserEventHandler in parserEventHandlers)
{
parserEventHandler.Call(player, ref args);
}
}
MValue[] argArray = null;
if (this.eventHandlers.Count != 0 && this.eventHandlers.TryGetValue(name, out var eventHandlers))
{
argArray = args.ToArray();
foreach (var eventHandler in eventHandlers)
{
eventHandler.Call(player, BaseBaseObjectPool, argArray);
}
}
object[] argObjects = null;
if (clientEventDelegateHandlers.Count != 0 &&
clientEventDelegateHandlers.TryGetValue(name, out var eventDelegates))
{
if (argArray == null)
{
argArray = args.ToArray();
}
var length = argArray.Length;
argObjects = new object[length];
for (var i = 0; i < length; i++)
{
argObjects[i] = argArray[i].ToObject(BaseBaseObjectPool);
}
foreach (var eventHandler in eventDelegates)
{
eventHandler(player, argObjects);
}
}
if (PlayerClientEventEventHandler.HasEvents())
{
if (argArray == null)
{
argArray = args.ToArray();
}
if (argObjects == null)
{
var length = argArray.Length;
argObjects = new object[length];
for (var i = 0; i < length; i++)
{
argObjects[i] = argArray[i].ToObject(BaseBaseObjectPool);
}
}
foreach (var eventHandler in PlayerClientEventEventHandler.GetEvents())
{
eventHandler(player, name, argObjects);
}
}
if (PlayerClientCustomEventEventHandler.HasEvents())
{
foreach (var eventHandler in PlayerClientCustomEventEventHandler.GetEvents())
{
eventHandler(player, name, ref args);
}
}
OnClientEventEvent(player, name, ref args, argArray, argObjects);
}
