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();
});
}
