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); switch (targetEntity) { case IPlayer targetPlayer: { var targetReference = new PlayerRef(targetPlayer); Task.Run(async() => { await WeaponDamageAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart)); sourceReference.Dispose(); targetReference.Dispose(); }); break; } case IVehicle targetVehicle: { var targetReference = new VehicleRef(targetVehicle); Task.Run(async() => { await WeaponDamageAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart)); sourceReference.Dispose(); targetReference.Dispose(); }); break; } default: Task.Run(async() => { await WeaponDamageAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart)); sourceReference.Dispose(); }); break; } }
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(); }); }
public override void OnSyncedMetaDataChangeEvent(IEntity entity, string key, object value) { base.OnSyncedMetaDataChangeEvent(entity, key, value); if (!SyncedMetaDataChangeAsyncDelegateHandlers.HasEvents()) { return; } switch (entity) { case IPlayer playerEntity: var playerEntityReference = new PlayerRef(playerEntity); Task.Run(async() => { await SyncedMetaDataChangeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(entity, key, value)); playerEntityReference.Dispose(); }); break; case IVehicle vehicleEntity: var vehicleEntityReference = new VehicleRef(vehicleEntity); Task.Run(async() => { await SyncedMetaDataChangeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(entity, key, value)); vehicleEntityReference.Dispose(); }); break; default: Task.Run(() => SyncedMetaDataChangeAsyncDelegateHandlers.CallAsyncWithoutTask(@delegate => @delegate(entity, key, value))); break; } }
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); switch (entity) { case IPlayer playerEntity: var playerEntityReference = new PlayerRef(playerEntity); Task.Run(async() => { await PlayerDamageAsyncEventHandler.CallAsync(@delegate => @delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage)); playerReference.Dispose(); playerEntityReference.Dispose(); }); break; case IVehicle vehicleEntity: var vehicleEntityReference = new VehicleRef(vehicleEntity); Task.Run(async() => { await PlayerDamageAsyncEventHandler.CallAsync(@delegate => @delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage)); playerReference.Dispose(); vehicleEntityReference.Dispose(); }); break; default: Task.Run(async() => { await PlayerDamageAsyncEventHandler.CallAsync(@delegate => @delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage)); playerReference.Dispose(); }); break; } }
public override void OnPlayerDeathEvent(IPlayer player, IEntity killer, uint weapon) { base.OnPlayerDeathEvent(player, killer, weapon); if (!PlayerDeadAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); switch (killer) { case IPlayer playerKiller: var playerKillerReference = new PlayerRef(playerKiller); Task.Run(async() => { await PlayerDeadAsyncEventHandler.CallAsync(@delegate => @delegate(player, killer, weapon)); playerReference.Dispose(); playerKillerReference.Dispose(); }); break; case IVehicle vehicleKiller: var vehicleKillerReference = new VehicleRef(vehicleKiller); Task.Run(async() => { await PlayerDeadAsyncEventHandler.CallAsync(@delegate => @delegate(player, killer, weapon)); playerReference.Dispose(); vehicleKillerReference.Dispose(); }); break; default: Task.Run(async() => { await PlayerDeadAsyncEventHandler.CallAsync(@delegate => @delegate(player, killer, weapon)); playerReference.Dispose(); }); break; } }
public override void OnPlayerRemoveEvent(IPlayer player) { base.OnPlayerRemoveEvent(player); if (!PlayerRemoveAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); Task.Run(async() => { await PlayerRemoveAsyncEventHandler.CallAsync(@delegate => @delegate(player)); playerReference.Dispose(); }); }
public override void OnCheckPointEvent(ICheckpoint checkpoint, IEntity entity, bool state) { base.OnCheckPointEvent(checkpoint, entity, state); if (!CheckpointAsyncEventHandler.HasEvents()) { return; } var checkpointReference = new CheckpointRef(checkpoint); switch (entity) { case IPlayer playerEntity: var playerEntityReference = new PlayerRef(playerEntity); Task.Run(async() => { await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state)); checkpointReference.Dispose(); playerEntityReference.Dispose(); }); break; case IVehicle vehicleEntity: var vehicleEntityReference = new VehicleRef(vehicleEntity); Task.Run(async() => { await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state)); checkpointReference.Dispose(); vehicleEntityReference.Dispose(); }); break; default: Task.Run(async() => { await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state)); checkpointReference.Dispose(); }); break; } Task.Run(async() => { await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state)); checkpointReference.Dispose(); }); }
public override void OnExplosionEvent(IPlayer sourcePlayer, ExplosionType explosionType, Position position, uint explosionFx) { base.OnExplosionEvent(sourcePlayer, explosionType, position, explosionFx); if (!ExplosionAsyncEventHandler.HasEvents()) { return; } var sourceReference = new PlayerRef(sourcePlayer); Task.Run(async() => { await ExplosionAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, explosionType, position, explosionFx)); sourceReference.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() => { await PlayerLeaveVehicleAsyncEventHandler.CallAsync(@delegate => @delegate(vehicle, player, seat)); playerReference.Dispose(); vehicleReference.Dispose(); }); }
public override void OnPlayerConnectEvent(IPlayer player, string reason) { base.OnPlayerConnectEvent(player, reason); if (!PlayerConnectAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); Task.Run(async() => { playerReference.DebugCountUp(); await PlayerConnectAsyncEventHandler.CallAsync(@delegate => @delegate(player, reason)); playerReference.DebugCountDown(); playerReference.Dispose(); }); }
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 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 OnColShapeEvent(IColShape colShape, IEntity entity, bool state) { base.OnColShapeEvent(colShape, entity, state); if (!ColShapeAsyncDelegateHandlers.HasEvents()) { return; } var colShapeReference = new ColShapeRef(colShape); switch (entity) { case IPlayer playerEntity: var playerEntityReference = new PlayerRef(playerEntity); Task.Run(async() => { await ColShapeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(colShape, entity, state)); playerEntityReference.Dispose(); colShapeReference.Dispose(); }); break; case IVehicle vehicleEntity: var vehicleEntityReference = new VehicleRef(vehicleEntity); Task.Run(async() => { await ColShapeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(colShape, entity, state)); vehicleEntityReference.Dispose(); colShapeReference.Dispose(); }); break; default: Task.Run(async() => { await ColShapeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(colShape, entity, state)); colShapeReference.Dispose(); }); break; } }
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 OnPlayerChangeVehicleSeatEvent(IVehicle vehicle, IPlayer player, byte oldSeat, byte newSeat) { base.OnPlayerChangeVehicleSeatEvent(vehicle, player, oldSeat, newSeat); if (!PlayerChangeVehicleSeatAsyncEventHandler.HasEvents()) { return; } var playerReference = new PlayerRef(player); var vehicleReference = new VehicleRef(vehicle); Task.Run(async() => { playerReference.DebugCountUp(); vehicleReference.DebugCountUp(); await PlayerChangeVehicleSeatAsyncEventHandler.CallAsync(@delegate => @delegate(vehicle, player, oldSeat, newSeat)); vehicleReference.DebugCountDown(); playerReference.DebugCountDown(); playerReference.Dispose(); vehicleReference.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(); }); }