Reduce load on schedule calls in many entity classes

markatk · markatk · commit c6cdeec842d0 · 2019-03-09T22:10:35.000+01:00
diff --git a/src/AlternateLife.RageMP.Net/Elements/Entities/Blip.cs b/src/AlternateLife.RageMP.Net/Elements/Entities/Blip.cs
@@ -19,70 +19,90 @@ public async Task SetDrawDistanceAsync(float value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Blip.Blip_SetDrawDistance(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Blip.Blip_SetDrawDistance(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<float> GetDrawDistanceAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Blip.Blip_GetDrawDistance(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Blip.Blip_GetDrawDistance(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetRotationAsync(int value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Blip.Blip_SetRotation(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Blip.Blip_SetRotation(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public new async Task<int> GetRotationAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Blip.Blip_GetRotation(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Blip.Blip_GetRotation(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetShortRangeAsync(bool value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Blip.Blip_SetShortRange(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Blip.Blip_SetShortRange(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<bool> GetShortRangeAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Blip.Blip_IsShortRange(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Blip.Blip_IsShortRange(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetColorAsync(uint value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Blip.Blip_SetColor(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Blip.Blip_SetColor(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<uint> GetColorAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Blip.Blip_GetColor(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Blip.Blip_GetColor(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetScaleAsync(float value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Blip.Blip_SetScale(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Blip.Blip_SetScale(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<float> GetScaleAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Blip.Blip_GetScale(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Blip.Blip_GetScale(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetNameAsync(string value)
@@ -94,15 +114,21 @@ public async Task SetNameAsync(string value)
             {
                 var name = converter.StringToPointer(value);
 
-                await _plugin.Schedule(() => Rage.Blip.Blip_SetName(NativePointer, name)).ConfigureAwait(false);
+                await _plugin
+                    .Schedule(() => Rage.Blip.Blip_SetName(NativePointer, name))
+                    .ConfigureAwait(false);
             }
         }
 
         public async Task<string> GetNameAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => StringConverter.PointerToString(Rage.Blip.Blip_GetName(NativePointer))).ConfigureAwait(false);
+            var namePointer = await _plugin
+                .Schedule(() => Rage.Blip.Blip_GetName(NativePointer))
+                .ConfigureAwait(false);
+
+            return StringConverter.PointerToString(namePointer);
         }
 
         public async Task ShowRouteAsync(IEnumerable<IPlayer> forPlayers, uint color, float scale)
diff --git a/src/AlternateLife.RageMP.Net/Elements/Entities/Checkpoint.cs b/src/AlternateLife.RageMP.Net/Elements/Entities/Checkpoint.cs
@@ -23,56 +23,76 @@ public async Task SetColorAsync(Color value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetColor(NativePointer, value.R, value.G, value.B, value.A)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_SetColor(NativePointer, value.R, value.G, value.B, value.A))
+                .ConfigureAwait(false);
         }
 
         public async Task<Color> GetColorAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => StructConverter.PointerToStruct<ColorRgba>(Rage.Checkpoint.Checkpoint_GetColor(NativePointer)).FromModColor()).ConfigureAwait(false);
+            var colorPointer = await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_GetColor(NativePointer))
+                .ConfigureAwait(false);
+
+            return StructConverter.PointerToStruct<ColorRgba>(colorPointer).FromModColor();
         }
 
         public async Task SetDirectionAsync(Vector3 value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetDirection(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_SetDirection(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<Vector3> GetDirectionAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Checkpoint.Checkpoint_GetDirection(NativePointer))).ConfigureAwait(false);
+            var directionPointer = await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_GetDirection(NativePointer))
+                .ConfigureAwait(false);
+
+            return StructConverter.PointerToStruct<Vector3>(directionPointer);
         }
 
         public async Task SetRadiusAsync(float value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetRadius(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_SetRadius(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<float> GetRadiusAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_GetRadius(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_GetRadius(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetVisibleAsync(bool value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetVisible(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_SetVisible(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<bool> IsVisibleAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_IsVisible(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Checkpoint.Checkpoint_IsVisible(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task ShowForAsync(IEnumerable<IPlayer> players)
diff --git a/src/AlternateLife.RageMP.Net/Elements/Entities/Colshape.cs b/src/AlternateLife.RageMP.Net/Elements/Entities/Colshape.cs
@@ -17,7 +17,9 @@ public async Task<ColshapeType> GetShapeTypeAsync()
         {
             CheckExistence();
 
-            return (ColshapeType) await _plugin.Schedule(() => Rage.Colshape.Colshape_GetShapeType(NativePointer)).ConfigureAwait(false);
+            return (ColshapeType) await _plugin
+                .Schedule(() => Rage.Colshape.Colshape_GetShapeType(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task<bool> IsPointWhithinAsync(Vector3 position)
diff --git a/src/AlternateLife.RageMP.Net/Elements/Entities/Entity.cs b/src/AlternateLife.RageMP.Net/Elements/Entities/Entity.cs
@@ -38,77 +38,105 @@ public async Task SetModelAsync(uint value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Entity.Entity_SetModel(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Entity.Entity_SetModel(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<uint> GetModelAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Entity.Entity_GetModel(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Entity.Entity_GetModel(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetAlphaAsync(uint value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Entity.Entity_SetAlpha(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Entity.Entity_SetAlpha(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<uint> GetAlphaAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Entity.Entity_GetAlpha(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Entity.Entity_GetAlpha(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetDimensionAsync(uint value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Entity.Entity_SetDimension(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Entity.Entity_SetDimension(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<uint> GetDimensionAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => Rage.Entity.Entity_GetDimension(NativePointer)).ConfigureAwait(false);
+            return await _plugin
+                .Schedule(() => Rage.Entity.Entity_GetDimension(NativePointer))
+                .ConfigureAwait(false);
         }
 
         public async Task SetPositionAsync(Vector3 value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Entity.Entity_SetPosition(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Entity.Entity_SetPosition(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public async Task<Vector3> GetPositionAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Entity.Entity_GetPosition(NativePointer))).ConfigureAwait(false);
+            var positionPointer = await _plugin
+                .Schedule(() => Rage.Entity.Entity_GetPosition(NativePointer))
+                .ConfigureAwait(false);
+
+            return StructConverter.PointerToStruct<Vector3>(positionPointer);
         }
 
         public virtual async Task SetRotationAsync(Vector3 value)
         {
             CheckExistence();
 
-            await _plugin.Schedule(() => Rage.Entity.Entity_SetRotation(NativePointer, value)).ConfigureAwait(false);
+            await _plugin
+                .Schedule(() => Rage.Entity.Entity_SetRotation(NativePointer, value))
+                .ConfigureAwait(false);
         }
 
         public virtual async Task<Vector3> GetRotationAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Entity.Entity_GetRotation(NativePointer))).ConfigureAwait(false);
+            var rotationPointer = await _plugin
+                .Schedule(() => Rage.Entity.Entity_GetRotation(NativePointer))
+                .ConfigureAwait(false);
+
+            return StructConverter.PointerToStruct<Vector3>(rotationPointer);
         }
 
         public async Task<Vector3> GetVelocityAsync()
         {
             CheckExistence();
 
-            return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Entity.Entity_GetVelocity(NativePointer))).ConfigureAwait(false);
+            var velocityPointer = await _plugin
+                .Schedule(() => Rage.Entity.Entity_GetVelocity(NativePointer))
+                .ConfigureAwait(false);
+
+            return StructConverter.PointerToStruct<Vector3>(velocityPointer);
         }
 
         public Task DestroyAsync()
diff --git a/src/AlternateLife.RageMP.Net/Elements/Entities/Marker.cs b/src/AlternateLife.RageMP.Net/Elements/Entities/Marker.cs
diff --git a/src/AlternateLife.RageMP.Net/Elements/Entities/TextLabel.cs b/src/AlternateLife.RageMP.Net/Elements/Entities/TextLabel.cs

Original file line number	Diff line number	Diff line change
`@@ -19,70 +19,90 @@ public async Task SetDrawDistanceAsync(float value)`
`19`	`19`	`{`
`20`	`20`	`CheckExistence();`
`21`	`21`
`22`		`- await _plugin.Schedule(() => Rage.Blip.Blip_SetDrawDistance(NativePointer, value)).ConfigureAwait(false);`
	`22`	`+ await _plugin`
	`23`	`+ .Schedule(() => Rage.Blip.Blip_SetDrawDistance(NativePointer, value))`
	`24`	`+ .ConfigureAwait(false);`
`23`	`25`	`}`
`24`	`26`
`25`	`27`	`public async Task<float> GetDrawDistanceAsync()`
`26`	`28`	`{`
`27`	`29`	`CheckExistence();`
`28`	`30`
`29`		`- return await _plugin.Schedule(() => Rage.Blip.Blip_GetDrawDistance(NativePointer)).ConfigureAwait(false);`
	`31`	`+ return await _plugin`
	`32`	`+ .Schedule(() => Rage.Blip.Blip_GetDrawDistance(NativePointer))`
	`33`	`+ .ConfigureAwait(false);`
`30`	`34`	`}`
`31`	`35`
`32`	`36`	`public async Task SetRotationAsync(int value)`
`33`	`37`	`{`
`34`	`38`	`CheckExistence();`
`35`	`39`
`36`		`- await _plugin.Schedule(() => Rage.Blip.Blip_SetRotation(NativePointer, value)).ConfigureAwait(false);`
	`40`	`+ await _plugin`
	`41`	`+ .Schedule(() => Rage.Blip.Blip_SetRotation(NativePointer, value))`
	`42`	`+ .ConfigureAwait(false);`
`37`	`43`	`}`
`38`	`44`
`39`	`45`	`public new async Task<int> GetRotationAsync()`
`40`	`46`	`{`
`41`	`47`	`CheckExistence();`
`42`	`48`
`43`		`- return await _plugin.Schedule(() => Rage.Blip.Blip_GetRotation(NativePointer)).ConfigureAwait(false);`
	`49`	`+ return await _plugin`
	`50`	`+ .Schedule(() => Rage.Blip.Blip_GetRotation(NativePointer))`
	`51`	`+ .ConfigureAwait(false);`
`44`	`52`	`}`
`45`	`53`
`46`	`54`	`public async Task SetShortRangeAsync(bool value)`
`47`	`55`	`{`
`48`	`56`	`CheckExistence();`
`49`	`57`
`50`		`- await _plugin.Schedule(() => Rage.Blip.Blip_SetShortRange(NativePointer, value)).ConfigureAwait(false);`
	`58`	`+ await _plugin`
	`59`	`+ .Schedule(() => Rage.Blip.Blip_SetShortRange(NativePointer, value))`
	`60`	`+ .ConfigureAwait(false);`
`51`	`61`	`}`
`52`	`62`
`53`	`63`	`public async Task<bool> GetShortRangeAsync()`
`54`	`64`	`{`
`55`	`65`	`CheckExistence();`
`56`	`66`
`57`		`- return await _plugin.Schedule(() => Rage.Blip.Blip_IsShortRange(NativePointer)).ConfigureAwait(false);`
	`67`	`+ return await _plugin`
	`68`	`+ .Schedule(() => Rage.Blip.Blip_IsShortRange(NativePointer))`
	`69`	`+ .ConfigureAwait(false);`
`58`	`70`	`}`
`59`	`71`
`60`	`72`	`public async Task SetColorAsync(uint value)`
`61`	`73`	`{`
`62`	`74`	`CheckExistence();`
`63`	`75`
`64`		`- await _plugin.Schedule(() => Rage.Blip.Blip_SetColor(NativePointer, value)).ConfigureAwait(false);`
	`76`	`+ await _plugin`
	`77`	`+ .Schedule(() => Rage.Blip.Blip_SetColor(NativePointer, value))`
	`78`	`+ .ConfigureAwait(false);`
`65`	`79`	`}`
`66`	`80`
`67`	`81`	`public async Task<uint> GetColorAsync()`
`68`	`82`	`{`
`69`	`83`	`CheckExistence();`
`70`	`84`
`71`		`- return await _plugin.Schedule(() => Rage.Blip.Blip_GetColor(NativePointer)).ConfigureAwait(false);`
	`85`	`+ return await _plugin`
	`86`	`+ .Schedule(() => Rage.Blip.Blip_GetColor(NativePointer))`
	`87`	`+ .ConfigureAwait(false);`
`72`	`88`	`}`
`73`	`89`
`74`	`90`	`public async Task SetScaleAsync(float value)`
`75`	`91`	`{`
`76`	`92`	`CheckExistence();`
`77`	`93`
`78`		`- await _plugin.Schedule(() => Rage.Blip.Blip_SetScale(NativePointer, value)).ConfigureAwait(false);`
	`94`	`+ await _plugin`
	`95`	`+ .Schedule(() => Rage.Blip.Blip_SetScale(NativePointer, value))`
	`96`	`+ .ConfigureAwait(false);`
`79`	`97`	`}`
`80`	`98`
`81`	`99`	`public async Task<float> GetScaleAsync()`
`82`	`100`	`{`
`83`	`101`	`CheckExistence();`
`84`	`102`
`85`		`- return await _plugin.Schedule(() => Rage.Blip.Blip_GetScale(NativePointer)).ConfigureAwait(false);`
	`103`	`+ return await _plugin`
	`104`	`+ .Schedule(() => Rage.Blip.Blip_GetScale(NativePointer))`
	`105`	`+ .ConfigureAwait(false);`
`86`	`106`	`}`
`87`	`107`
`88`	`108`	`public async Task SetNameAsync(string value)`
`@@ -94,15 +114,21 @@ public async Task SetNameAsync(string value)`
`94`	`114`	`{`
`95`	`115`	`var name = converter.StringToPointer(value);`
`96`	`116`
`97`		`- await _plugin.Schedule(() => Rage.Blip.Blip_SetName(NativePointer, name)).ConfigureAwait(false);`
	`117`	`+ await _plugin`
	`118`	`+ .Schedule(() => Rage.Blip.Blip_SetName(NativePointer, name))`
	`119`	`+ .ConfigureAwait(false);`
`98`	`120`	`}`
`99`	`121`	`}`
`100`	`122`
`101`	`123`	`public async Task<string> GetNameAsync()`
`102`	`124`	`{`
`103`	`125`	`CheckExistence();`
`104`	`126`
`105`		`- return await _plugin.Schedule(() => StringConverter.PointerToString(Rage.Blip.Blip_GetName(NativePointer))).ConfigureAwait(false);`
	`127`	`+ var namePointer = await _plugin`
	`128`	`+ .Schedule(() => Rage.Blip.Blip_GetName(NativePointer))`
	`129`	`+ .ConfigureAwait(false);`
	`130`	`+`
	`131`	`+ return StringConverter.PointerToString(namePointer);`
`106`	`132`	`}`
`107`	`133`
`108`	`134`	`public async Task ShowRouteAsync(IEnumerable<IPlayer> forPlayers, uint color, float scale)`
Original file line number	Diff line number	Diff line change
`@@ -23,56 +23,76 @@ public async Task SetColorAsync(Color value)`
`23`	`23`	`{`
`24`	`24`	`CheckExistence();`
`25`	`25`
`26`		`- await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetColor(NativePointer, value.R, value.G, value.B, value.A)).ConfigureAwait(false);`
	`26`	`+ await _plugin`
	`27`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_SetColor(NativePointer, value.R, value.G, value.B, value.A))`
	`28`	`+ .ConfigureAwait(false);`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`public async Task<Color> GetColorAsync()`
`30`	`32`	`{`
`31`	`33`	`CheckExistence();`
`32`	`34`
`33`		`- return await _plugin.Schedule(() => StructConverter.PointerToStruct<ColorRgba>(Rage.Checkpoint.Checkpoint_GetColor(NativePointer)).FromModColor()).ConfigureAwait(false);`
	`35`	`+ var colorPointer = await _plugin`
	`36`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_GetColor(NativePointer))`
	`37`	`+ .ConfigureAwait(false);`
	`38`	`+`
	`39`	`+ return StructConverter.PointerToStruct<ColorRgba>(colorPointer).FromModColor();`
`34`	`40`	`}`
`35`	`41`
`36`	`42`	`public async Task SetDirectionAsync(Vector3 value)`
`37`	`43`	`{`
`38`	`44`	`CheckExistence();`
`39`	`45`
`40`		`- await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetDirection(NativePointer, value)).ConfigureAwait(false);`
	`46`	`+ await _plugin`
	`47`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_SetDirection(NativePointer, value))`
	`48`	`+ .ConfigureAwait(false);`
`41`	`49`	`}`
`42`	`50`
`43`	`51`	`public async Task<Vector3> GetDirectionAsync()`
`44`	`52`	`{`
`45`	`53`	`CheckExistence();`
`46`	`54`
`47`		`- return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Checkpoint.Checkpoint_GetDirection(NativePointer))).ConfigureAwait(false);`
	`55`	`+ var directionPointer = await _plugin`
	`56`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_GetDirection(NativePointer))`
	`57`	`+ .ConfigureAwait(false);`
	`58`	`+`
	`59`	`+ return StructConverter.PointerToStruct<Vector3>(directionPointer);`
`48`	`60`	`}`
`49`	`61`
`50`	`62`	`public async Task SetRadiusAsync(float value)`
`51`	`63`	`{`
`52`	`64`	`CheckExistence();`
`53`	`65`
`54`		`- await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetRadius(NativePointer, value)).ConfigureAwait(false);`
	`66`	`+ await _plugin`
	`67`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_SetRadius(NativePointer, value))`
	`68`	`+ .ConfigureAwait(false);`
`55`	`69`	`}`
`56`	`70`
`57`	`71`	`public async Task<float> GetRadiusAsync()`
`58`	`72`	`{`
`59`	`73`	`CheckExistence();`
`60`	`74`
`61`		`- return await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_GetRadius(NativePointer)).ConfigureAwait(false);`
	`75`	`+ return await _plugin`
	`76`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_GetRadius(NativePointer))`
	`77`	`+ .ConfigureAwait(false);`
`62`	`78`	`}`
`63`	`79`
`64`	`80`	`public async Task SetVisibleAsync(bool value)`
`65`	`81`	`{`
`66`	`82`	`CheckExistence();`
`67`	`83`
`68`		`- await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_SetVisible(NativePointer, value)).ConfigureAwait(false);`
	`84`	`+ await _plugin`
	`85`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_SetVisible(NativePointer, value))`
	`86`	`+ .ConfigureAwait(false);`
`69`	`87`	`}`
`70`	`88`
`71`	`89`	`public async Task<bool> IsVisibleAsync()`
`72`	`90`	`{`
`73`	`91`	`CheckExistence();`
`74`	`92`
`75`		`- return await _plugin.Schedule(() => Rage.Checkpoint.Checkpoint_IsVisible(NativePointer)).ConfigureAwait(false);`
	`93`	`+ return await _plugin`
	`94`	`+ .Schedule(() => Rage.Checkpoint.Checkpoint_IsVisible(NativePointer))`
	`95`	`+ .ConfigureAwait(false);`
`76`	`96`	`}`
`77`	`97`
`78`	`98`	`public async Task ShowForAsync(IEnumerable<IPlayer> players)`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,9 @@ public async Task<ColshapeType> GetShapeTypeAsync()`
`17`	`17`	`{`
`18`	`18`	`CheckExistence();`
`19`	`19`
`20`		`- return (ColshapeType) await _plugin.Schedule(() => Rage.Colshape.Colshape_GetShapeType(NativePointer)).ConfigureAwait(false);`
	`20`	`+ return (ColshapeType) await _plugin`
	`21`	`+ .Schedule(() => Rage.Colshape.Colshape_GetShapeType(NativePointer))`
	`22`	`+ .ConfigureAwait(false);`
`21`	`23`	`}`
`22`	`24`
`23`	`25`	`public async Task<bool> IsPointWhithinAsync(Vector3 position)`
Original file line number	Diff line number	Diff line change
`@@ -38,77 +38,105 @@ public async Task SetModelAsync(uint value)`
`38`	`38`	`{`
`39`	`39`	`CheckExistence();`
`40`	`40`
`41`		`- await _plugin.Schedule(() => Rage.Entity.Entity_SetModel(NativePointer, value)).ConfigureAwait(false);`
	`41`	`+ await _plugin`
	`42`	`+ .Schedule(() => Rage.Entity.Entity_SetModel(NativePointer, value))`
	`43`	`+ .ConfigureAwait(false);`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`public async Task<uint> GetModelAsync()`
`45`	`47`	`{`
`46`	`48`	`CheckExistence();`
`47`	`49`
`48`		`- return await _plugin.Schedule(() => Rage.Entity.Entity_GetModel(NativePointer)).ConfigureAwait(false);`
	`50`	`+ return await _plugin`
	`51`	`+ .Schedule(() => Rage.Entity.Entity_GetModel(NativePointer))`
	`52`	`+ .ConfigureAwait(false);`
`49`	`53`	`}`
`50`	`54`
`51`	`55`	`public async Task SetAlphaAsync(uint value)`
`52`	`56`	`{`
`53`	`57`	`CheckExistence();`
`54`	`58`
`55`		`- await _plugin.Schedule(() => Rage.Entity.Entity_SetAlpha(NativePointer, value)).ConfigureAwait(false);`
	`59`	`+ await _plugin`
	`60`	`+ .Schedule(() => Rage.Entity.Entity_SetAlpha(NativePointer, value))`
	`61`	`+ .ConfigureAwait(false);`
`56`	`62`	`}`
`57`	`63`
`58`	`64`	`public async Task<uint> GetAlphaAsync()`
`59`	`65`	`{`
`60`	`66`	`CheckExistence();`
`61`	`67`
`62`		`- return await _plugin.Schedule(() => Rage.Entity.Entity_GetAlpha(NativePointer)).ConfigureAwait(false);`
	`68`	`+ return await _plugin`
	`69`	`+ .Schedule(() => Rage.Entity.Entity_GetAlpha(NativePointer))`
	`70`	`+ .ConfigureAwait(false);`
`63`	`71`	`}`
`64`	`72`
`65`	`73`	`public async Task SetDimensionAsync(uint value)`
`66`	`74`	`{`
`67`	`75`	`CheckExistence();`
`68`	`76`
`69`		`- await _plugin.Schedule(() => Rage.Entity.Entity_SetDimension(NativePointer, value)).ConfigureAwait(false);`
	`77`	`+ await _plugin`
	`78`	`+ .Schedule(() => Rage.Entity.Entity_SetDimension(NativePointer, value))`
	`79`	`+ .ConfigureAwait(false);`
`70`	`80`	`}`
`71`	`81`
`72`	`82`	`public async Task<uint> GetDimensionAsync()`
`73`	`83`	`{`
`74`	`84`	`CheckExistence();`
`75`	`85`
`76`		`- return await _plugin.Schedule(() => Rage.Entity.Entity_GetDimension(NativePointer)).ConfigureAwait(false);`
	`86`	`+ return await _plugin`
	`87`	`+ .Schedule(() => Rage.Entity.Entity_GetDimension(NativePointer))`
	`88`	`+ .ConfigureAwait(false);`
`77`	`89`	`}`
`78`	`90`
`79`	`91`	`public async Task SetPositionAsync(Vector3 value)`
`80`	`92`	`{`
`81`	`93`	`CheckExistence();`
`82`	`94`
`83`		`- await _plugin.Schedule(() => Rage.Entity.Entity_SetPosition(NativePointer, value)).ConfigureAwait(false);`
	`95`	`+ await _plugin`
	`96`	`+ .Schedule(() => Rage.Entity.Entity_SetPosition(NativePointer, value))`
	`97`	`+ .ConfigureAwait(false);`
`84`	`98`	`}`
`85`	`99`
`86`	`100`	`public async Task<Vector3> GetPositionAsync()`
`87`	`101`	`{`
`88`	`102`	`CheckExistence();`
`89`	`103`
`90`		`- return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Entity.Entity_GetPosition(NativePointer))).ConfigureAwait(false);`
	`104`	`+ var positionPointer = await _plugin`
	`105`	`+ .Schedule(() => Rage.Entity.Entity_GetPosition(NativePointer))`
	`106`	`+ .ConfigureAwait(false);`
	`107`	`+`
	`108`	`+ return StructConverter.PointerToStruct<Vector3>(positionPointer);`
`91`	`109`	`}`
`92`	`110`
`93`	`111`	`public virtual async Task SetRotationAsync(Vector3 value)`
`94`	`112`	`{`
`95`	`113`	`CheckExistence();`
`96`	`114`
`97`		`- await _plugin.Schedule(() => Rage.Entity.Entity_SetRotation(NativePointer, value)).ConfigureAwait(false);`
	`115`	`+ await _plugin`
	`116`	`+ .Schedule(() => Rage.Entity.Entity_SetRotation(NativePointer, value))`
	`117`	`+ .ConfigureAwait(false);`
`98`	`118`	`}`
`99`	`119`
`100`	`120`	`public virtual async Task<Vector3> GetRotationAsync()`
`101`	`121`	`{`
`102`	`122`	`CheckExistence();`
`103`	`123`
`104`		`- return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Entity.Entity_GetRotation(NativePointer))).ConfigureAwait(false);`
	`124`	`+ var rotationPointer = await _plugin`
	`125`	`+ .Schedule(() => Rage.Entity.Entity_GetRotation(NativePointer))`
	`126`	`+ .ConfigureAwait(false);`
	`127`	`+`
	`128`	`+ return StructConverter.PointerToStruct<Vector3>(rotationPointer);`
`105`	`129`	`}`
`106`	`130`
`107`	`131`	`public async Task<Vector3> GetVelocityAsync()`
`108`	`132`	`{`
`109`	`133`	`CheckExistence();`
`110`	`134`
`111`		`- return await _plugin.Schedule(() => StructConverter.PointerToStruct<Vector3>(Rage.Entity.Entity_GetVelocity(NativePointer))).ConfigureAwait(false);`
	`135`	`+ var velocityPointer = await _plugin`
	`136`	`+ .Schedule(() => Rage.Entity.Entity_GetVelocity(NativePointer))`
	`137`	`+ .ConfigureAwait(false);`
	`138`	`+`
	`139`	`+ return StructConverter.PointerToStruct<Vector3>(velocityPointer);`
`112`	`140`	`}`
`113`	`141`
`114`	`142`	`public Task DestroyAsync()`