Add synced methods to player weapons

Author: Timschuu

src/AlternateLife.RageMP.Net/Elements/Entities/Player.Weapons.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -11,111 +10,171 @@ namespace AlternateLife.RageMP.Net.Elements.Entities
 {
     internal partial class Player
     {
-        public async Task SetCurrentWeaponAsync(uint value)
+        public void SetCurrentWeapon(uint value)
         {
             CheckExistence();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_SetCurrentWeapon(NativePointer, value))
-                .ConfigureAwait(false);
+            Rage.Player.Player_SetCurrentWeapon(NativePointer, value);
         }
 
-        public async Task<uint> GetCurrentWeaponAsync()
+        public Task SetCurrentWeaponAsync(uint value)
+        {
+            return _plugin.Schedule(() => SetCurrentWeapon(value));
+        }
+
+        public uint GetCurrentWeapon()
         {
             CheckExistence();
 
-            return await _plugin
-                .Schedule(() => Rage.Player.Player_GetCurrentWeapon(NativePointer))
-                .ConfigureAwait(false);
+            return Rage.Player.Player_GetCurrentWeapon(NativePointer);
+        }
+
+        public Task<uint> GetCurrentWeaponAsync()
+        {
+            return _plugin.Schedule(GetCurrentWeapon);
         }
 
-        public async Task SetCurrentWeaponAmmoAsync(uint value)
+        public void SetCurrentWeaponAmmo(uint value)
         {
             CheckExistence();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_SetCurrentWeaponAmmo(NativePointer, value))
-                .ConfigureAwait(false);
+            Rage.Player.Player_SetCurrentWeaponAmmo(NativePointer, value);
         }
 
-        public async Task<uint> GetCurrentWeaponAmmoAsync()
+        public Task SetCurrentWeaponAmmoAsync(uint value)
+        {
+            return _plugin.Schedule(() => SetCurrentWeaponAmmo(value));
+        }
+
+        public uint GetCurrentWeaponAmmo()
         {
             CheckExistence();
 
-            return await _plugin
-                .Schedule(() => Rage.Player.Player_GetCurrentWeaponAmmo(NativePointer))
-                .ConfigureAwait(false);
+            return Rage.Player.Player_GetCurrentWeaponAmmo(NativePointer);
+        }
+
+        public Task<uint> GetCurrentWeaponAmmoAsync()
+        {
+            return _plugin.Schedule(GetCurrentWeaponAmmo);
         }
 
-        public async Task<uint> GetWeaponAmmoAsync(WeaponHash weaponHash)
+        public uint GetWeaponAmmo(WeaponHash weaponHash)
         {
             CheckExistence();
 
-            return await _plugin
-                .Schedule(() => Rage.Player.Player_GetWeaponAmmo(NativePointer, (uint) weaponHash))
-                .ConfigureAwait(false);
+            return Rage.Player.Player_GetWeaponAmmo(NativePointer, (uint) weaponHash);
+        }
+
+        public Task<uint> GetWeaponAmmoAsync(WeaponHash weaponHash)
+        {
+            return _plugin.Schedule(() => GetWeaponAmmo(weaponHash));
+        }
+
+        public uint GetWeaponAmmo(uint weapon)
+        {
+            return GetWeaponAmmo((WeaponHash) weapon);
         }
 
         public Task<uint> GetWeaponAmmoAsync(uint weapon)
         {
             return GetWeaponAmmoAsync((WeaponHash) weapon);
         }
 
-        public async Task<int> GetWeaponAmmoAsync(int weapon)
+        public int GetWeaponAmmo(int weapon)
         {
-            return (int) await GetWeaponAmmoAsync((WeaponHash) weapon)
-                .ConfigureAwait(false);
+            return (int) GetWeaponAmmo((WeaponHash) weapon);
         }
 
-        public async Task SetWeaponAmmoAsync(WeaponHash weaponHash, uint ammo)
+        public Task<int> GetWeaponAmmoAsync(int weapon)
+        {
+            return _plugin.Schedule(() => GetWeaponAmmo(weapon));
+        }
+
+        public void SetWeaponAmmo(WeaponHash weaponHash, uint ammo)
         {
             CheckExistence();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_SetWeaponAmmo(NativePointer, (uint) weaponHash, ammo))
-                .ConfigureAwait(false);
+            Rage.Player.Player_SetWeaponAmmo(NativePointer, (uint) weaponHash, ammo);
+        }
+
+        public Task SetWeaponAmmoAsync(WeaponHash weaponHash, uint ammo)
+        {
+            return _plugin.Schedule(() => SetWeaponAmmo(weaponHash, ammo));
+        }
+
+        public void SetWeaponAmmo(WeaponHash weapon, int ammo)
+        {
+            SetWeaponAmmo(weapon, (uint) ammo);
         }
 
         public Task SetWeaponAmmoAsync(WeaponHash weapon, int ammo)
         {
             return SetWeaponAmmoAsync(weapon, (uint) ammo);
         }
 
