public static void Calculate(float bonusDamage, Race attacker, Race[] targets)
{
var stat = attacker.GetModule <StatModule> ();
foreach (var target in targets)
{
var targetStat = target.GetModule <StatModule> ();
var isHit = AccuracyCalculator.IsHit(stat.attackRating, targetStat.attackRating);
isHit = !isHit?AccuracyCalculator.MakeSureHit(attacker) : isHit;
if (isHit)
{
var isCritHit = AccuracyCalculator.IsCriticalHit(attacker, stat.criticalRating);
isCritHit = !isCritHit?AccuracyCalculator.MakeSureCritical(attacker) : isCritHit;
// optional Damage
var outputDamage = AttackPowerCalculator.TakeDamage(bonusDamage, targetStat.magicResist, isCritHit);
AccuracyCalculator.HandleCriticalDamage(ref outputDamage, attacker, target);
AttackPowerCalculator.HandleDamage(ref outputDamage, attacker, target);
target.GetModule <HealthPowerModule> (x => x.SubtractHp(outputDamage));
}
else
{
var isCritHit = AccuracyCalculator.IsCriticalHit(attacker, stat.criticalRating);
var damage = AttackPowerCalculator.TakeDamage(bonusDamage, targetStat.physicalDefend, isCritHit);
Affect.GetSubAffects <IMissingHandler>(target, handler => handler.HandleMissing(damage, attacker));
}
}
}
public static void RemoveAffect(Race who, Affect affect)
{
var affectModule = who.GetModule <AffectModule> ();
Destroy(affect.gameObject);
affectModule.RefreshAffect();
}
public override bool Upgrade(float price = 0)
{
if (upgradeCount == 9)
{
return(false);
}
if (EnoughGold(own, upgradePrice))
{
++upgradeCount;
Affect.HasAffect <Sword> (own, (a) => {
a.Upgrade();
title = "Sword lv." + (upgradeCount + 1);
brief = "+" + Mathf.Floor(a.damage) + " damage";
SubtractGold(own, upgradePrice);
upgradePrice *= 1.2f;
});
var addingItem = GetRandomItem();
if (addingItem)
{
brief += ", " + addingItem.brief;
}
return(true);
}
return(false);
}
public override bool Upgrade(float price = 0)
{
if (upgradeCount == 2)
{
return(false);
}
if (EnoughGold(own, upgradePrice))
{
++upgradeCount;
Affect.HasAffect <Ring> (own, (a) => {
a.Upgrade();
title = "Ring lv." + (upgradeCount + 1);
brief = "+" + Mathf.Floor(a.point) + " all stats";
SubtractGold(own, upgradePrice);
if (upgradeCount == 1)
{
upgradePrice = 120f;
}
});
var addingItem = GetRandomItem();
if (addingItem)
{
brief += ", " + addingItem.brief;
}
return(true);
}
return(false);
}
public override void Execute()
{
own.GetModule <AffectModule>((a) => {
a.RemoveAffect(m => typeof(INegativeAffect).IsAssignableFrom(m.GetType()));
});
Affect.CreatePrimitiveAndUse <HealthPowerRestoring> (own, new[] { own }, hp => hp.extraHp = extraHp);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <Potion> (own, targets, x => {
x.extraHp = extraHp;
});
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <SwordmanE1> (own, targets, t => {
t.gainPoint = gainPoint;
});
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <BurnAffect> (own, targets, x => {
x.subtractHp = subtractHp;
x.turnNumber = turnNumber;
});
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <SwordmanD1> (own, targets, t => {
t.gainPoint = gainPoint;
t.storedEnergy = Mathf.Max(1f, own.GetModule <EnergyModule> ().energy);
});
return(true);
}
public void HandleAttack(Race target)
{
OnSetTimeout(() => {
Affect.CreatePrimitiveAndUse <StunAffect> (own, new Race[] { target }, x => {
x.turnNumber = 1;
});
}, 3f);
}
public void AddAffect(Affect affect)
{
if (_affects == null)
{
_affects = new List <Affect> ();
}
_affects.Add(affect);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <StunAffectAndDamageDealing> (own, targets, x => {
x.turnNumber = turnNumber;
x.damage = damage;
});
return(true);
}
public override bool Disuse()
{
Affect.GetAffects <Artifact2> (own, x => {
x.Disuse();
Destroy(x.gameObject);
});
return(true);
}
public override bool Use(Race[] targets)
{
if (Affect.HasAffect <SwordmanB3> (own))
{
return(false);
}
Affect.CreatePrimitiveAndUse <SwordmanB3> (own, targets);
return(true);
}
public void HandleAttack(Race target)
{
OnSetTimeout(() => {
Affect.CreatePrimitiveAndUse <BurnAffect> (own, new Race[] { target }, x => {
x.subtractHp = 6f;
x.turnNumber = 3;
});
}, 3f);
}
public override bool Use(Race[] targets)
{
if (Affect.HasAffect <Artifact1> (own))
{
return(false);
}
Affect.CreatePrimitiveAndUse <Artifact2> (own, targets);
return(true);
}
public virtual void StartTurn()
{
_isTurn = true;
_isEndTurn = false;
_turnNumber++;
GetModule <StatModule> (s => {
GetModule <HealthPowerModule>(hp => {
Affect.CreatePrimitiveAndUse <HealthPowerRestoring> (this, new Race[] { this }, hpr => hpr.extraHp = s.regenerateHp * hp.hp);
});
});
}
public override bool Use(Race[] targets)
{
if (Affect.HasAffect <Sword> (own))
{
return(false);
}
Affect.CreatePrimitiveAndUse <Sword> (own, targets);
upgradePrice *= 1.2f;
return(true);
}
void Update()
{
foreach (var target in targets)
{
ExecuteInTurn(target, () => {
Affect.Use(own, this);
if (turn == turnNumber)
{
Destroy(gameObject);
}
});
}
}
public float GetStat(string name)
{
var val = .0f;
Affect.GetSubAffects <GearAffect> (_race, x => {
var fi = x.GetType().GetField(name);
if (fi != null)
{
var v = fi.GetValue(x);
val += (float)System.Convert.ChangeType(v, typeof(float));
}
});
return(val);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <SwordmanA1> (own, targets, t => {
t.gainPoint = gainPoint;
if (usedNumber == 9)
{
own.GetModule <SkillModule> (s => {
s.Add <SwordmanA2Skill> (1);
});
SetVisible(false);
}
});
return(true);
}
void Update()
{
foreach (var target in targets)
{
ExecuteInTurn(target, () => {
if (turn <= turnNumber)
{
Affect.CreatePrimitiveAndUse <DamageDealing>(own, new Race[] { target }, d => d.damage = damage);
target.AllowAttack(false);
}
else
{
target.AllowAttack(true);
Destroy(gameObject);
}
});
}
}
public static bool IsCriticalHit(Race who, float attackerCHC)
{
var addition = 0f;
var percentCHC = attackerCHC * 100f;
Affect.GetSubAffects <IAdditionalCriticalHitChange> (who, x => {
addition += x.additionalCriticalHitChange;
});
addition *= 100f;
percentCHC = Mathf.Min(percentCHC + addition, 100f);
var chcProbability = Probability.Initialize(new bool[] { false, true }, new float[] {
100f - percentCHC,
percentCHC
});
var chcResult = Probability.GetValueInProbability(chcProbability);
return(chcResult);
}
public static void Use(Race own, Affect affect)
{
var a = affect;
foreach (var target in a.targets)
{
target.GetModule <AffectModule> ((am) => {
am.AddAffect(a);
});
var effectValueTransfer = own.GetModule <EffectValueTransferModule> ();
if (typeof(IPhysicalAttackingEventHandler).IsAssignableFrom(a.GetType()))
{
var physicalAttacking = ((IPhysicalAttackingEventHandler)a);
var stat = own.GetModule <StatModule> ();
var targetStat = target.GetModule <StatModule> ();
var isHit = AccuracyCalculator.IsHit(stat.attackRating, targetStat.attackRating);
isHit = !isHit?AccuracyCalculator.IsDodgeable(own, target) : isHit;
isHit = !isHit?AccuracyCalculator.MakeSureHit(own) : isHit;
effectValueTransfer.Add("isHit", isHit);
if (isHit)
{
var isCritHit = AccuracyCalculator.IsCriticalHit(own, stat.criticalRating);
isCritHit = !isCritHit?AccuracyCalculator.MakeSureCritical(own) : isCritHit;
// optional Damage
var outputDamage = AttackPowerCalculator.TakeDamage(physicalAttacking.bonusDamage, targetStat.physicalDefend, isCritHit);
AccuracyCalculator.HandleCriticalDamage(ref outputDamage, own, target);
AttackPowerCalculator.HandleDamage(ref outputDamage, own, target);
target.GetModule <HealthPowerModule> (x => x.SubtractHp(outputDamage));
effectValueTransfer.Add("damage", outputDamage);
effectValueTransfer.Add("targetHp", target.GetModule <HealthPowerModule> ().hp);
effectValueTransfer.Add("isCritHit", isCritHit);
effectValueTransfer.Add("targetNetId", target.netId.Value);
AttackPowerCalculator.OccurAffectChange(own, target);
AttackPowerCalculator.ExtraAttackableAffect(own, target);
physicalAttacking.HandleAttack(target);
}
else
{
var isCritHit = AccuracyCalculator.IsCriticalHit(own, stat.criticalRating);
var damage = AttackPowerCalculator.TakeDamage(physicalAttacking.bonusDamage, targetStat.physicalDefend, isCritHit);
effectValueTransfer.Add("damage", damage);
effectValueTransfer.Add("targetHp", target.GetModule <HealthPowerModule> ().hp);
effectValueTransfer.Add("isCritHit", isCritHit);
effectValueTransfer.Add("targetNetId", target.netId.Value);
physicalAttacking.HandleAttack(target);
}
}
else if (typeof(IMagicalAttackingEventHandler).IsAssignableFrom(a.GetType()))
{
var magicalAttacking = ((IMagicalAttackingEventHandler)a);
var stat = own.GetModule <StatModule> ();
var targetStat = target.GetModule <StatModule> ();
var isHit = AccuracyCalculator.IsHit(stat.attackRating, targetStat.attackRating);
isHit = !isHit?AccuracyCalculator.IsDodgeable(own, target) : isHit;
isHit = !isHit?AccuracyCalculator.MakeSureHit(own) : isHit;
effectValueTransfer.Add("isHit", isHit);
if (isHit)
{
var isCritHit = AccuracyCalculator.IsCriticalHit(own, stat.criticalRating);
isCritHit = !isCritHit?AccuracyCalculator.MakeSureCritical(own) : isCritHit;
// optional Damage
var outputDamage = AttackPowerCalculator.TakeDamage(magicalAttacking.bonusDamage, targetStat.magicResist, isCritHit);
AccuracyCalculator.HandleCriticalDamage(ref outputDamage, own, target);
AttackPowerCalculator.HandleDamage(ref outputDamage, own, target);
target.GetModule <HealthPowerModule> (x => x.SubtractHp(outputDamage));
effectValueTransfer.Add("damage", outputDamage);
effectValueTransfer.Add("targetHp", target.GetModule <HealthPowerModule> ().hp);
effectValueTransfer.Add("isCritHit", isCritHit);
effectValueTransfer.Add("targetNetId", target.netId.Value);
AttackPowerCalculator.OccurAffectChange(own, target);
AttackPowerCalculator.ExtraAttackableAffect(own, target);
magicalAttacking.HandleAttack(target);
}
else
{
var isCritHit = AccuracyCalculator.IsCriticalHit(own, stat.criticalRating);
var damage = AttackPowerCalculator.TakeDamage(magicalAttacking.bonusDamage, targetStat.physicalDefend, isCritHit);
effectValueTransfer.Add("damage", damage);
effectValueTransfer.Add("targetHp", target.GetModule <HealthPowerModule> ().hp);
effectValueTransfer.Add("isCritHit", isCritHit);
effectValueTransfer.Add("targetNetId", target.netId.Value);
magicalAttacking.HandleAttack(target);
}
}
else
{
a.Execute(target);
}
EmitAffects(own, new EmitAffectArgs {
affect = a,
target = target
});
}
a.Execute();
a.AddGainPoint();
a.HandlePlugins();
a.FlushAll();
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <StunAffect> (own, targets, x => x.turnNumber = turnNumber);
return(true);
}
public float AdditionalAffectChange(BurnAffect affect, Race target)
{
return(!ableBurnAffect || Affect.HasAffect <BurnAffect> (target) ? 0f : 1f);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <NegativeAffectDissolving> (own, targets);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <AddDefendChance> (own, targets, x => x.chance = chance);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <AddVitalityPoint> (own, targets, x => x.point = point);
return(true);
}
public override void Execute()
{
Affect.CreatePrimitiveAndUse <HealthPowerRestoring> (own, targets, hp => hp.extraHp = extraHp);
}
