static List <int> GetSecondaryPlayTargets(NetSkill ns, NetCard nc, NetBattlefield bf, List <int> primaryTargets, MHRandom r)
{
if (primaryTargets == null ||
primaryTargets.Count < 1)
{
return(null);
}
Subskill ss = ns.GetSubSkill();
if (ss.trigger.triggerGroup == ETriggerGroupType.DoAttack ||
ss.trigger.triggerGroup == ETriggerGroupType.DoAlternateAttack)
{
//there is no secondary targets of playing card to the battelfield unless its a spell
return(null);
}
if (ss.targets.script2 == null ||
string.IsNullOrEmpty(ss.targets.script2.scriptName))
{
return(null);
}
return(ns.FindSecondaryTargets(bf, -1, primaryTargets));
}
static List <CardAIPlanData> RefineMultiCastPlan(CardAI ai, CardAIPlanData entryState, List <CardAIPlanData> plans)
{
NetBattlefield bf = entryState.bf;
//get top plans and try to refine them
int min = Mathf.Min(plans.Count, ai.refiningSize);
for (int i = 0; i < min; i++)
{
for (int k = 0; k < ai.intensity; k++)
{
//prepare source for cast copying target enumerator so that it can be reused by the further casts
CardAIPlanData source = entryState;
NetSkill ns = bf.GetSkillByID(plans[i].GetTopCardPlay().skill);
//cast form the source plan data so that it is not casted "after" action we want to reiterate to different targets
CardAIPlanData d = CastSkillOnece(ai, ns, ns.GetOwner(bf), source, bf.CloneAndRemember(), plans[i].GetTopCardPlay().targetEnumerator);
if (d.valid && plans[i].value < d.value)
{
d.SetEnumerator(plans[i].GetTopCardPlay().targetEnumerator);
plans[i] = d;
}
}
}
//select best plan per skill
return(plans.GetRange(0, min));
}
static public List <CardAIPlanData> ProduceCastPlans(CardAI ai, CardAIPlanData data, List <NetSkill> skills, int count)
{
List <CardAIPlanData> plans = new List <CardAIPlanData>(skills.Count);
NetBattlefield bf = data.bf;
for (int i = 0; i < skills.Count; i++)
{
NetSkill ns = skills[i];
IEnumerator <List <int> > targetEnumerator = null;
for (int k = 0; k < count; k++)
{
CardAIPlanData d = CastSkillOnece(ai, ns, ns.GetOwner(bf), data, bf.CloneAndRemember(), targetEnumerator);
if (d.valid)
{
if (targetEnumerator == null)
{
targetEnumerator = d.GetTopCardPlay().targetEnumerator;
}
plans.Add(d);
}
}
}
return(plans);
}
static IList <int> GetPlayCardTargets(bool friendlyTurn, NetSkill ns, NetCard nc, NetBattlefield bf)
{
Subskill ss = ns.GetSubSkill();
if (ss.trigger.triggerGroup == ETriggerGroupType.DoAttack ||
ss.trigger.triggerGroup == ETriggerGroupType.DoAlternateAttack)
{
if (ss.trigger.requiredToBeInFrontline)
{
if (friendlyTurn)
{
return(bf.GetFreeFriendlyMeleeSlots(false));
}
else
{
return(bf.GetFreeEnemyMeleeSlots(false));
}
}
else if (ss.trigger.requiredToBeInBackline)
{
if (friendlyTurn)
{
return(bf.GetFreeFriendlyRangedSlots(false));
}
else
{
return(bf.GetFreeEnemyRangedSlots(false));
}
}
else
{
List <int> both;
if (friendlyTurn)
{
IList <int> a = bf.GetFreeFriendlyMeleeSlots(false);
IList <int> b = bf.GetFreeFriendlyRangedSlots(false);
both = new List <int>(a.Count + b.Count);
both.AddRange(a);
both.AddRange(b);
return(both);
}
else
{
IList <int> a = bf.GetFreeEnemyMeleeSlots(false);
IList <int> b = bf.GetFreeEnemyRangedSlots(false);
both = new List <int>(a.Count + b.Count);
both.AddRange(a);
both.AddRange(b);
return(both);
}
}
}
else
{
return(ns.FindValidTargets(bf, -1));
}
}
static IEnumerator <List <int> > GetTargetEnumerator(NetSkill ns, NetCard nc, IList <int> potentialTargets, CardAI ai)
{
if (potentialTargets.Count < 1)
{
return(null);
}
Subskill ss = ns.GetSubSkill();
int count = 0;
if (ss.trigger.triggerGroup == ETriggerGroupType.DoAttack ||
ss.trigger.triggerGroup == ETriggerGroupType.DoAlternateAttack)
{
count = 1;
}
else
{
if (potentialTargets.Count < ss.targets.targetCountRange.minimumCount)
{
return(null);
}
if (potentialTargets.Count <= ss.targets.targetCountRange.maximumCount)
{
count = potentialTargets.Count;
}
else
{
count = ss.targets.targetCountRange.maximumCount;
}
}
List <int> pt = new List <int>(potentialTargets);
pt.Sort(delegate(int a, int b)
{
if (ai.preferredStrategicPlaces != null)
{
bool stratA = ai.preferredStrategicPlaces.Contains(a);
bool stratB = ai.preferredStrategicPlaces.Contains(b);
if (stratA != stratB)
{
return(stratA ? -1 : 1);
}
//if they are the same use regular random
}
return(ai.r.GetInt(0, 2) - 1);
});
var lu = new ListUtils(pt, count);
return(lu.GetEnumerator());
}
static CardAIPlanData ProduceSingleRefination(CardAI ai, CardAIPlanData entryState, CardAIPlanData plan)
{
NetBattlefield bf = entryState.bf;
NetSkill ns = bf.GetSkillByID(plan.GetTopCardPlay().skill);
//cast form the source plan data so that it is not casted "after" action we want to reiterate to different targets
CardAIPlanData d = CastSkillOnece(ai, ns, ns.GetOwner(bf), entryState, bf.CloneAndRemember(), plan.GetTopCardPlay().targetEnumerator);
if (d.valid && plan.value < d.value)
{
d.SetEnumerator(plan.GetTopCardPlay().targetEnumerator);
}
return(d);
}
// Helper that applies normal damage and shield leech (affected by leechFactor).
static public object Act_ShieldLeech_Helper(NetBattlefield bf, NetQueueItem q, FInt leechFactor)
{
NetSkill ns = q.GetNetSkill(bf);
NetCard owner = bf.GetCardByID(ns.OwnerCardID);
NetCard target = null;
if (NetType.IsNullOrEmpty(q.Targets))
{
return(null);
}
FInt damage = owner.GetSkillCastingStrength(ns);
int shieldLeeched = 0;
// Primary targets.
foreach (var v in q.Targets.value)
{
target = bf.ConvertPositionIDToCard(v);
if (target != null)
{
target.ReciveNormalDamage(damage, bf, q, v);
shieldLeeched += (damage * leechFactor).ToInt();
}
}
// Secondary targets.
if (!NetType.IsNullOrEmpty(q.SecondaryTargets))
{
damage *= 0.5f;
foreach (var v in q.SecondaryTargets.value)
{
target = bf.ConvertPositionIDToCard(v);
if (target != null)
{
target.ReciveNormalDamage(damage, bf, q, v);
shieldLeeched += (damage * leechFactor).ToInt();
}
}
}
if (shieldLeeched > 0)
{
FInt currentShields = owner.GetCA_SHIELD();
owner.SetCA_SHIELD(currentShields + shieldLeeched);
}
return(null);
}
// Ancient version of the built-in script Act_DrainHealthEssence, which leeches 80% instead.
// Note: Built-in script Act_DrainHealthAncient does not appear to do this.
static public object Act_LifeLeech_Ancient(NetBattlefield bf, NetQueueItem q, List <NetQueueItem> stack, List <NetQueueItem> previousItems, MHRandom random)
{
NetSkill ns = q.GetNetSkill(bf);
NetCard owner = bf.GetCardByID(ns.OwnerCardID);
NetCard target = null;
if (NetType.IsNullOrEmpty(q.Targets))
{
return(null);
}
FInt damage = owner.GetSkillCastingStrength(ns);
int lifeLeeched = 0;
// Primary targets.
foreach (var v in q.Targets.value)
{
target = bf.ConvertPositionIDToCard(v);
if (target != null)
{
target.ReciveNormalDamage(damage, bf, q, v);
lifeLeeched += (damage * 0.8f).ToInt();
}
}
// Secondary targets.
if (!NetType.IsNullOrEmpty(q.SecondaryTargets))
{
damage *= 0.5f;
foreach (var v in q.SecondaryTargets.value)
{
target = bf.ConvertPositionIDToCard(v);
if (target != null)
{
target.ReciveNormalDamage(damage, bf, q, v);
lifeLeeched += (damage * 0.8f).ToInt();
}
}
}
if (lifeLeeched > 0)
{
owner.ReciveHealthNormal(lifeLeeched, bf, q, t);
}
return(null);
}
/// <summary>
/// Target any enemy character
/// </summary>
/// <param name="bf"></param>
/// <param name="ns"></param>
/// <param name="bfPosition"></param>
/// <returns></returns>
static public List <int> Trg_RangeTargeting_Unblocked(NetBattlefield bf, NetSkill ns, int bfPosition)
{
if (bf == null || ns == null)
{
return(null);
}
NetCard nc = bf.GetCardByID(ns.OwnerCardID);
if (nc == null)
{
return(null);
}
//this skill should work only when activated from battlefield
if (!bf.IsBattleSlot(bfPosition))
{
return(null);
}
return(SubskillScript.TrgU_FallbackTargets(bf, ns, nc));
}
static CardAIPlanData CastSkillOnece(CardAI ai, NetSkill ns, NetCard nc, CardAIPlanData data, NetBattlefield bf, IEnumerator <List <int> > targetEnumerator)
{
//structure makes a new copy
CardAIPlanData result = data;
//using previous bf allows to utilize already cached data, as well as share caching with following casts.
//later we will use new bf to ensure we do not override the same bf.
NetBattlefield prevBf = data.bf;
IList <int> targets = GetPlayCardTargets(ai.FriendlyTurn, ns, nc, prevBf);
if (targets == null || targets.Count < 1)
{
return(new CardAIPlanData());
}
if (targetEnumerator == null)
{
targetEnumerator = GetTargetEnumerator(ns, nc, targets, ai);
if (targetEnumerator == null)
{
return(new CardAIPlanData());
}
}
targetEnumerator.MoveNext();
List <int> selectedTargets = targetEnumerator.Current;
if (selectedTargets == null || selectedTargets.Count == 0)
{
return(new CardAIPlanData());
}
List <int> secTargets = GetSecondaryPlayTargets(ns, nc, prevBf, selectedTargets, ai.r);
FInt skillDelay = ns.GetSkillDelay(prevBf);
int cost = prevBf.GetCardCastingCostFast(ns.GetOwner(prevBf).CardID);
//add cost if something need to be casted next turn by AI
var ncp = bf.GetPlayerByPlayerID(ai.playerID);
if (cost > ncp.ApLeft)
{
skillDelay += 2;
}
//operate from now on its own bf
result.bf = bf;
NetQueueItem q;
if (ns.IsCastingSpell())
{
q = new NetQueueItem(bf, ns, new NetListInt(selectedTargets), new NetListInt(secTargets), skillDelay, -1);
}
else
{
q = new NetQueueItem(bf, ns, null, null, skillDelay, selectedTargets[0]);
}
//if ap cost were larger than current ap then we will result in negative ap.
//because its just simulation we do not care for that now, as the sum of this and next turn ap
//for estimating cost would be identical
ncp.ApLeft -= nc.GetCastingCost();
bf.PlayCard(q, ai.r);
float value = bf.GetValueByCloneSimulation(ai.iterations, ai.r);
result.value = value;
result.AddCardPlay(nc.CardID, ns.SkillInBattleID, q);
result.SetEnumerator(targetEnumerator);
result.valid = true;
return(result);
}
static public object Act_AddShieldingImproved(
NetBattlefield bf,
NetQueueItem q,
List <NetQueueItem> stack,
List <NetQueueItem> previousItems,
MHRandom random)
{
NetSkill ns = q.GetNetSkill(bf);
NetCard owner = bf.GetCardByID(ns.OwnerCardID);
//skill needs target(-s)
if (!NetTypeAtomic.IsValid(q.Targets))
{
return(null);
}
FInt extra = FInt.ZERO;
if (ns.MainAtt != null)
{
extra = owner.GetSkillCastingStrength(ns);
}
FInt value = ns.GetFloatAttribute("TAG-CA_SHIELD");
string sign = ns.GetStringAttribute("TAG-CA_SHIELD");
if (value == FInt.ZERO)
{
if (bf.ChallengeType == EChallengeType.TypePhysical)
{
value = ns.GetFloatAttribute("TAG-SHIELDING_PHYSICAL");
}
else if (bf.ChallengeType == EChallengeType.TypeMental)
{
value = ns.GetFloatAttribute("TAG-SHIELDING_MENTAL");
}
else if (bf.ChallengeType == EChallengeType.TypeSpirit)
{
value = ns.GetFloatAttribute("TAG-SHIELDING_SPIRIT");
}
}
if (string.IsNullOrEmpty(sign))
{
if (bf.ChallengeType == EChallengeType.TypePhysical)
{
sign = ns.GetStringAttribute("TAG-SHIELDING_PHYSICAL");
}
else if (bf.ChallengeType == EChallengeType.TypeMental)
{
sign = ns.GetStringAttribute("TAG-SHIELDING_MENTAL");
}
else if (bf.ChallengeType == EChallengeType.TypeSpirit)
{
sign = ns.GetStringAttribute("TAG-SHIELDING_SPIRIT");
}
}
value += extra;
value.CutToInt();
if (sign == "*")
{
value = value * 0.01f;
}
foreach (var v in q.Targets.value)
{
NetCard target = bf.ConvertPositionIDToCard(v);
if (target == null)
{
continue;
}
FInt prev = target.GetCA_SHIELD();
if (sign == "+")
{
target.SetCA_SHIELD(value + prev);
}
else if (sign == "*")
{
target.SetCA_SHIELD(value * prev);
}
}
if (NetType.IsNullOrEmpty(q.SecondaryTargets))
{
return(null);
}
foreach (var v in q.SecondaryTargets.value)
{
NetCard target = bf.ConvertPositionIDToCard(v);
if (target == null)
{
continue;
}
FInt prev = target.GetCA_SHIELD();
if (sign == "+")
{
target.SetCA_SHIELD(value + prev);
}
else if (sign == "*")
{
target.SetCA_SHIELD(value * prev);
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="bf">general battlefield information</param>
/// <param name="q">queue element which is already executed which trigers this skill</param>
/// <param name="stack">Items which are still in stack including "q", which most likely is first element</param>
/// <param name="previousItems">Queue items which were already executed in order they were executed</param>
/// <param name="random">random generator specific to this thread</param>
/// <returns></returns>
/// <summary>
/// Basic damage
/// </summary>
static public object Act_Damage_Procedural(
NetBattlefield bf,
NetQueueItem q,
List <NetQueueItem> stack,
List <NetQueueItem> previousItems,
MHRandom random)
{
NetSkill ns = q.GetNetSkill(bf);
NetCard owner = bf.GetCardByID(ns.OwnerCardID);
NetCard target = null;
if (NetType.IsNullOrEmpty(q.Targets))
{
return(null);
}
int flags = ns.Flags;
bool essence = (flags & (int)EActivatorBlocks.Essence) > 0;
bool ancient = (flags & (int)EActivatorBlocks.Ancient) > 0;
bool gray = !ancient && !essence;
FInt damage = GameplayUtils.GetDamageFor(ns, owner);
// if ((flags & (int)SkillGenerator.EActivatorBlocks.Additive) > 0)
// {
//
// if (essence)
// {
// //essence is estimated to be equal between additive and multiplicative at
// // value of 10 (A x 0.2 + 8) ~ (A = 10)
// damage = owner.GetSkillCastingAdditiveStrength(ns, SkillGenerator.ESSENCE_ADDITIVE_BASE);
// }
// else if(ancient)
// {
// //essence is estimated to be equal between additive and multiplicative at
// // value of 15 (A x 0.2 + 12) ~ (A = 15)
// damage = owner.GetSkillCastingAdditiveStrength(ns, SkillGenerator.ANCIENT_ADDITIVE_BASE);
// }
// else
// {
// //essence is estimated to be equal between additive and multiplicative at
// // value of 6 (A x 0.2 + 5) ~ (A = 6)
// damage = owner.GetSkillCastingAdditiveStrength(ns, SkillGenerator.GRAY_ADDITIVE_BASE);
// }
// }
// else
// {
// damage = owner.GetSkillCastingStrength(ns);
// }
bool trueDamage = (flags & (int)EActivatorBlocks.TrueDamage) > 0;
bool poisonDamage = (flags & (int)EActivatorBlocks.PoisonDamage) > 0;
bool lifeLeech = (flags & (int)EActivatorBlocks.LifeLeech) > 0;
bool shieldLeech = (flags & (int)EActivatorBlocks.ShieldLeech) > 0;
bool additive = (flags & (int)EActivatorBlocks.Additive) > 0;
int lifeLeeched = 0;
int shieldLeeched = 0;
#region Primary targets
foreach (var v in q.Targets.value)
{
target = bf.ConvertPositionIDToCard(v);
if (target != null)
{
FInt dmg = damage;
if (poisonDamage && target.IsWounded())
{
if (essence)
{
dmg *= 1.35f;
}
else
{
dmg *= 1.6f;
}
}
if (trueDamage)
{
if (essence)
{
target.ReciveTrueDamageEssence(dmg, bf, q, v);
}
else //no test for ancient
{
target.ReciveTrueDamageAncient(dmg, bf, q, v);
}
}
else
{
target.ReciveNormalDamage(dmg, bf, q, v);
}
if (lifeLeech)
{
if (essence)
{
lifeLeeched += (dmg * 0.4f).ToInt();
}
else
{
lifeLeeched += (dmg * 0.8f).ToInt();
}
}
if (shieldLeech)
{
if (essence)
{
shieldLeeched += (dmg * 0.5f).ToInt();
}
else
{
shieldLeeched += (dmg * 1.0f).ToInt();
}
}
}
}
#endregion
#region Secondary targets
////do splash if needed
if (!NetType.IsNullOrEmpty(q.SecondaryTargets))
{
bool splashBonus = (flags & (int)EActivatorBlocks.AOE) > 0;
if (gray || !splashBonus)
{
damage *= 0.5f;
}
else
{
//this is !gray && AOE
if (essence)
{
damage *= 0.75f;
}
if (ancient)
{
damage *= 1f;
}
}
//ancient damage is 100% splash
foreach (var v in q.SecondaryTargets.value)
{
target = bf.ConvertPositionIDToCard(v);
if (target != null)
{
FInt dmg = damage;
if (poisonDamage && target.IsWounded())
{
if (essence)
{
dmg *= 1.35f;
}
else
{
dmg *= 1.6f;
}
}
if (trueDamage)
{
if (essence)
{
target.ReciveTrueDamageEssence(dmg, bf, q, v);
}
else //no test for ancient
{
target.ReciveTrueDamageAncient(dmg, bf, q, v);
}
}
else
{
target.ReciveNormalDamage(dmg, bf, q, v);
}
if (lifeLeech)
{
if (essence)
{
lifeLeeched += (dmg * 0.4f).ToInt();
}
else
{
lifeLeeched += (dmg * 0.8f).ToInt();
}
}
if (shieldLeech)
{
if (essence)
{
shieldLeeched += (dmg * 0.5f).ToInt();
}
else
{
shieldLeeched += (dmg * 1.0f).ToInt();
}
}
}
}
}
#endregion
#region Leech
if (lifeLeeched > 0)
{
FInt max = owner.GetCA_MAX_HEALTH();
FInt cur = owner.GetCA_HEALTH();
if (cur < max)
{
if (lifeLeeched > max - cur)
{
owner.SetCA_HEALTH(max);
}
else
{
owner.SetCA_HEALTH(cur + lifeLeeched);
}
}
}
if (shieldLeeched > 0)
{
FInt cur = owner.GetCA_SHIELD();
owner.SetCA_SHIELD(cur + shieldLeeched);
}
#endregion
return(null);
}
