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 <Potion> (own, targets, x => {
x.extraHp = extraHp;
});
return(true);
}
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 <BurnAffect> (own, targets, x => {
x.subtractHp = subtractHp;
x.turnNumber = turnNumber;
});
return(true);
}
public void HandleAttack(Race target)
{
OnSetTimeout(() => {
Affect.CreatePrimitiveAndUse <StunAffect> (own, new Race[] { target }, x => {
x.turnNumber = 1;
});
}, 3f);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <StunAffectAndDamageDealing> (own, targets, x => {
x.turnNumber = turnNumber;
x.damage = damage;
});
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 <BurnAffect> (own, new Race[] { target }, x => {
x.subtractHp = 6f;
x.turnNumber = 3;
});
}, 3f);
}
public override bool Use(Race[] targets)
{
if (Affect.HasAffect <SwordmanB3> (own))
{
return(false);
}
Affect.CreatePrimitiveAndUse <SwordmanB3> (own, targets);
return(true);
}
public override bool Use(Race[] targets)
{
if (Affect.HasAffect <Artifact1> (own))
{
return(false);
}
Affect.CreatePrimitiveAndUse <Artifact2> (own, targets);
return(true);
}
public override bool Use(Race[] targets)
{
if (Affect.HasAffect <Sword> (own))
{
return(false);
}
Affect.CreatePrimitiveAndUse <Sword> (own, targets);
upgradePrice *= 1.2f;
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)
{
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 override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <StatDamageAdding> (own, targets, d => d.extraDamage = extraDamage);
return(true);
}
public override void Execute()
{
Affect.CreatePrimitiveAndUse <HealthPowerRestoring> (own, targets, hp => hp.extraHp = extraHp);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <GoldAdding> (own, targets, g => g.extraGold = extraGold);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <AddVitalityPoint> (own, targets, x => x.point = point);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <Antidote> (own, targets);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <StunAffect> (own, targets, x => x.turnNumber = turnNumber);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <BurstStrength> (own, targets);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <EnergyAdding> (own, targets, e => e.extraEnergy = extraEnergy);
return(true);
}
public static void OccurAffectChange(Race own, Race target)
{
var occurs = new Dictionary <Type, float> ();
var defineAffects = new Dictionary <Type, DefineAffectArgs> ();
var addAffectHandler = new Action <Affect, Type>((affect, t) => {
var method = affect.GetType().GetMethod("AdditionalAffectChange"
, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic
, null
, CallingConventions.Any
, new Type[] { t, target.GetType() }
, null);
var useDefine = affect.GetType().GetMethod("UseDefineAffect"
, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic
, null
, CallingConventions.Any
, new Type[] { t }
, null);
if (method != null)
{
var value = method.Invoke(affect, new object[] { null, target });
var useDefineAffect = (bool)useDefine.Invoke(affect, new object[] { null });
if (value != null)
{
if (occurs.ContainsKey(t))
{
occurs[t] += (float)value;
}
else
{
occurs.Add(t, (float)value);
}
}
if (useDefineAffect && !defineAffects.ContainsKey(t))
{
var methodDefineAffect = affect.GetType().GetMethod("DefineAffect"
, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic
, null
, CallingConventions.Any
, new Type[] { t }
, null);
defineAffects.Add(t, new DefineAffectArgs {
affect = affect,
methodDefineAffect = methodDefineAffect
});
}
}
});
own.GetModule <AffectModule> (am => {
foreach (var affect in am.affects)
{
var interfaceTypes = affect.GetType().GetInterfaces();
foreach (var interfaceType in interfaceTypes)
{
if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IAdditionalAffectChange <>))
{
var t = interfaceType.GetGenericArguments();
if (t.Length == 0)
{
continue;
}
var tt = t[0];
addAffectHandler(affect, tt);
}
}
}
});
foreach (var occur in occurs)
{
var percent = Mathf.Min(occur.Value * 100f, 100f);
var probability = Probability.Initialize(new bool[] { false, true }, new float[] {
100f - percent,
percent
});
var result = Probability.GetValueInProbability(probability);
if (!result)
{
continue;
}
Affect.CreatePrimitiveAndUse(occur.Key, own, new Race[] { target }, af => {
foreach (var defineAffect in defineAffects.Where(d => d.Key == occur.Key))
{
var affect = defineAffect.Value.affect;
var method = defineAffect.Value.methodDefineAffect;
method.Invoke(affect, new object[] { af });
}
});
}
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <StatTechniqueAdding> (own, targets, x => x.extraTechnique = extraTechnique);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <HeartOfHestia> (own, targets);
return(true);
}
public void AssignAttackableAffect(Race target)
{
Affect.CreatePrimitiveAndUse <BurnAffect> (own, new Race[] { target }, b => {
b.subtractHp = 10f;
});
}
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 <BlessingOfAmphitrite> (own, targets);
return(true);
}
public override bool Use(Race[] targets)
{
Affect.CreatePrimitiveAndUse <NegativeAffectDissolvingAndHealthPowerRestoring> (own, targets, n => n.extraHp = extraHp);
return(true);
}
