finish

api/AltV.Net.Async/AltAsync.Off.cs

@@ -3,9 +3,9 @@ namespace AltV.Net.Async
     public partial class AltAsync
     {
         public static void OffServer(string eventName, Function function) =>
-            Core.OffServer(eventName, function);
+            CoreImpl.OffServer(eventName, function);
 
         public static void OffClient(string eventName, Function function) =>
-            Core.OffClient(eventName, function);
+            CoreImpl.OffClient(eventName, function);
     }
 }

api/AltV.Net.Async/AltAsync.RegisterEvents.cs

@@ -727,11 +727,11 @@ public static void RegisterEvents(object target)
                             break;
                         case AsyncServerEventAttribute @event:
                             var serverEventName = @event.Name ?? eventMethod.Name;
-                            Core.OnServer(serverEventName, Function.Create(Core, eventMethodDelegate));
+                            CoreImpl.OnServer(serverEventName, Function.Create(CoreImpl, eventMethodDelegate));
                             break;
                         case AsyncClientEventAttribute @event:
                             var clientEventName = @event.Name ?? eventMethod.Name;
-                            Core.OnClient(clientEventName, Function.Create(Core, eventMethodDelegate));
+                            CoreImpl.OnClient(clientEventName, Function.Create(CoreImpl, eventMethodDelegate));
                             break;
                     }
                 });

api/AltV.Net.Client.Async/AltAsync.cs

@@ -7,6 +7,7 @@ public static partial class AltAsync
         // internal static AsyncCore Core;
 
         internal static AltVAsync AltVAsync;
+        internal static ICore CoreImpl;
 
         // public static async void Log(string message)
         // {
@@ -58,27 +59,27 @@ internal static void Setup(AltVAsync altVAsync)
             AltVAsync = altVAsync;
         }
 
-        // internal static void Setup(AsyncCore core)
-        // {
-        //     Core = core;
-        // }
+        internal static void Setup(Core core)
+        {
+            CoreImpl = core;
+        }
 
         public static Task Do(Action action)
         {
             CheckIfAsyncResource();
             return AltVAsync.Schedule(action);
         }
-        
+
         public static Task Do(Task task)
         {
             throw new ArgumentException("AltAsync.Do should never have async code inside");
         }
-        
+
         public static Task Do(Func<Task> task)
         {
             throw new ArgumentException("AltAsync.Do should never have async code inside");
         }
-        
+
         public static void RunOnMainThreadBlocking(Action action, SemaphoreSlim semaphoreSlim)
         {
             CheckIfAsyncResource();
@@ -125,27 +126,27 @@ public class MainThreadContext : IAsyncDisposable
         {
             public async ValueTask DisposeAsync()
             {
-                if (!Alt.Core.IsMainThread()) throw new Exception("ReturnToMainThread using block was exited on a non-main thread");
+                if (!CoreImpl.IsMainThread()) throw new Exception("ReturnToMainThread using block was exited on a non-main thread");
                 await Task.Run(() => {}); // jump to bg thread
             }
 
             private MainThreadContext()
             {
             }
-            
+
             internal static readonly MainThreadContext Instance = new();
         }
 
         public static async Task<MainThreadContext> ReturnToMainThread()
         {
-            if (Alt.Core.IsMainThread()) return MainThreadContext.Instance;
+            if (CoreImpl.IsMainThread()) return MainThreadContext.Instance;
             var source = new TaskCompletionSource();
             RunOnMainThread(() => source.SetResult());
             await source.Task;
             return MainThreadContext.Instance;
         }
-        
-        
+
+
         public static async Task WaitFor(Func<bool> fn, uint timeout = 2000, uint interval = 0)
         {
             var checkUntil = DateTime.Now.AddMilliseconds(timeout);
@@ -164,7 +165,7 @@ public static async Task WaitFor(Func<bool> fn, uint timeout = 2000, uint interv
                 source.SetException(new TimeoutException("Failed to wait for callback"));
                 Alt.ClearInterval(handle);
             }, interval);
-            
+
             await source.Task;
         }
     }

api/AltV.Net.Client.Async/AsyncResource.cs

@@ -1,5 +1,7 @@
 using System.Runtime.Loader;
 using AltV.Net.CApi;
