internal static Order ToShortModel(DB.Orders dbItem, UnitOfWork unitOfWork)
{
var Order =
new Order()
{
Id = dbItem.Id,
Closed = dbItem.Closed,
Client = Clients.ReadShort(dbItem.Client.Id, unitOfWork),
Car = Cars.ReadShort(dbItem.Car.Id, unitOfWork),
DateFrom = dbItem.DateFrom,
DateTo = dbItem.DateTo,
MileageEnd = dbItem.MileageEnd,
Other = dbItem.Other,
Overrun = dbItem.Overrun,
Territory = dbItem.Territory,
Wash = dbItem.Wash,
Discount = dbItem.Discount,
DiscountType = dbItem.DiscountType,
SiteId = dbItem.SiteId,
User = Users.Read(dbItem.User.Id, unitOfWork),
Deleted = dbItem.Deleted
};
foreach (var od in dbItem.OrderDamagesCollection)
{
Order.Damages.Add(Damages.Read(od.Damage.Id, unitOfWork));
}
return(Order);
}
public static void Init()
{
var Minions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Instance.Position, Annie.Q.Range);
foreach (var Minion in Minions)
{
if (Annie.Q.IsReady() && AnnieMenu.CheckBox(AnnieMenu.Lasthit, "Q"))
{
if (Minion.IsValidTarget(Annie.Q.Range))
{
if (Minion.Health - Damages.QDamage(Minion) <= 0)
{
if (AnnieMenu.CheckBox(AnnieMenu.Laneclear, "Exception"))
{
if (!Annie.HasStun())
{
Annie.Q.Cast(Minion);
}
}
else
{
Annie.Q.Cast(Minion);
}
}
}
}
}
}
/// <summary>
/// Update damages
/// </summary>
/// <param name="damages">Damages to update</param>
public void UpdateDamages(Damages damages)
{
AutoRentEntities context = new AutoRentEntities();
DbTransaction transaction = null;
try
{
context.Connection.Open();
transaction = context.Connection.BeginTransaction();
context.Damages.Attach(context.Damages.Single(c => c.Id == damages.Id));
context.Damages.ApplyCurrentValues(damages);
context.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
}
finally
{
context.Connection.Close();
}
}
public override void Execute()
{
// Items
if (Settings.UseItems)
{
var enemy = TargetSelector.GetTarget(BOTRK.Range, DamageType.Physical);
if (enemy != null)
{
if (CanUseItem(ItemId.Bilgewater_Cutlass))
{
Cutlass.Cast(enemy);
Debug.WriteChat("Using Bilgewater Cutlass on {0}", enemy.ChampionName);
}
else if (CanUseItem(ItemId.Blade_of_the_Ruined_King) &&
enemy.HealthPercent <= Settings.MaxBOTRKHPEnemy && PlayerHealth <= Settings.MaxBOTRKHPPlayer)
{
BOTRK.Cast(enemy);
Debug.WriteChat("Using BOTRK on {0}", enemy.ChampionName);
}
}
}
// Skills
if (Settings.UseR && R.IsReady() && PlayerMana >= SettingsMana.MinRMana)
{
var target = TargetSelector.GetTarget(R.Range, DamageType.Magical);
if (target != null)
{
if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
{
var targetHealth = target.TotalShieldHealth();
if (target.HasBuff("TristanaEChargeSound"))
{
targetHealth -= Damages.EDamage(target);
}
if (targetHealth < Damages.RDamage(target))
{
R.Cast(target);
Debug.WriteChat("Casting R in Combo to finish {0}, calculated HP to cast R: {1}, current HP: {2}.", target.ChampionName, targetHealth.ToString(), target.Health.ToString());
return;
}
}
}
}
if (Settings.UseW && W.IsReady() && PlayerMana >= SettingsMana.MinWMana)
{
var target = TargetSelector.GetTarget(W.Range, DamageType.Magical);
if (target != null)
{
if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
{
var pred = W.GetPrediction(target);
if (pred.HitChance >= SettingsPrediction.MinWHCCombo)
{
W.Cast(pred.CastPosition);
Debug.WriteChat("Casting W in Combo on {0}", target.ChampionName);
}
}
}
}
}
private static void OnSpellbookCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!Enabled)
{
return;
}
try
{
if (sender.Owner.IsMe)
{
var target = args.Target as Obj_AI_Hero;
if (target != null)
{
switch (args.Slot)
{
case SpellSlot.Q:
case SpellSlot.W:
case SpellSlot.E:
case SpellSlot.R:
Damages.Clean();
if (Damages.IsDying(target))
{
args.Process = false;
}
break;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// 航空戦での与ダメージを推測します。
/// </summary>
/// <param name="damages">与ダメージリスト。</param>
private void CalculateAttackDamage(int[] damages)
{
// 敵はめんどくさすぎるので省略
// 仮想火力を求め、それに従って合計ダメージを分配
var firepower = new int[12];
var launchedIndex = LaunchedShipIndexFriend;
foreach (int i in launchedIndex)
{
var ship = Battle.Initial.GetFriendShip(i);
if (ship == null)
{
continue;
}
var slots = ship.SlotInstanceMaster;
var aircrafts = ship.Aircraft;
for (int s = 0; s < slots.Count; s++)
{
if (slots[s] == null)
{
continue;
}
switch (slots[s].CategoryType)
{
// 通常の爆撃機系
case EquipmentTypes.CarrierBasedBomber:
case EquipmentTypes.SeaplaneBomber:
firepower[i] += (int)(1.0 * (slots[s].Bomber * Math.Sqrt(aircrafts[s]) + 25));
break;
// 噴式爆撃機
case EquipmentTypes.JetBomber:
firepower[i] += (int)(1.0 / Math.Sqrt(2) * (slots[s].Bomber * Math.Sqrt(aircrafts[s]) + 25));
break;
// 通常の攻撃機系 (80%と150%はランダムのため係数は平均値)
case EquipmentTypes.CarrierBasedTorpedo:
firepower[i] += (int)(1.15 * (slots[s].Torpedo * Math.Sqrt(aircrafts[s]) + 25));
break;
// 噴式攻撃機(いる？)
case EquipmentTypes.JetTorpedo:
firepower[i] += (int)(1.15 / Math.Sqrt(2) * (slots[s].Torpedo * Math.Sqrt(aircrafts[s]) + 25));
break;
}
}
}
int totalFirepower = firepower.Sum();
int totalDamage = Damages.Select(dmg => (int)dmg).Skip(12).Take(12).Sum();
for (int i = 0; i < firepower.Length; i++)
{
damages[i] += (int)Math.Round((double)totalDamage * firepower[i] / Math.Max(totalFirepower, 1));
}
}
public static void Init()
{
var Minions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Instance.Position, Elise.Q.Range);
foreach (var Minion in Minions)
{
if (Elise.CheckForm())
{
if (Elise.Q.IsReady() && EliseMenu.CheckBox(EliseMenu.Lasthit, "Q"))
{
if (Minion.Health - Damages.QDamage(Minion) <= 0)
{
Elise.Q.Cast(Minion);
}
}
}
else
{
if (Elise.Q2.IsReady() && EliseMenu.CheckBox(EliseMenu.Lasthit, "Q2"))
{
if (Minion.Health - Damages.Q2Damage(Minion) <= 0)
{
Elise.Q2.Cast(Minion);
}
}
}
}
}
/// <summary>
/// 航空戦での与ダメージを推測します。
/// </summary>
/// <param name="damages">与ダメージリスト。</param>
private void CalculateAttackDamage(int[] damages)
{
// 敵はめんどくさすぎるので省略
// 仮想火力を求め、それに従って合計ダメージを分配
var firepower = new int[12];
var launchedIndex = LaunchedShipIndexFriend;
var members = _battleData.Initial.FriendFleet.MembersWithoutEscaped;
foreach (int i in launchedIndex)
{
ShipData ship;
if (i < 6)
{
ship = _battleData.Initial.FriendFleet.MembersWithoutEscaped[i];
}
else
{
ship = _battleData.Initial.FriendFleetEscort.MembersWithoutEscaped[i - 6];
}
if (ship == null)
{
continue;
}
var slots = ship.SlotInstanceMaster;
var aircrafts = ship.Aircraft;
for (int s = 0; s < slots.Count; s++)
{
if (slots[s] == null)
{
continue;
}
switch (slots[s].CategoryType)
{
case 7: // 艦上爆撃機
case 11: // 水上爆撃機
case 57: // 噴式戦闘爆撃機
firepower[i] += (int)(1.0 * (slots[s].Bomber * Math.Sqrt(aircrafts[s]) + 25));
break;
case 8: // 艦上攻撃機 (80%と150%はランダムのため係数は平均値)
case 58: // 噴式攻撃機
firepower[i] += (int)(1.15 * (slots[s].Torpedo * Math.Sqrt(aircrafts[s]) + 25));
break;
}
}
}
int totalFirepower = firepower.Sum();
int totalDamage = Damages.Skip(6).Take(6).Sum() + damages.Skip(18).Take(6).Sum();
for (int i = 0; i < firepower.Length; i++)
{
damages[(i < 6 ? i : (i + 6))] += (int)Math.Round((double)totalDamage * firepower[i] / Math.Max(totalFirepower, 1));
}
}
private static float HandleDamageIndicator(Obj_AI_Base unit)
{
if (!Settings.Drawings.DrawInfo)
{
return(0);
}
var enemy = (AIHeroClient)unit;
if (enemy == null)
{
return(0);
}
if (MenuManager.IsCacheEnabled && Damages.Exist(unit.NetworkId))
{
return(Damages.Get(unit.NetworkId));
}
var damage = 0f;
if (!IsCastingR)
{
if (R.IsReady() && unit.IsValidTargetCached(R.Range))
{
damage += GetCurrentShootsRCount == 1
? Damage.GetRDamage(unit, true)
: Damage.GetRDamage(unit) * (GetCurrentShootsRCount - 1) + Damage.GetRDamage(unit, true);
}
if (Q.IsReady() && unit.IsValidTarget(Q.Range))
{
damage += Damage.GetQDamage(unit);
}
if (W.IsReady() && unit.IsValidTarget(W.Range))
{
damage += Damage.GetWDamage(unit);
}
}
else
{
if (IsInsideRRange(unit))
{
damage += GetCurrentShootsRCount == 1 ? Damage.GetRDamage(unit, true) : Damage.GetRDamage(unit);
}
}
if (unit.IsValidTargetCached(Player.Instance.GetAutoAttackRange()))
{
damage += HasAttackBuff ? Damage.Get4ThShootDamage(unit) : Player.Instance.GetAutoAttackDamage(unit);
}
if (MenuManager.IsCacheEnabled)
{
Damages.Add(unit.NetworkId, damage);
}
return(damage);
}
public override void Execute()
{
// Kill Steal
foreach (var enemy in EntityManager.Heroes.Enemies.Where(e => e.IsValidTarget(SpellManager.HasIgnite() ? SpellManager.Ignite.Range : SpellManager.R.Range)))
{
if (Settings.KsR && SpellManager.R.IsReady() && SpellManager.R.IsInRange(enemy) && Damages.RDamage(enemy) > enemy.TotalShieldHealth())
{
if (enemy.HasBuffOfType(BuffType.SpellImmunity))
{
continue;
}
SpellManager.R.Cast(enemy);
break;
}
if (Settings.KsIgnite && SpellManager.HasIgnite() && SpellManager.Ignite.IsReady() &&
Damages.IgniteDmg(enemy) > enemy.Health && SpellManager.Ignite.IsInRange(enemy))
{
SpellManager.Ignite.Cast(enemy);
break;
}
}
// Potion manager
if (Settings.Potion && !Player.Instance.IsInShopRange() && Player.Instance.HealthPercent <= Settings.potionMinHP && !(Player.Instance.HasBuff("RegenerationPotion") || Player.Instance.HasBuff("ItemCrystalFlaskJungle") || Player.Instance.HasBuff("ItemMiniRegenPotion") || Player.Instance.HasBuff("ItemCrystalFlask") || Player.Instance.HasBuff("ItemDarkCrystalFlask")))
{
if (Item.HasItem(HealthPotion.Id) && Item.CanUseItem(HealthPotion.Id))
{
Debug.WriteChat("Using HealthPotion because below {0}% HP - have {1}% HP", String.Format("{0}", Settings.potionMinHP), String.Format("{0:##.##}", Player.Instance.HealthPercent));
HealthPotion.Cast();
return;
}
if (Item.HasItem(HuntersPotion.Id) && Item.CanUseItem(HuntersPotion.Id))
{
Debug.WriteChat("Using HuntersPotion because below {0}% HP - have {1}% HP", String.Format("{0}", Settings.potionMinHP), String.Format("{0:##.##}", Player.Instance.HealthPercent));
HuntersPotion.Cast();
return;
}
if (Item.HasItem(TotalBiscuit.Id) && Item.CanUseItem(TotalBiscuit.Id))
{
Debug.WriteChat("Using TotalBiscuitOfRejuvenation because below {0}% HP - have {1}% HP", String.Format("{0}", Settings.potionMinHP), String.Format("{0:##.##}", Player.Instance.HealthPercent));
TotalBiscuit.Cast();
return;
}
if (Item.HasItem(RefillablePotion.Id) && Item.CanUseItem(RefillablePotion.Id))
{
Debug.WriteChat("Using RefillablePotion because below {0}% HP - have {1}% HP", String.Format("{0}", Settings.potionMinHP), String.Format("{0:##.##}", Player.Instance.HealthPercent));
RefillablePotion.Cast();
return;
}
if (Item.HasItem(CorruptingPotion.Id) && Item.CanUseItem(CorruptingPotion.Id))
{
Debug.WriteChat("Using CorruptingPotion because below {0}% HP - have {1}% HP", String.Format("{0}", Settings.potionMinHP), String.Format("{0:##.##}", Player.Instance.HealthPercent));
CorruptingPotion.Cast();
return;
}
}
}
public void Clearup()
{
//RunTimedFunction.RemoveTimer(BetterTimerTypes.MobKillTimer, MapID, SpawnID);
OriginalPosition = null;
Owner = null;
Controller = null;
Damages.Clear();
}
public override void Execute()
{
if (Settings.UseR)
{
var etarget = TargetSelector.GetTarget(R.Range, DamageType.Physical);
if (Damages.RDamage(etarget) + Damages.QDamage(etarget) + Damages.EDamage(etarget) + Damages.WDamage(etarget) > etarget.Health)
{
R.Cast();
}
}
if (Settings.UseE)
{
var etarget = TargetSelector.GetTarget(E.Range, DamageType.Magical);
var eprediction = E.GetPrediction(etarget);
if (eprediction.HitChance >= HitChance.High)
{
if (E.IsReady() && etarget != null && !ObjectManager.Player.HasBuff("SionR"))
{
E.Cast(eprediction.CastPosition);
}
}
}
if (Settings.UseW)
{
var target = TargetSelector.GetTarget(W.Range, DamageType.Physical);
if (W.IsReady() && target != null && !ObjectManager.Player.HasBuff("SionR"))
{
W.Cast();
}
}
if (Settings.UseQ)
{
var target = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
var eprediction = Q.GetPrediction(target);
if (eprediction.HitChance >= HitChance.High && !ObjectManager.Player.HasBuff("SionR"))
{
if (Q.IsReady() && target != null && Player.Instance.IsFacing(target))
{
Q.Cast(eprediction.CastPosition);
}
}
}
if (activatedP)
{
var target = TargetSelector.GetTarget(2000, DamageType.Physical);
if (Q.IsReady() && Player.Instance.Position.Distance(target) > target.GetAutoAttackRange())
{
Q.Cast(target);
}
}
}
public override void SerializeEffect <T>(T effect, DM_Effect holder)
{
var puncDamage = effect as PunctualDamage;
Knockback = puncDamage.Knockback;
HitInventory = puncDamage.HitInventory;
Damage = Damages.ParseDamageArray(puncDamage.Damages);
Damages_AI = Damages.ParseDamageArray(puncDamage.DamagesAI);
IgnoreHalfResistances = puncDamage.IgnoreHalfResistances;
}
public override void Execute()
{
if (Player.Instance.IsDead)
{
return;
}
var enemies =
EntityManager.Heroes.Enemies.Where(
e => e.IsEnemy && e.IsVisible && !e.IsDead && !e.IsZombie && !e.IsInvulnerable && e.Health > 0)
.ToList();
foreach (var enemy in enemies)
{
if (Settings.KSQ && SpellManager.Q.IsReady() && Damages.QDamage(enemy) > enemy.Health &&
SpellManager.Q.IsInRange(enemy))
{
if (enemy.HasBuffOfType(BuffType.SpellImmunity) || enemy.HasBuffOfType(BuffType.SpellShield))
{
continue;
}
var pred = Q.GetPrediction(enemy);
if (pred.HitChance >= HitChance.High)
{
Q.Cast(pred.CastPosition);
break;
}
}
if (Settings.KSE && SpellManager.E.IsReady() && Damages.EDamage(enemy) > enemy.Health &&
SpellManager.E.IsInRange(enemy))
{
if (enemy.HasBuffOfType(BuffType.SpellImmunity) || enemy.HasBuffOfType(BuffType.SpellShield))
{
continue;
}
var pred = E.GetPrediction(enemy);
if (pred.HitChance >= HitChance.High)
{
E.Cast(pred.CastPosition);
break;
}
}
if (Settings.KSR && SpellManager.R.IsReady() && Damages.RDamage(enemy) > enemy.Health &&
SpellManager.R.IsInRange(enemy))
{
if (enemy.HasBuffOfType(BuffType.SpellImmunity) || enemy.HasBuffOfType(BuffType.SpellShield))
{
continue;
}
R.Cast(enemy);
break;
}
}
}
public override void Execute()
{
// Skills
if (Settings.UseR && R.IsReady() && PlayerMana >= SettingsMana.MinRManaC)
{
var target = TargetSelector.GetTarget(R.Range, DamageType.Magical);
if (target != null)
{
if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
{
var targetHealth = target.TotalShieldHealth();
if (target.HasBuff("TristanaEChargeSound"))
{
targetHealth -= Damages.EDamage(target);
}
if (targetHealth < Damages.RDamage(target))
{
R.Cast(target);
return;
}
}
}
}
if (Settings.UseW && W.IsReady() && PlayerMana >= SettingsMana.MinWManaC)
{
var target = TargetSelector.GetTarget(W.Range, DamageType.Magical);
if (target != null)
{
if (!Settings.WTurret && Extensions.CountEnemiesInRange(target, 200) <= 2)
{
if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield) &&
!target.IsUnderTurret())
{
var pred = W.GetPrediction(target);
if (pred.HitChance >= SettingsPrediction.MinWHCCombo)
{
W.Cast(pred.CastPosition);
}
}
}
else
{
if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
{
var pred = W.GetPrediction(target);
if (pred.HitChance >= SettingsPrediction.MinWHCCombo)
{
W.Cast(pred.CastPosition);
}
}
}
}
}
}
public void InsertDamages(Damages damages)
{
if ((damages.EntityState != EntityState.Detached))
{
this.ObjectContext.ObjectStateManager.ChangeObjectState(damages, EntityState.Added);
}
else
{
this.ObjectContext.Damages.AddObject(damages);
}
}
public void AddMove(Command move, HitPos hitPosition, int damage,
CrushProp crushProperty = CrushProp.None,
PositionProp positionProperty = PositionProp.Stand,
PositionProp enemyPositionProperty = PositionProp.Stand)
{
Commands.Add(move);
HitPositions.Add(hitPosition);
Damages.Add(damage);
CrushProperties.Add(crushProperty);
PositionProperties.Add(positionProperty);
}
public static void SpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsMe)
{
return;
}
if ((Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) &&
MenuManager.LaneClearMenu["LCQ"].Cast <CheckBox>().CurrentValue) &&
Program.Q.IsReady())
{
if (Orbwalker.CanAutoAttack)
{
return;
}
foreach (var minion in EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy,
Variables._Player.ServerPosition, Variables._Player.GetAutoAttackRange()))
{
if (minion == null)
{
return;
}
var dmg = Variables._Player.GetSpellDamage(minion, SpellSlot.Q) +
Variables._Player.GetAutoAttackDamage(minion);
if (Prediction.Health.GetPrediction(minion, (int)(Variables._Player.AttackDelay * 1000)) <= dmg / 2 &&
(Orbwalker.LastTarget == null || Orbwalker.LastTarget.NetworkId != minion.NetworkId))
{
Player.CastSpell(SpellSlot.Q, Game.CursorPos);
}
}
}
var LastHitE = Variables._Player;
foreach (
var Etarget in
EntityManager.Heroes.Enemies.Where(
Etarget => Etarget.IsValidTarget(Program.E.Range) && Etarget.Path.Count() < 2))
{
if (MenuManager.ComboMenu["Ekill"].Cast <CheckBox>().CurrentValue&& Program.E.IsReady() &&
Variables._Player.CountEnemiesInRange(600) <= 1)
{
var dmgE = Variables._Player.GetSpellDamage(Etarget, SpellSlot.E);
if (dmgE > Etarget.Health ||
(Damages.WTarget(Etarget) == 2 && dmgE + Damages.Wdmg(Etarget) > Etarget.Health))
{
LastHitE = Etarget;
}
}
if (LastHitE != Variables._Player)
{
Program.E.Cast(LastHitE);
}
}
}
public override void Execute()
{
if (Settings.UseRk && R.IsReady() && E.IsReady() && Q.IsReady())
{
var target = TargetSelector.GetTarget(R.Range, DamageType.Physical);
if (target != null && Damages.RDamage(target) + Damages.QDamage(target) + Damages.EDamage(target) + Damages.FaaDamage(target) > target.Health)
{
R.Cast(target);
}
}
var qtarget = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
if (Settings.UseE && E.IsReady() &&
(qtarget.IsValidTarget(Q.Range) && Q.IsReady()))
{
var vec = qtarget.ServerPosition - ObjectManager.Player.Position;
var castBehind = E.GetPrediction(qtarget).CastPosition + Vector3.Normalize(vec) * 100;
E.Cast(castBehind);
Q.Cast(castBehind);
}
if (Settings.UseW)
{
var target = TargetSelector.GetTarget(W.Range, DamageType.Physical);
if (W.IsReady() && target != null)
{
W.Cast();
}
}
if (Settings.UseQ && Q.IsReady() && !E.IsReady())
{
var wtarget = TargetSelector.GetTarget(W.Range, DamageType.Physical);
var prede = Q.GetPrediction(wtarget);
if (prede.HitChance >= HitChance.High)
{
if (wtarget != null)
{
Q.Cast(prede.CastPosition);
}
}
}
if (Settings.UseRi && R.IsReady())
{
var target = TargetSelector.GetTarget(R.Range, DamageType.Physical);
if (R.IsReady() && target != null)
{
R.Cast(target);
}
}
}
/// <summary>
/// 戦闘詳細の情報を出力します。
/// </summary>
public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.AppendFormat("{0} → {1}\r\n", GetAttackerName(), GetDefenderName());
if (AttackType >= 0)
{
builder.Append("[").Append(GetAttackKind()).Append("] ");
}
for (int i = 0; i < Damages.Length; i++)
{
if (CriticalTypes[i] == CriticalType.Invalid) // カットイン(主砲/主砲)、カットイン(主砲/副砲)時に発生する
{
continue;
}
if (i > 0)
{
builder.Append(" , ");
}
switch (CriticalTypes[i])
{
case CriticalType.Miss:
builder.Append("Miss");
break;
case CriticalType.Hit:
builder.Append(Damages[i]).Append(" Dmg");
break;
case CriticalType.Critical:
builder.Append(Damages[i]).Append(" Critical!");
break;
}
}
{
int before = Math.Max(DefenderHP, 0);
int after = Math.Max(DefenderHP - Damages.Sum(), 0);
if (before != after)
{
builder.AppendFormat(" ( {0} → {1} )", before, after);
}
}
builder.AppendLine();
return(builder.ToString());
}
public virtual void InflictDamages(Damages damages)
{
if (!ObjectAvailable)
{
return;
}
damages.Apply();
if (!Stats.IsLifeStealImmune && damages.ApplyAutoAttack && damages.Type == DamageType.DAMAGE_TYPE_PHYSICAL)
{
damages.Source.Stats.Health.Heal(damages.Delta * damages.Source.Stats.LifeSteal.TotalSafe);
}
if (Shields.Magical > 0 && damages.Type == DamageType.DAMAGE_TYPE_MAGICAL)
{
float value = Shields.UseMagicalShield(damages.Delta);
Stats.Health.Current -= value;
float shieldLoss = -(damages.Delta - value);
OnShieldModified(true, false, shieldLoss);
}
else if (Shields.Physical > 0 && damages.Type == DamageType.DAMAGE_TYPE_PHYSICAL)
{
float value = Shields.UsePhysicalShield(damages.Delta);
Stats.Health.Current -= value;
float shieldLoss = -(damages.Delta - value);
OnShieldModified(false, true, shieldLoss);
}
else if (Shields.MagicalAndPhysical > 0)
{
float value = Shields.UseMagicalAndPhysicalShield(damages.Delta);
Stats.Health.Current -= value;
float shieldLoss = -(damages.Delta - value);
OnShieldModified(true, true, shieldLoss);
}
else
{
Stats.Health.Current -= damages.Delta;
Game.Send(new DamageDoneMessage(damages.Result, damages.Type, damages.Delta, NetId, damages.Source.NetId));
}
UpdateStats();
damages.Source.UpdateStats();
EventsBinder.OnDamagesInflicted(damages);
if (Stats.Health.Current <= 0)
{
OnDead(damages.Source);
}
}
public override void Execute()
{
if (Settings.UseE)
{
var etarget = TargetSelector.GetTarget(E.Range, DamageType.Physical);
var eprediction = E.GetPrediction(etarget);
if (eprediction.HitChance >= HitChance.High)
{
if (E.IsReady() && etarget != null)
{
E.Cast(eprediction.CastPosition);
}
}
}
if (Settings.UseW)
{
var target = TargetSelector.GetTarget(W.Range, DamageType.Physical);
if (W.IsReady() && target != null)
{
W.Cast();
}
}
if (Settings.UseQ)
{
var target = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
if (Q.IsReady() && target != null)
{
Q.Cast();
}
}
if (Settings.UseR && R.IsReady())
{
var target = TargetSelector.GetTarget(E.Range, DamageType.Physical);
if (target.IsValidTarget(R.Range) && !target.IsZombie && !target.IsInvulnerable && !target.IsDead)
{
int passiveCounter = target.GetBuffCount("dariushemo") <= 0 ? 0 : target.GetBuffCount("dariushemo");
if (!target.HasBuffOfType(BuffType.Invulnerability) && !target.HasBuffOfType(BuffType.SpellShield))
{
if (Damages.RDamage(target, passiveCounter) >=
target.Health + Damages.PassiveDmg(target, 1))
{
if (!target.HasBuffOfType(BuffType.Invulnerability) &&
!target.HasBuffOfType(BuffType.SpellShield))
{
R.Cast(target);
}
}
}
}
}
}
public void DeleteDamages(Damages damages)
{
if ((damages.EntityState != EntityState.Detached))
{
this.ObjectContext.ObjectStateManager.ChangeObjectState(damages, EntityState.Deleted);
}
else
{
this.ObjectContext.Damages.Attach(damages);
this.ObjectContext.Damages.DeleteObject(damages);
}
}
private static Car ToModel(DB.Cars dbItem, UnitOfWork unitOfWork)
{
var car =
new Car()
{
Id = dbItem.Id,
Color = (CarColor)dbItem.Color,
BodyType = (Body)dbItem.Body,
BodyNumber = dbItem.BodyNumber,
Enginge = dbItem.Engine,
Kpp = dbItem.Kpp,
Number = dbItem.Number,
Sts = dbItem.Sts,
TO = dbItem.TO,
Year = dbItem.Year,
Insurance = dbItem.Insurance,
Model = CarModels.Read(dbItem.Model.Id, unitOfWork),
Mileage = dbItem.Mileage,
SiteId = dbItem.SiteId,
User = Users.Read(dbItem.User.Id, unitOfWork),
Deleted = dbItem.Deleted
};
if (dbItem.CarRental != null)
{
car.CarRental = CarRentals.Read(dbItem.CarRental.Id, unitOfWork);
}
foreach (var damage in dbItem.DamagesCollection.Where(damage => !damage.Archive))
{
car.Damages.Add(Damages.Read(damage.Id, unitOfWork));
}
foreach (var rent in dbItem.RentsCollection)
{
car.Rents.Add(Rents.Read(rent.Id, unitOfWork));
}
foreach (var order in dbItem.OrdersCollection.Where(q => !q.Deleted))
{
var cor = new CarOrder()
{
ClientId = order.Client.Id,
DateFrom = order.DateFrom,
DateTo = order.DateTo,
Id = order.Id,
Territory = order.Territory
};
foreach (var serv in order.OrderServicesCollection)
{
cor.Services.Add(Services.Read(serv.Service.Id, unitOfWork));
}
car.Orders.Add(cor);
}
return(car);
}
private static void AddDependencies(UnitOfWork unitOfWork, Car item, int carId)
{
foreach (var itm in item.Damages)
{
itm.CarId = carId;
Damages.AddNew(itm, unitOfWork);
}
foreach (var rent in item.Rents)
{
rent.CarId = carId;
Rents.AddNew(rent, unitOfWork);
}
}
private static void AddDependencies(UnitOfWork unitOfWork, Order item, DB.Orders dbItem)
{
foreach (var itm in item.Damages)
{
var did = Damages.AddNew(itm, unitOfWork, true);
itm.Id = did;
OrderDamages.AddNew(itm, dbItem, unitOfWork);
}
foreach (var serv in item.Services)
{
OrderServices.AddNew(serv, dbItem, unitOfWork);
}
}
private void ExecuteAddDamage()
{
AddDamageWindowViewModel addDamageWindowViewModel = new AddDamageWindowViewModel();
Model.Damage damage = addDamageWindowViewModel.GetDamage();
if (damage != null)
{
DamageViewModel damageViewModel = new DamageViewModel {
Damage = damage
};
Damages.Add(damageViewModel);
}
}
public void ReadXML(XmlNode xmlNode)
{
try
{
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
if (childNode.Name == "Name")
{
Name = childNode.InnerText;
}
else if (childNode.Name == "Modifier")
{
Modifier = Convert.ToInt32(childNode.InnerText);
}
else if (childNode.Name == "Type")
{
Type = Methods.GetAttackTypeFromString(childNode.InnerText);
}
else if (childNode.Name == "Ability")
{
Ability = Methods.GetAbilityFromString(childNode.InnerText);
}
else if (childNode.Name == "Damages")
{
foreach (XmlNode damageNode in childNode.ChildNodes)
{
if (damageNode.Name == "Damage")
{
Damages.Add(new Damage(damageNode));
}
}
}
else if (childNode.Name == "ThreatRangeMin")
{
ThreatRangeMin = Convert.ToInt32(childNode.InnerText);
}
else if (childNode.Name == "CritMultiplier")
{
CritMultiplier = Convert.ToInt32(childNode.InnerText);
}
else if (childNode.Name == "TwoHanded")
{
TwoHanded = Convert.ToBoolean(childNode.InnerText);
}
}
}
catch (XmlException e)
{
MessageBox.Show(e.ToString());
}
}
public override void Execute()
{
if (Settings.UseQ && Q.IsReady() && PlayerMana >= SettingsMana.MinQMana)
{
var target =
EntityManager.MinionsAndMonsters.CombinedAttackable.Where(e => e.IsValidTarget(Q.Range))
.OrderBy(e => e.Health).FirstOrDefault(e => e.Health <= Damages.QDamage(e));
if (target != null)
{
Q.Cast(target);
Debug.WriteChat("Casting Q in LastHit on {0}", target.BaseSkinName);
}
}
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.F))
{
if (isTrigger == true)
{
arme1.transform.parent = null;
Destroy(arme1);
arme2.transform.parent = pivot.transform;
arme2.transform.position = arme1.transform.position;
Damages damages = arme2.GetComponent <Damages>();
damages.isOnPlayer = true;
}
}
}
public double AddDamagesUp(Damages Damages, int yearsToAggregate, Timestep emissionPeriod)
{
double i_totalDamage = 0.0;
for (int year = emissionPeriod.Value; year < Math.Min(LegacyConstants.NYear, emissionPeriod.Value + yearsToAggregate); year++)
{
for (int region = 0; region < LegacyConstants.NoReg; region++)
{
for (int sector = 0; sector < LegacyConstants.NoSector; sector++)
{
i_totalDamage += Damages[year, region, (Sector)sector] * this[year, region];
}
}
}
return i_totalDamage;
}