+        public void SetWeaponAmmo(uint weapon, uint ammo)
+        {
+            SetWeaponAmmo((WeaponHash) weapon, ammo);
+        }
+
         public Task SetWeaponAmmoAsync(uint weapon, uint ammo)
         {
             return SetWeaponAmmoAsync((WeaponHash) weapon, ammo);
         }
 
+        public void SetWeaponAmmo(int weapon, int ammo)
+        {
+            SetWeaponAmmo((WeaponHash) weapon, (uint) ammo);
+        }
+
         public Task SetWeaponAmmoAsync(int weapon, int ammo)
         {
             return SetWeaponAmmoAsync((WeaponHash) weapon, (uint) ammo);
         }
 
-        public async Task GiveWeaponAsync(WeaponHash weaponHash, uint ammo)
+        public void GiveWeapon(WeaponHash weaponHash, uint ammo)
         {
             CheckExistence();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_GiveWeapon(NativePointer, (uint) weaponHash, ammo))
-                .ConfigureAwait(false);
+            Rage.Player.Player_GiveWeapon(NativePointer, (uint) weaponHash, ammo);
+        }
+
+        public Task GiveWeaponAsync(WeaponHash weaponHash, uint ammo)
+        {
+            return _plugin.Schedule(() => GiveWeapon(weaponHash, ammo));
+        }
+
+        public void GiveWeapon(WeaponHash weapon, int ammo)
+        {
+            GiveWeapon(weapon, (uint) ammo);
         }
 
         public Task GiveWeaponAsync(WeaponHash weapon, int ammo)
         {
             return GiveWeaponAsync(weapon, (uint) ammo);
         }
 
+        public void GiveWeapon(uint weapon, uint ammo)
+        {
+            GiveWeapon((WeaponHash) weapon, ammo);
+        }
+
         public Task GiveWeaponAsync(uint weapon, uint ammo)
         {
             return GiveWeaponAsync((WeaponHash) weapon, ammo);
         }
 
+        public void GiveWeapon(int weapon, int ammo)
+        {
+            GiveWeapon((WeaponHash) weapon, (uint) ammo);
+        }
+
         public Task GiveWeaponAsync(int weapon, int ammo)
         {
             return GiveWeaponAsync((WeaponHash) weapon, (uint) ammo);
         }
 
-        public async Task GiveWeaponsAsync(IDictionary<WeaponHash, uint> weapons)
+        public void GiveWeapons(IDictionary<WeaponHash, uint> weapons)
         {
             Contract.NotNull(weapons, nameof(weapons));
             CheckExistence();
@@ -125,87 +184,128 @@ public async Task GiveWeaponsAsync(IDictionary<WeaponHash, uint> weapons)
             var hashes = weapons.Keys.Select(x => (uint) x).ToArray();
             var ammo = weapons.Values.ToArray();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_GiveWeapons(NativePointer, hashes, ammo, (ulong) count))
-                .ConfigureAwait(false);
+            Rage.Player.Player_GiveWeapons(NativePointer, hashes, ammo, (ulong) count);
+        }
+
+        public Task GiveWeaponsAsync(IDictionary<WeaponHash, uint> weapons)
+        {
+            return _plugin.Schedule(() => GiveWeapons(weapons));
+        }
+
+        public void GiveWeapons(IDictionary<WeaponHash, int> weapons)
+        {
+            GiveWeapons(weapons.ToDictionary(x => x.Key, x => (uint) x.Value));
         }
 
         public Task GiveWeaponsAsync(IDictionary<WeaponHash, int> weapons)
         {
             return GiveWeaponsAsync(weapons.ToDictionary(x => x.Key, x => (uint) x.Value));
         }
 
+        public void GiveWeapons(IDictionary<uint, uint> weapons)
+        {
+            GiveWeapons(weapons.ToDictionary(x => (WeaponHash) x.Key, x => x.Value));
+        }
+
         public Task GiveWeaponsAsync(IDictionary<uint, uint> weapons)
         {
             return GiveWeaponsAsync(weapons.ToDictionary(x => (WeaponHash) x.Key, x => x.Value));
         }
 
+        public void GiveWeapons(IDictionary<int, int> weapons)
+        {
+            GiveWeapons(weapons.ToDictionary(x => (WeaponHash) x.Key, x => (uint) x.Value));
+        }
+
         public Task GiveWeaponsAsync(IDictionary<int, int> weapons)
         {
             return GiveWeaponsAsync(weapons.ToDictionary(x => (WeaponHash) x.Key, x => (uint) x.Value));
         }
 
