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