public override void OnPlayerDamageEvent(IPlayer player, IEntity entity, uint weapon, ushort damage) { base.OnPlayerDamageEvent(player, entity, weapon, damage); if (!PlayerDamageAsyncEventHandler.HasEvents()) { return; } var oldHealth = player.Health; var oldArmor = player.Armor; var oldMaxHealth = player.MaxHealth; var oldMaxArmor = player.MaxArmor; var playerReference = new PlayerRef(player); var entityReference = new BaseObjectRef(entity); Task.Run(async() => { playerReference.DebugCountUp(); entityReference.DebugCountUp(); await PlayerDamageAsyncEventHandler.CallAsync(@delegate => @delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage)); entityReference.DebugCountDown(); playerReference.DebugCountDown(); playerReference.Dispose(); entityReference.Dispose(); }); }
//AltAsync.OnPlayerEvent += OnPlayerEvent; //... /*class EventHandler * { * //... * public void Call(IPlayer player, object[] args) * { * //... * } * } * * private EventHandler[] eventHandlers = new EventHandler[42]; * * public async Task OnPlayerEvent(IPlayer player, string eventName, object[] args) * { * var number = FastStringToInt(eventName); * if (eventHandlers.Length < number) * { * eventHandlers[number].Call(player, args); * } * } * * private static int FastStringToInt(string eventName) * { * var y = 0; * for (var i = 0; i < eventName.Length; i++) * y = y * 10 + (eventName[i] - '0'); * return y; * }*/ public async void Bla2(IPlayer player) { using (var reference = new PlayerRef(player)) { if (!reference.Exists) { return; } reference.DebugCountUp(); //TODO: how to prevent player exists check to happen here inside //TODO: maybe create a PlayerRef struct from player native pointer and do all calls inside that struct //TODO: other way would be make a counter in player that counts up on ref create and down on ref delete //TODO: possible by adding addref and removeref methods to player class and counting the int up in them player.Position = Position.Zero; player.Rotation = Rotation.Zero; reference.DebugCountDown(); } await player.SetPositionAsync(new Position(1, 2, 3)); var unused = await player.GetPositionAsync(); await AltAsync.Do(() => { }); var unused2 = await AltAsync.Do(() => Alt.CreateVehicle(VehicleModel.Apc, new Position(1, 2, 3), new Rotation(1, 2, 3))); }
public override void ForEach(IBaseObjectCallback <IPlayer> baseObjectCallback) { foreach (var entity in GetAllEntities()) { using var entityRef = new PlayerRef(entity); if (!entityRef.Exists) { continue; } entityRef.DebugCountUp(); baseObjectCallback.OnBaseObject(entity); entityRef.DebugCountDown(); } }
public override void OnPlayerWeaponChangeEvent(IntPtr eventPointer, IPlayer player, uint oldWeapon, uint newWeapon) { base.OnPlayerWeaponChangeEvent(eventPointer, player, oldWeapon, newWeapon); if (!PlayerWeaponChangeAsyncDelegateHandlers.HasEvents()) { return; } var playerRef = new PlayerRef(player); Task.Run(async() => { playerRef.DebugCountUp(); await PlayerWeaponChangeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(player, oldWeapon, newWeapon)); playerRef.DebugCountDown(); playerRef.Dispose(); }); }
public override void OnFireEvent(IntPtr eventPointer, IPlayer player, FireInfo[] fires) { base.OnFireEvent(eventPointer, player, fires); if (!FireAsyncDelegateHandlers.HasEvents()) { return; } var playerRef = new PlayerRef(player); Task.Run(async() => { playerRef.DebugCountUp(); await FireAsyncDelegateHandlers.CallAsync(@delegate => @delegate(player, fires)); playerRef.DebugCountDown(); playerRef.Dispose(); }); }
public override void OnPlayerRemoveEvent(IPlayer player) { base.OnPlayerRemoveEvent(player); if (!PlayerRemoveAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); Task.Run(async() => { playerReference.DebugCountUp(); await PlayerRemoveAsyncEventHandler.CallAsync(@delegate => @delegate(player)); playerReference.DebugCountDown(); playerReference.Dispose(); }); }
public override void OnStartProjectileEvent(IntPtr eventPointer, IPlayer player, Position startPosition, Position direction, uint ammoHash, uint weaponHash) { base.OnStartProjectileEvent(eventPointer, player, startPosition, direction, ammoHash, weaponHash); if (!StartProjectileAsyncDelegateHandlers.HasEvents()) { return; } var playerRef = new PlayerRef(player); Task.Run(async() => { playerRef.DebugCountUp(); await StartProjectileAsyncDelegateHandlers.CallAsync(@delegate => @delegate(player, startPosition, direction, ammoHash, weaponHash)); playerRef.DebugCountDown(); playerRef.Dispose(); }); }
public override void OnPlayerLeaveVehicleEvent(IVehicle vehicle, IPlayer player, byte seat) { base.OnPlayerLeaveVehicleEvent(vehicle, player, seat); if (!PlayerLeaveVehicleAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); var vehicleReference = new VehicleRef(vehicle); Task.Run(async() => { playerReference.DebugCountUp(); vehicleReference.DebugCountUp(); await PlayerLeaveVehicleAsyncEventHandler.CallAsync(@delegate => @delegate(vehicle, player, seat)); vehicleReference.DebugCountDown(); playerReference.DebugCountDown(); playerReference.Dispose(); vehicleReference.Dispose(); }); }
public override void OnPlayerDeathEvent(IPlayer player, IEntity killer, uint weapon) { base.OnPlayerDeathEvent(player, killer, weapon); if (!PlayerDeadAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); var killerReference = new BaseObjectRef(killer); Task.Run(async() => { playerReference.DebugCountUp(); killerReference.DebugCountUp(); await PlayerDeadAsyncEventHandler.CallAsync(@delegate => @delegate(player, killer, weapon)); killerReference.DebugCountDown(); playerReference.DebugCountDown(); playerReference.Dispose(); killerReference.Dispose(); }); }
public override void OnWeaponDamageEvent(IntPtr eventPointer, IPlayer sourcePlayer, IEntity targetEntity, uint weapon, ushort damage, Position shotOffset, BodyPart bodyPart) { base.OnWeaponDamageEvent(eventPointer, sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart); if (!WeaponDamageAsyncEventHandler.HasEvents()) { return; } var sourceReference = new PlayerRef(sourcePlayer); var targetReference = new BaseObjectRef(targetEntity); Task.Run(async() => { sourceReference.DebugCountUp(); targetReference.DebugCountUp(); await WeaponDamageAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart)); sourceReference.DebugCountDown(); targetReference.DebugCountDown(); sourceReference.Dispose(); targetReference.Dispose(); }); }
public override void OnExplosionEvent(IntPtr eventPointer, IPlayer sourcePlayer, ExplosionType explosionType, Position position, uint explosionFx, IEntity targetEntity) { base.OnExplosionEvent(eventPointer, sourcePlayer, explosionType, position, explosionFx, targetEntity); if (!ExplosionAsyncEventHandler.HasEvents()) { return; } var sourceReference = new PlayerRef(sourcePlayer); var targetEntityReference = new BaseObjectRef(targetEntity); Task.Run(async() => { sourceReference.DebugCountUp(); targetEntityReference.DebugCountUp(); await ExplosionAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, explosionType, position, explosionFx, targetEntity)); sourceReference.DebugCountDown(); targetEntityReference.DebugCountDown(); sourceReference.Dispose(); targetEntityReference.Dispose(); }); }