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 OnNetOwnerChangeEvent(IEntity targetEntity, IPlayer oldPlayer, IPlayer newPlayer) { base.OnNetOwnerChangeEvent(targetEntity, oldPlayer, newPlayer); if (!NetOwnerChangeAsyncEventHandler.HasEvents()) { return; } var targetEntityRef = new BaseObjectRef(targetEntity); var oldPlayerRef = new BaseObjectRef(oldPlayer); var newPlayerRef = new BaseObjectRef(newPlayer); Task.Run(async() => { targetEntityRef.DebugCountUp(); oldPlayerRef.DebugCountUp(); newPlayerRef.DebugCountUp(); await NetOwnerChangeAsyncEventHandler.CallAsync(@delegate => @delegate(targetEntity, oldPlayer, newPlayer)); newPlayerRef.DebugCountDown(); oldPlayerRef.DebugCountDown(); targetEntityRef.DebugCountDown(); newPlayerRef.Dispose(); oldPlayerRef.Dispose(); targetEntityRef.Dispose(); }); }
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 OnPlayerConnectEvent(IPlayer player, string reason) { base.OnPlayerConnectEvent(player, reason); if (!PlayerConnectAsyncEventHandler.HasEvents()) { return; } Task.Run(() => PlayerConnectAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(player, reason))); }
public override void OnPlayerDeathEvent(IPlayer player, IEntity killer, uint weapon) { base.OnPlayerDeathEvent(player, killer, weapon); if (!PlayerDeadAsyncEventHandler.HasEvents()) { return; } Task.Run(() => PlayerDeadAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(player, killer, weapon))); }
public override void OnCheckPointEvent(ICheckpoint checkpoint, IEntity entity, bool state) { base.OnCheckPointEvent(checkpoint, entity, state); if (!CheckpointAsyncEventHandler.HasEvents()) { return; } Task.Run(() => CheckpointAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(checkpoint, entity, state))); }
public override void OnWeaponDamageEvent(IPlayer sourcePlayer, IEntity targetEntity, uint weapon, ushort damage, Position shotOffset, BodyPart bodyPart) { base.OnWeaponDamageEvent(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart); if (!WeaponDamageAsyncEventHandler.HasEvents()) { return; } Task.Run(() => WeaponDamageAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart))); }
public override void OnPlayerLeaveVehicleEvent(IVehicle vehicle, IPlayer player, byte seat) { base.OnPlayerLeaveVehicleEvent(vehicle, player, seat); if (!PlayerLeaveVehicleAsyncEventHandler.HasEvents()) { return; } Task.Run(() => PlayerLeaveVehicleAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(vehicle, player, seat))); }
public override void OnPlayerRemoveEvent(IPlayer player) { base.OnPlayerRemoveEvent(player); if (!PlayerRemoveAsyncEventHandler.HasEvents()) { return; } Task.Run(() => PlayerRemoveAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(player))); }
public override void OnVehicleRemoveEvent(IVehicle vehicle) { base.OnVehicleRemoveEvent(vehicle); if (!VehicleRemoveAsyncEventHandler.HasEvents()) { return; } Task.Run(() => VehicleRemoveAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(vehicle))); }
public override void OnConsoleCommandEvent(string name, string[] args) { base.OnConsoleCommandEvent(name, args); if (!ConsoleCommandAsyncDelegateHandlers.HasEvents()) { return; } Task.Run(() => ConsoleCommandAsyncDelegateHandlers.CallAsyncWithoutTask(@delegate => @delegate(name, args))); }
public override void OnSyncedMetaDataChangeEvent(IEntity entity, string key, object value) { base.OnSyncedMetaDataChangeEvent(entity, key, value); if (!SyncedMetaDataChangeAsyncDelegateHandlers.HasEvents()) { return; } Task.Run(() => SyncedMetaDataChangeAsyncDelegateHandlers.CallAsyncWithoutTask(@delegate => @delegate(entity, key, value))); }
public override void OnColShapeEvent(IColShape colShape, IEntity entity, bool state) { base.OnColShapeEvent(colShape, entity, state); if (!ColShapeAsyncDelegateHandlers.HasEvents()) { return; } Task.Run(() => ColShapeAsyncDelegateHandlers.CallAsyncWithoutTask(@delegate => @delegate(colShape, entity, state))); }
public override void OnExplosionEvent(IPlayer sourcePlayer, ExplosionType explosionType, Position position, uint explosionFx) { base.OnExplosionEvent(sourcePlayer, explosionType, position, explosionFx); if (!ExplosionAsyncEventHandler.HasEvents()) { return; } Task.Run(() => ExplosionAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(sourcePlayer, explosionType, position, explosionFx))); }
public override void OnPlayerChangeVehicleSeatEvent(IVehicle vehicle, IPlayer player, byte oldSeat, byte newSeat) { base.OnPlayerChangeVehicleSeatEvent(vehicle, player, oldSeat, newSeat); if (!PlayerChangeVehicleSeatAsyncEventHandler.HasEvents()) { return; } Task.Run(() => PlayerChangeVehicleSeatAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(vehicle, player, oldSeat, newSeat))); }
public override void OnPlayerDamageEvent(IPlayer player, IEntity attacker, uint weapon, ushort damage) { base.OnPlayerDamageEvent(player, attacker, weapon, damage); if (!PlayerDamageAsyncEventHandler.HasEvents()) { return; } var oldHealth = player.Health; var oldArmor = player.Armor; Task.Run(() => PlayerDamageAsyncEventHandler.CallAsyncWithoutTask(@delegate => @delegate(player, attacker, oldHealth, oldArmor, weapon, damage))); }
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 OnVehicleRemoveEvent(IVehicle vehicle) { base.OnVehicleRemoveEvent(vehicle); if (!VehicleRemoveAsyncEventHandler.HasEvents()) { return; } var vehicleReference = new VehicleRef(vehicle); Task.Run(async() => { await VehicleRemoveAsyncEventHandler.CallAsync(@delegate => @delegate(vehicle)); vehicleReference.Dispose(); }); }
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 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 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 OnPlayerDisconnectEvent(IPlayer player, string reason) { base.OnPlayerDisconnectEvent(player, reason); if (!PlayerDisconnectAsyncEventHandler.HasEvents()) { return; } var readOnlyPlayer = player.Copy(); Task.Run(async() => { await PlayerDisconnectAsyncEventHandler.CallAsync(@delegate => @delegate(readOnlyPlayer, player, reason)); readOnlyPlayer.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 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 OnSyncedMetaDataChangeEvent(IEntity entity, string key, object value) { base.OnSyncedMetaDataChangeEvent(entity, key, value); if (!SyncedMetaDataChangeAsyncDelegateHandlers.HasEvents()) { return; } var baseObjectRef = new BaseObjectRef(entity); Task.Run(async() => { baseObjectRef.DebugCountUp(); await SyncedMetaDataChangeAsyncDelegateHandlers.CallAsync(@delegate => @delegate(entity, key, value)); baseObjectRef.DebugCountDown(); baseObjectRef.Dispose(); }); }
public override void OnVehicleDestroyEvent(IVehicle vehicle) { base.OnVehicleDestroyEvent(vehicle); if (!VehicleDestroyAsyncDelegateHandlers.HasEvents()) { return; } var vehicleReference = new VehicleRef(vehicle); Task.Run(async() => { vehicleReference.DebugCountUp(); await VehicleDestroyAsyncDelegateHandlers.CallAsync(@delegate => @delegate(vehicle)); vehicleReference.DebugCountDown(); vehicleReference.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 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(); }); }