public override void OnEventDidTrigger(RuleDealDamage evt)
{
var master = evt?.Target?.Descriptor?.Master.Value;
if (master == null)
{
return;
}
if (master.Descriptor.State.IsDead)
{
return;
}
//Main.logger.Log($"{evt.Target.Damage}, {evt.Target.HPLeft}");
int max_can_transfer = master.HPLeft - 1;
int max_need_transfer = (-evt.Target.HPLeft) - evt.Target.Stats.Constitution + 1;
int transfer_damage = Math.Min(max_can_transfer, max_need_transfer);
transfer_damage = Math.Min(transfer_damage, evt.Target.Damage);
if (transfer_damage <= 0)
{
return;
}
evt.Target.Damage -= transfer_damage;
var damage_bundle = new DamageBundle(new DirectDamage(new DiceFormula(transfer_damage, DiceType.One), 0));
var rule = this.Fact.MaybeContext.TriggerRule(new RuleDealDamage(evt.Target, master, damage_bundle));
}
private int DealHitPointsDamage(ContextActionDealDamage2.DamageInfo info)
{
if (this.Context.MaybeCaster == null)
{
UberDebug.LogError(this, (object)"Caster is missing", (object[])Array.Empty <object>());
return(0);
}
BaseDamage damage1 = this.DamageType.GetDamageDescriptor(info.Dices, info.Bonus).CreateDamage();
damage1.EmpowerBonus = !info.Empower ? damage1.EmpowerBonus : 1.5f;
damage1.Maximized = info.Maximize || damage1.Maximized;
BaseDamage baseDamage = damage1;
DamageCriticalModifierType?criticalModifier = info.CriticalModifier;
int?critModifier = criticalModifier.HasValue ? new int?(criticalModifier.GetValueOrDefault().IntValue()) : new int?();
baseDamage.CriticalModifier = critModifier;
damage1.Half = this.Half;
damage1.AlreadyHalved = info.PreRolledValue.HasValue && this.Half && this.AlreadyHalved;
damage1.PreRolledValue = info.PreRolledValue;
if (this.IsAoE && !info.PreRolledValue.HasValue)
{
int?nullable2 = this.Context.AoEDamage.Get <ContextActionDealDamage, int?>(this, new int?());
if (nullable2.HasValue)
{
damage1.PreRolledValue = nullable2;
}
}
ContextAttackData data = ElementsContext.GetData <ContextAttackData>();
DamageBundle damage2 = (DamageBundle)damage1;
damage2.Weapon = data?.AttackRoll?.Weapon;
RuleDealDamage rule = new RuleDealDamage(this.Context.MaybeCaster, this.Target.Unit, damage2)
{
Projectile = data?.Projectile,
AttackRoll = data?.AttackRoll,
HalfBecauseSavingThrow = info.HalfBecauseSavingThrow,
MinHPAfterDamage = !this.UseMinHPAfterDamage ? new int?() : new int?(this.MinHPAfterDamage),
SourceAbility = this.Context.SourceAbility,
SourceArea = this.Context.AssociatedBlueprint as BlueprintAbilityAreaEffect
};
if (this.IsShadowEvocation)
{
RuleSavingThrow ruleSavingThrow = this.Context.TriggerRule(new RuleSavingThrow(this.Target.Unit, SavingThrowType.Will, this.Context.Params.DC));
rule.ReducedBecauseOfShadowEvocation = ruleSavingThrow.IsPassed;
}
if (this.IsShadowEvocationGreater)
{
RuleSavingThrow ruleSavingThrow = this.Context.TriggerRule(new RuleSavingThrow(this.Target.Unit, SavingThrowType.Will, this.Context.Params.DC));
rule.ReducedBecauseOfShadowEvocationGreater = ruleSavingThrow.IsPassed;
}
this.Context.TriggerRule <RuleDealDamage>(rule);
if (this.IsAoE && !this.Context.AoEDamage.Get <ContextActionDealDamage, int?>(this, new int?()).HasValue)
{
this.Context.AoEDamage[this] = new int?(rule.Calculate.CalculatedDamage.FirstItem <DamageValue>().RolledValue);
}
return(rule.Damage);
}
public override void OnEventDidTrigger(RuleDealDamage evt)
{
if (evt.Target.Damage < 0)
{
return;
}
var pet = evt?.Target?.Descriptor?.Pet;
if (pet == null)
{
return;
}
/*if (evt.Target.HPLeft <= 0)
* {
* return;
* }*/
if (pet.Descriptor.State.IsDead)
{
return;
}
int max_can_transfer = pet.HPLeft + pet.Stats.Constitution - 1;
int max_need_transfer = threshold - evt.Target.HPLeft;
int transfer_damage = Math.Min(max_can_transfer, max_need_transfer);
transfer_damage = Math.Min(transfer_damage, evt.Target.Damage);
if (transfer_damage <= 0)
{
return;
}
evt.Target.Damage -= transfer_damage;
var damage_bundle = new DamageBundle(new DirectDamage(new DiceFormula(transfer_damage, DiceType.One), 0));
var rule = this.Fact.MaybeContext.TriggerRule(new RuleDealDamage(evt.Target, pet, damage_bundle));
}
private void triggerEffect()
{
int bonus = this.ContextValue.Calculate(this.Context);
if (Stat != StatType.Unknown)
{
ModifiableValue stat = this.Owner.Stats.GetStat(this.Stat);
RuleDealStatDamage rule = new RuleDealStatDamage(this.Owner.Unit, this.Owner.Unit, this.Stat, DiceFormula.Zero, bonus);
rule.Reason = (RuleReason)this.Fact;
this.Context.TriggerRule <RuleDealStatDamage>(rule);
}
else
{
var hp_damage = new DamageBundle(new BaseDamage[1]
{
(BaseDamage) new DirectDamage(new DiceFormula(0, DiceType.Zero), bonus)
}
);
RuleDealDamage rule = new RuleDealDamage(this.Owner.Unit, this.Owner.Unit, hp_damage);
rule.Reason = (RuleReason)this.Fact;
this.Context.TriggerRule <RuleDealDamage>(rule);
}
}
public override void RunAction()
{
UnitEntityData maybeCaster = this.Context.MaybeCaster;
if (maybeCaster == null)
{
UberDebug.LogError((object)"Caster is missing", (object[])Array.Empty <object>());
}
else
{
var target = this.Target;
if (target == null)
{
return;
}
var weapon = maybeCaster.Body.PrimaryHand.MaybeWeapon;
RuleAttackRoll attackWithWeapon = new RuleAttackRoll(maybeCaster, target.Unit, weapon, 0);
attackWithWeapon.Reason = (RuleReason)this.Context;
attackWithWeapon.AttackType = AttackType.RangedTouch;
RuleAttackRoll rule = attackWithWeapon;
this.Context.TriggerRule <RuleAttackRoll>(rule);
RuleCalculateWeaponStats weaponRule = new RuleCalculateWeaponStats(maybeCaster, weapon, (RuleAttackWithWeapon)null);
this.Context.TriggerRule <RuleCalculateWeaponStats>(weaponRule);
DamageBundle damage = (DamageBundle)null;
foreach (DamageDescription damageDescription in weaponRule.DamageDescription)
{
damageDescription.TypeDescription = new DamageTypeDescription()
{
Type = DamageType.Energy,
Energy = this.damageType
};
if (damage == null)
{
damage = new DamageBundle(weapon, weaponRule.WeaponSize, damageDescription.CreateDamage());
}
else
{
damage.Add(damageDescription.CreateDamage());
}
}
if (rule.IsHit)
{
action_on_success?.Run();
if (this.damageType == DamageEnergyType.PositiveEnergy)
{
if (target.Unit.Descriptor.HasFact(library.Get <BlueprintUnitFact>("734a29b693e9ec346ba2951b27987e33")))
{
this.Context.TriggerRule <RuleDealDamage>(new RuleDealDamage(this.Context.MaybeCaster, this.Target.Unit, damage));
}
else
{
foreach (var i in damage)
{
this.Context.TriggerRule <RuleHealDamage>(new RuleHealDamage(this.Context.MaybeCaster, this.Target.Unit, i.Dice, i.Bonus));
}
}
}
else
{
if (target.Unit.Descriptor.HasFact(library.Get <BlueprintUnitFact>("734a29b693e9ec346ba2951b27987e33")))
{
foreach (var i in damage)
{
this.Context.TriggerRule <RuleHealDamage>(new RuleHealDamage(this.Context.MaybeCaster, this.Target.Unit, i.Dice, i.Bonus));
}
}
else
{
this.Context.TriggerRule <RuleDealDamage>(new RuleDealDamage(this.Context.MaybeCaster, this.Target.Unit, damage));
}
}
}
else
{
action_on_miss?.Run();
}
}
}
public RuleDealDamageNew([NotNull] UnitEntityData initiator, [NotNull] UnitEntityData target, DamageBundle damage) : base(initiator, target, damage)
{
}
