public bool ShouldBlock(ExecuteOrderEventArgs args)
{
if (!this.menu.SlowDown)
{
return(false);
}
if (!args.Entities.Any())
{
return(false);
}
switch (args.OrderId)
{
case OrderId.Ability:
case OrderId.AbilityTarget:
case OrderId.AbilityLocation:
case OrderId.AbilityTargetRune:
case OrderId.AbilityTargetTree:
{
var handle = args.Entities.First().Handle;
if (this.abilitySleeper.IsSleeping(handle))
{
return(true);
}
var ability = (ActiveAbility)EntityManager9.GetAbilityFast(args.Ability.Handle);
if (ability == null)
{
return(false);
}
if (this.lowDelayAbilities.Contains(ability.Id))
{
this.abilitySleeper.Sleep(handle, ability.CastPoint + AbilityLowDelay);
}
else
{
this.abilitySleeper.Sleep(handle, ability.CastPoint + AbilityDelay);
}
return(false);
}
case OrderId.Hold:
case OrderId.Stop:
//case OrderId.MoveLocation:
//case OrderId.AttackTarget:
{
var handle = args.Entities.First().Handle;
this.abilitySleeper.Reset(handle);
break;
}
}
return(false);
}
private static void StartChanneling(uint abilityHandle)
{
if (!(EntityManager9.GetAbilityFast(abilityHandle) is IChanneled channeled))
{
return;
}
channeled.Owner.ChannelEndTime = Game.RawGameTime + channeled.GetCastDelay() + 1f;
}
// Token: 0x060003B2 RID: 946 RVA: 0x0001CE3C File Offset: 0x0001B03C
private static void StartChanneling(uint abilityHandle)
{
IChanneled channeled;
if ((channeled = (EntityManager9.GetAbilityFast(abilityHandle) as IChanneled)) == null)
{
return;
}
channeled.Owner.ChannelEndTime = channeled.GetCastDelay() + 1f;
}
private void OnBoolPropertyChange(Entity sender, BoolPropertyChangeEventArgs args)
{
var newValue = args.NewValue;
if (newValue == args.OldValue)
{
return;
}
try
{
switch (args.PropertyName)
{
case "m_bToggleState":
{
if (!newValue)
{
break;
}
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
this.AbilityCasted?.Invoke(ability);
break;
}
//case "m_bInAbilityPhase":
//{
// var ability = EntityManager9.GetAbilityFast(sender.Handle);
// if (ability == null)
// {
// return;
// }
// ability.IsCasting = newValue;
// ability.Owner.IsCasting = newValue;
// this.AbilityCastChange?.Invoke(ability);
// break;
//}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x06000392 RID: 914 RVA: 0x0001BEA8 File Offset: 0x0001A0A8
private static void OnRemoveEntity(EntityEventArgs args)
{
try
{
PhysicalItem physicalItem = args.Entity as PhysicalItem;
if (!(physicalItem == null) && !(physicalItem.Item == null))
{
Ability9 abilityFast = EntityManager9.GetAbilityFast(physicalItem.Item.Handle);
if (!(abilityFast == null))
{
abilityFast.IsActive = true;
}
}
}
catch (Exception exception)
{
Logger.Error(exception, null);
}
}
private void OnEntityAdded(EntityAddedEventArgs e)
{
try
{
var physicalItem = e.Entity as PhysicalItem;
if (physicalItem == null || physicalItem.Item == null)
{
return;
}
var item = EntityManager9.GetAbilityFast(physicalItem.Item.Handle);
if (item == null)
{
return;
}
item.IsAvailable = false;
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
private static void OnRemoveEntity(EntityEventArgs args)
{
try
{
var physicalItem = args.Entity as PhysicalItem;
if (physicalItem == null || physicalItem.Item == null)
{
return;
}
var item = EntityManager9.GetAbilityFast(physicalItem.Item.Handle);
if (item == null)
{
return;
}
item.IsAvailable = true;
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnEntityRemoved(EntityRemovedEventArgs e)
{
try
{
var physicalItem = e.Entity as PhysicalItem;
if (physicalItem == null || physicalItem.Item == null)
{
return;
}
var item = EntityManager9.GetAbilityFast(physicalItem.Item.Handle);
if (item == null)
{
return;
}
item.IsAvailable = true;
//UpdateManager.BeginInvoke(100, () => InventoryChanged?.Invoke(null, EventArgs.Empty));
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
private void OnNetworkPropertyChanged(Entity sender, NetworkPropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "m_bToggleState":
{
var newValue = e.NewValue.GetBoolean();
if (!newValue || newValue == e.OldValue.GetBoolean())
{
break;
}
UpdateManager.BeginInvoke(() =>
{
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
this.AbilityCasted?.Invoke(ability);
});
}
break;
case "m_bInAbilityPhase":
{
var newValue = e.NewValue.GetBoolean();
if (newValue == e.OldValue.GetBoolean())
{
break;
}
UpdateManager.BeginInvoke(() =>
{
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
ability.IsCasting = newValue;
ability.Owner.IsCasting = newValue;
this.AbilityCastChange?.Invoke(ability);
});
}
break;
case "m_flEnableTime":
{
var newValue = e.NewValue.GetSingle();
if (newValue == e.OldValue.GetSingle())
{
break;
}
UpdateManager.BeginInvoke(() =>
{
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
ability.ItemEnableTimeSleeper.SleepUntil(newValue);
});
}
break;
case "m_flCastStartTime":
{
var newValue = e.NewValue.GetSingle();
var oldValue = e.OldValue.GetSingle();
if (newValue == oldValue)
{
break;
}
UpdateManager.BeginInvoke(() =>
{
if (this.AbilityCasted == null)
{
return;
}
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
if (!ability.IsDisplayingCharges)
{
return;
}
var castTime = newValue - oldValue;
if (castTime < 0 || oldValue < 0)
{
return;
}
var visibleTime = GameManager.RawGameTime - ability.Owner.LastNotVisibleTime;
if (visibleTime < 0.05f)
{
return;
}
if (ability.CastPoint <= 0)
{
this.AbilityCasted(ability);
}
else
{
if (Math.Abs(ability.CastPoint - castTime) < 0.03f)
{
this.AbilityCasted(ability);
}
}
});
}
break;
case "m_fCooldown":
{
var newValue = e.NewValue.GetSingle();
var oldValue = e.OldValue.GetSingle();
if (newValue == oldValue)
{
break;
}
UpdateManager.BeginInvoke(() =>
{
if (this.AbilityCasted == null)
{
return;
}
if (newValue <= oldValue || oldValue > 0)
{
return;
}
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
var visibleTime = GameManager.RawGameTime - ability.Owner.LastNotVisibleTime;
if (visibleTime < 0.05f)
{
return;
}
this.AbilityCasted(ability);
});
}
break;
case "m_flChannelStartTime":
{
var newValue = e.NewValue.GetSingle();
if (newValue == e.OldValue.GetSingle())
{
break;
}
UpdateManager.BeginInvoke(() =>
{
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
if (!(ability is IChanneled channeled))
{
return;
}
if (newValue > 0)
{
ability.IsChanneling = true;
channeled.Owner.ChannelEndTime = newValue + channeled.ChannelTime;
channeled.Owner.ChannelActivatesOnCast = channeled.IsActivatesOnChannelStart;
this.AbilityChannel?.Invoke(ability);
}
else
{
ability.IsChanneling = false;
channeled.Owner.ChannelEndTime = 0;
channeled.Owner.ChannelActivatesOnCast = false;
}
});
}
break;
case "m_iParity":
{
if (e.NewValue.GetInt32() == e.OldValue.GetInt32())
{
break;
}
UpdateManager.BeginInvoke(() =>
{
var owner = EntityManager9.GetUnitFast(sender.Handle);
if (owner == null)
{
return;
}
var inventory = owner.BaseInventory;
var checkedItems = new List <uint>();
foreach (var handle in this.GetInventoryItems(inventory).Select(x => x.Handle))
{
var item = EntityManager9.GetAbilityFast(handle);
if (item == null)
{
continue;
}
checkedItems.Add(handle);
if (item.Owner == owner)
{
item.IsAvailable = true;
//UpdateManager.BeginInvoke(100, () => InventoryChanged?.Invoke(null, EventArgs.Empty));
continue;
}
EntityManager9.RemoveAbility(item.BaseAbility);
EntityManager9.AddAbility(item.BaseAbility);
}
foreach (var handle in this.GetStashItems(inventory).Select(x => x.Handle))
{
var item = EntityManager9.GetAbilityFast(handle);
if (item == null)
{
continue;
}
checkedItems.Add(handle);
if (item.Owner == owner)
{
item.IsAvailable = false;
//UpdateManager.BeginInvoke(100, () => InventoryChanged?.Invoke(null, EventArgs.Empty));
continue;
}
EntityManager9.RemoveAbility(item.BaseAbility);
EntityManager9.AddAbility(item.BaseAbility);
}
// stashed neutral items
foreach (var item in owner.AbilitiesFast.Where(x => x.IsItem && x.IsAvailable && !checkedItems.Contains(x.Handle)))
{
item.IsAvailable = false;
//UpdateManager.BeginInvoke(100, () => InventoryChanged?.Invoke(null, EventArgs.Empty));
}
});
}
break;
}
}
private void GameOnUpdate2()
{
//hack
try
{
foreach (var unit in EntityManager9.Units.Where(x => x.IsVisible))
{
var inventory = unit.BaseUnit?.Inventory;
if (inventory == null)
{
continue;
}
var checkedItems = new List <uint>();
foreach (var handle in this.GetInventoryItems(inventory).Select(x => x.Handle))
{
var item = EntityManager9.GetAbilityFast(handle);
if (item == null)
{
continue;
}
checkedItems.Add(handle);
if (item.Owner == unit)
{
item.IsAvailable = true;
continue;
}
EntityManager9.RemoveAbility(item.BaseAbility);
EntityManager9.AddAbility(item.BaseAbility);
}
foreach (var handle in this.GetStashItems(inventory).Select(x => x.Handle))
{
var item = EntityManager9.GetAbilityFast(handle);
if (item == null)
{
continue;
}
checkedItems.Add(handle);
if (item.Owner == unit)
{
item.IsAvailable = false;
continue;
}
EntityManager9.RemoveAbility(item.BaseAbility);
EntityManager9.AddAbility(item.BaseAbility);
}
// stashed neutral items
foreach (var item in unit.AbilitiesFast.Where(
x => x.IsItem && x.IsAvailable && !checkedItems.Contains(x.Handle)))
{
item.IsAvailable = false;
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnInt32PropertyChange(Entity sender, Int32PropertyChangeEventArgs args)
{
if (args.NewValue == args.OldValue || args.PropertyName != "m_iParity")
{
return;
}
var owner = EntityManager9.GetUnitFast(sender.Handle);
if (owner == null)
{
return;
}
UpdateManager.BeginInvoke(
() =>
{
try
{
var inventory = owner.BaseInventory;
var checkedItems = new List <uint>();
foreach (var handle in this.GetInventoryItems(inventory).Select(x => x.Handle))
{
var item = EntityManager9.GetAbilityFast(handle);
if (item == null)
{
continue;
}
checkedItems.Add(handle);
if (item.Owner == owner)
{
item.IsAvailable = true;
continue;
}
EntityManager9.RemoveAbility(item.BaseAbility);
EntityManager9.AddAbility(item.BaseAbility);
}
foreach (var handle in this.GetStashItems(inventory).Select(x => x.Handle))
{
var item = EntityManager9.GetAbilityFast(handle);
if (item == null)
{
continue;
}
checkedItems.Add(handle);
if (item.Owner == owner)
{
item.IsAvailable = false;
continue;
}
EntityManager9.RemoveAbility(item.BaseAbility);
EntityManager9.AddAbility(item.BaseAbility);
}
// stashed neutral items
foreach (var item in owner.AbilitiesFast.Where(
x => x.IsItem && x.IsAvailable && !checkedItems.Contains(x.Handle)))
{
item.IsAvailable = false;
}
}
catch (Exception e)
{
Logger.Error(e);
}
});
}
private void OnFloatPropertyChange(Entity sender, FloatPropertyChangeEventArgs args)
{
var newValue = args.NewValue;
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (newValue == args.OldValue)
{
return;
}
try
{
switch (args.PropertyName)
{
case "m_flEnableTime":
{
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
ability.ItemEnableTimeSleeper.SleepUntil(newValue);
break;
}
case "m_flCastStartTime":
{
if (this.AbilityCasted == null)
{
break;
}
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
if (!ability.IsDisplayingCharges)
{
return;
}
var castTime = newValue - args.OldValue;
if (castTime < 0 || args.OldValue < 0)
{
return;
}
var visibleTime = Game.RawGameTime - ability.Owner.LastNotVisibleTime;
if (visibleTime < 0.05f)
{
return;
}
if (ability.CastPoint <= 0)
{
this.AbilityCasted(ability);
}
else
{
if (Math.Abs(ability.CastPoint - castTime) < 0.03f)
{
this.AbilityCasted(ability);
}
}
break;
}
case "m_fCooldown":
{
if (this.AbilityCasted == null)
{
break;
}
if (newValue <= args.OldValue || args.OldValue > 0)
{
break;
}
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
var visibleTime = Game.RawGameTime - ability.Owner.LastNotVisibleTime;
if (visibleTime < 0.05f)
{
return;
}
this.AbilityCasted(ability);
break;
}
case "m_flChannelStartTime":
{
var ability = EntityManager9.GetAbilityFast(sender.Handle);
if (ability == null)
{
return;
}
if (!(ability is IChanneled channeled))
{
break;
}
if (newValue > 0)
{
ability.IsChanneling = true;
channeled.Owner.ChannelEndTime = newValue + channeled.ChannelTime;
channeled.Owner.ChannelActivatesOnCast = channeled.IsActivatesOnChannelStart;
this.AbilityChannel?.Invoke(ability);
}
else
{
ability.IsChanneling = false;
channeled.Owner.ChannelEndTime = 0;
channeled.Owner.ChannelActivatesOnCast = false;
}
break;
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