-        public async Task RemoveWeaponAsync(WeaponHash weaponHash)
+        public void RemoveWeapon(WeaponHash weaponHash)
         {
             CheckExistence();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_RemoveWeapon(NativePointer, (uint) weaponHash))
-                .ConfigureAwait(false);
+            Rage.Player.Player_RemoveWeapon(NativePointer, (uint) weaponHash);
+        }
+
+        public Task RemoveWeaponAsync(WeaponHash weaponHash)
+        {
+            return _plugin.Schedule(() => RemoveWeapon(weaponHash));
+        }
+
+        public void RemoveWeapon(uint weapon)
+        {
+            RemoveWeapon((WeaponHash) weapon);
         }
 
         public Task RemoveWeaponAsync(uint weapon)
         {
             return RemoveWeaponAsync((WeaponHash) weapon);
         }
 
+        public void RemoveWeapon(int weapon)
+        {
+            RemoveWeapon((WeaponHash) weapon);
+        }
+
         public Task RemoveWeaponAsync(int weapon)
         {
             return RemoveWeaponAsync((WeaponHash) weapon);
         }
 
-        public async Task RemoveWeaponsAsync(IEnumerable<uint> weaponHashes)
+        public void RemoveWeapons(IEnumerable<uint> weaponHashes)
         {
             Contract.NotNull(weaponHashes, nameof(weaponHashes));
             CheckExistence();
 
             var weapons = weaponHashes.ToArray();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_RemoveWeapons(NativePointer, weapons, (ulong) weapons.LongLength))
-                .ConfigureAwait(false);
+            Rage.Player.Player_RemoveWeapons(NativePointer, weapons, (ulong) weapons.LongLength);
+        }
+        
+        public Task RemoveWeaponsAsync(IEnumerable<uint> weaponHashes)
+        {
+            return _plugin.Schedule(() => RemoveWeapons(weaponHashes));
         }
 
+        public void RemoveWeapons(IEnumerable<WeaponHash> weaponHashes)
+        {
+            RemoveWeapons(weaponHashes.Select(x => (uint) x));
+        }
+        
         public Task RemoveWeaponsAsync(IEnumerable<WeaponHash> weaponHashes)
         {
             return RemoveWeaponsAsync(weaponHashes.Select(x => (uint) x));
         }
 
+        public void RemoveWeapons(IEnumerable<int> weaponHashes)
+        {
+            RemoveWeapons(weaponHashes.Select(x => (uint) x));
+        }
+        
         public Task RemoveWeaponsAsync(IEnumerable<int> weaponHashes)
         {
             return RemoveWeaponsAsync(weaponHashes.Select(x => (uint) x));
         }
 
-        public async Task RemoveAllWeaponsAsync()
+        public void RemoveAllWeapons()
         {
             CheckExistence();
 
-            await _plugin
-                .Schedule(() => Rage.Player.Player_RemoveAllWeapons(NativePointer))
-                .ConfigureAwait(false);
+            Rage.Player.Player_RemoveAllWeapons(NativePointer);
+        }
+        
+        public Task RemoveAllWeaponsAsync()
+        {
+            return _plugin.Schedule(RemoveAllWeapons);
         }
 
-        public async Task<IReadOnlyDictionary<WeaponHash, uint>> GetWeaponsAsync()
+        public IReadOnlyDictionary<WeaponHash, uint> GetWeapons()
         {
             CheckExistence();
 
-            IntPtr weapons = IntPtr.Zero;
-            IntPtr ammo = IntPtr.Zero;
-            ulong count = 0;
-
-            await _plugin
-                .Schedule(() => Rage.Player.Player_GetWeapons(NativePointer, out weapons, out ammo, out count))
-                .ConfigureAwait(false);
+            Rage.Player.Player_GetWeapons(NativePointer, out var weapons, out var ammo, out var count);
 
             var allWeapons = new Dictionary<WeaponHash, uint>();
 
@@ -219,5 +319,10 @@ await _plugin
 
             return allWeapons;
         }
+        
+        public Task<IReadOnlyDictionary<WeaponHash, uint>> GetWeaponsAsync()
+        {
+            return _plugin.Schedule(GetWeapons);
+        }
     }
 }

src/AlternateLife.RageMP.Net/Interfaces/IPlayer.cs

@@ -1622,7 +1622,7 @@ Task SetCustomizationAsync(bool isMale, HeadBlendData headBlend, int eyeColor, i
         /// </summary>
         /// <param name="weapon">Weapon to remove</param>
         /// <exception cref="EntityDeletedException">This entity was deleted before</exception>
-        Task RemoveWeapon(WeaponHash weapon);
+        void RemoveWeapon(WeaponHash weapon);
 
         /// <summary>
         /// Remove a weapon from the player.