+using AltV.Net.Client.Elements.Interfaces;
+using AltV.Net.Client.Elements.Pools;
 
 namespace AltV.Net.Client.Async
 {
@@ -60,17 +62,5 @@ public override void OnTick()
         //     return new AsyncColShapePool(colShapeFactory);
         // }
         //
-        // public override Core GetCore(IntPtr nativePointer, IntPtr resourcePointer, AssemblyLoadContext assemblyLoadContext, ILibrary library, IBaseBaseObjectPool baseBaseObjectPool,
-        //     IBaseEntityPool baseEntityPool,
-        //     IEntityPool<IPlayer> playerPool,
-        //     IEntityPool<IVehicle> vehiclePool,
-        //     IBaseObjectPool<IBlip> blipPool,
-        //     IBaseObjectPool<ICheckpoint> checkpointPool,
-        //     IBaseObjectPool<IVoiceChannel> voiceChannelPool,
-        //     IBaseObjectPool<IColShape> colShapePool,
-        //     INativeResourcePool nativeResourcePool)
-        // {
-        //     return new AsyncCore(nativePointer, resourcePointer, assemblyLoadContext, library, baseBaseObjectPool, baseEntityPool, playerPool, vehiclePool, blipPool, checkpointPool, voiceChannelPool, colShapePool, nativeResourcePool);
-        // }
     }
 }

api/AltV.Net.Client/ModuleWrapper.cs

@@ -114,7 +114,7 @@ public static void MainWithAssembly(Assembly resourceAssembly, IntPtr resourcePo
 
             _core = client;
             Alt.CoreImpl = client;
-            AltShared.Core = client;
+            AltShared.CoreImpl = client;
             Alt.Log("Core initialized");
 
             _core.GetAllPlayers();

api/AltV.Net.Shared/AltShared.cs

@@ -9,9 +9,9 @@ namespace AltV.Net.Shared
 {
     public static class AltShared
     {
-        public static ISharedCore Core { get; set; }
-        public static uint Hash(string key) => Core.Hash(key);
+        internal static ISharedCore CoreImpl { get; set; }
+        public static uint Hash(string key) => CoreImpl.Hash(key);
         public static bool CacheEntities = true;
-        public static void EmitLocal(string eventName, params object[] args) => Core.TriggerLocalEvent(eventName, args);
+        public static void EmitLocal(string eventName, params object[] args) => CoreImpl.TriggerLocalEvent(eventName, args);
     }
 }

api/AltV.Net.Shared/Elements/Args/MValueBuffer2.cs

@@ -17,8 +17,8 @@ public struct MValueBuffer2
         public int size;
 
         [Obsolete("Use Alt.CreateMValueBuffer or overload with ISharedCore argument instead")]
-        public MValueBuffer2(MValueConst[] values) : this(AltShared.Core, values) {
-            AltShared.Core.LogWarning("new MValueBuffer2(MValueConst[]) is deprecated, use Alt.CreateMValueBuffer or overload with ISharedCore argument instead");
+        public MValueBuffer2(MValueConst[] values) : this(AltShared.CoreImpl, values) {
+            AltShared.CoreImpl.LogWarning("new MValueBuffer2(MValueConst[]) is deprecated, use Alt.CreateMValueBuffer or overload with ISharedCore argument instead");
         }
 
         public MValueBuffer2(ISharedCore core, MValueConst[] values)

api/AltV.Net.Shared/Elements/Args/MValueWriter2.cs

@@ -14,9 +14,9 @@ public class MValueWriter2 : IMValueWriter
         private readonly ISharedCore core;
 
         [Obsolete("Use Alt.CreateMValueWriter or overload with ISharedCore argument instead")]
-        public MValueWriter2() : this(AltShared.Core)
+        public MValueWriter2() : this(AltShared.CoreImpl)
         {
-            AltShared.Core.LogWarning("new MValueWriter2() is deprecated, use Alt.CreateMValueWriter or overload with ISharedCore argument instead");
+            AltShared.CoreImpl.LogWarning("new MValueWriter2() is deprecated, use Alt.CreateMValueWriter or overload with ISharedCore argument instead");
         }
 
         public MValueWriter2(ISharedCore core)
@@ -43,7 +43,7 @@ public struct MValueObject : IWritableMValue
             public List<object> Values { get; }
 
             [Obsolete("Use overload with core as first parameter instead")]
-            public MValueObject(List<string> names, List<object> values) : this(AltShared.Core, names, values)
+            public MValueObject(List<string> names, List<object> values) : this(AltShared.CoreImpl, names, values)
             {
             }
 
@@ -91,7 +91,7 @@ public struct MValueArray : IWritableMValue
 
 
             [Obsolete("Use overload with core as first parameter instead")]
-            public MValueArray(List<object> values) : this(AltShared.Core, values)
+            public MValueArray(List<object> values) : this(AltShared.CoreImpl, values)
             {
             }
             public MValueArray(ISharedCore core, List<object> values)

api/AltV.Net.Shared/Events/HashSetEventHandler.cs

@@ -2,7 +2,7 @@ namespace AltV.Net.Shared.Events
 {
     internal class HashSetEventHandler<TEvent> : IEventHandler<TEvent>
     {
-        private ISharedCore core => AltShared.Core; // todo pass core to constructor
+        private ISharedCore core => AltShared.CoreImpl; // todo pass core to constructor
         private readonly EventType? type;
         private readonly HashSet<TEvent> events = new();