public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
Room room = ai.Room;
if (room.GetTag(Name) is CardUseStruct use)
{
Player target = use.To[0];
if (ai.IsEnemy(target))
{
if (!ai.IsCardEffect(use.Card, target, player))
{
return(true);
}
Player wizzard = ai.GetWizzardRaceWinner(Name, target);
if (wizzard != null && ai.IsFriend(wizzard) && ai.CanRetrial(wizzard, Name, target))
{
DamageStruct damage = new DamageStruct(Name, null, target, 3, DamageStruct.DamageNature.Thunder);
if (ai.GetDamageScore(damage).Score > 8)
{
return(true);
}
}
}
}
return(false);
}
public override List <int> OnExchange(TrustedAI ai, Player player, string pattern, int min, int max, string pile)
{
Room room = ai.Room;
if (room.GetTag(Name) is DamageStruct damage)
{
ScoreStruct score = ai.GetDamageScore(damage);
damage.Damage++;
ScoreStruct _score = ai.GetDamageScore(damage);
if (_score.Score - score.Score > 3)
{
List <int> ids = new List <int>();
foreach (int id in player.GetCards("h"))
{
if (!RoomLogic.CanDiscard(room, player, player, id))
{
continue;
}
WrappedCard card = room.GetCard(id);
FunctionCard fcard = Engine.GetFunctionCard(card.Name);
if (fcard is Slash || fcard is Weapon)
{
ids.Add(id);
}
}
if (ids.Count > 0)
{
ai.SortByUseValue(ref ids, false);
return(new List <int> {
ids[0]
});
}
}
}
return(new List <int>());
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
Room room = ai.Room;
Player caocao = room.FindPlayer(prompt.Split(':')[1]);
CardUseStruct use = new CardUseStruct(null, player, new List <Player>());
if (caocao != null && ai.IsFriend(caocao))
{
object reason = room.GetTag("current_Jink");
DamageStruct damage = new DamageStruct();
if (reason is SlashEffectStruct slash)
{
damage.From = slash.From;
damage.To = slash.To;
damage.Card = slash.Slash;
damage.Damage = slash.Drank + 1;
damage.Nature = DamageStruct.DamageNature.Normal;
if (damage.Card.Name == FireSlash.ClassName)
{
damage.Nature = DamageStruct.DamageNature.Fire;
}
else if (damage.Card.Name == ThunderSlash.ClassName)
{
damage.Nature = DamageStruct.DamageNature.Thunder;
}
}
else if (reason is CardEffectStruct effect)
{
damage.From = effect.From;
damage.To = effect.To;
damage.Card = effect.Card;
damage.Damage = 1;
damage.Nature = DamageStruct.DamageNature.Normal;
}
List <WrappedCard> jinks = ai.GetCards("Jink", player);
ScoreStruct score = ai.GetDamageScore(damage);
if (score.Score < -5 && jinks.Count > 0)
{
use.Card = jinks[0];
}
else if (score.Score < 0 && jinks.Count > 1)
{
use.Card = jinks[0];
}
}
return(use);
}
public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
if (data is string str)
{
string[] strs = str.Split(':');
Player who = ai.Room.FindPlayer(strs[1]);
DamageStruct damage = new DamageStruct(Name, who, player);
if (ai.IsFriend(who) || ai.GetDamageScore(damage).Score > 0)
{
return(true);
}
}
else if (data is Player target)
{
DamageStruct damage = new DamageStruct(Name, player, target);
if (ai.GetDamageScore(damage).Score > 0)
{
return(true);
}
}
return(false);
}
public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
if (data is Player target)
{
if (ai.IsEnemy(target))
{
DamageStruct damage = new DamageStruct(Name, null, target, 3, DamageStruct.DamageNature.Thunder);
if (ai.GetDamageScore(damage).Score > 0)
{
return(true);
}
}
}
return(false);
}
public override List <int> OnExchange(TrustedAI ai, Player player, string pattern, int min, int max, string pile)
{
Room room = ai.Room;
if (room.GetTag(Name) is DamageStruct damage)
{
ScoreStruct score = ai.GetDamageScore(damage, DamageStruct.DamageStep.Done);
if (ai.IsEnemy(damage.To))
{
List <int> ids = new List <int>();
foreach (int id in player.GetCards("h"))
{
WrappedCard card = room.GetCard(id);
if (Engine.MatchExpPattern(room, pattern, player, card) && (card.Name != Peach.ClassName && card.Name != Analeptic.ClassName || damage.Damage > 1))
{
ids.Add(id);
}
}
if (ids.Count > 0)
{
List <double> values = ai.SortByKeepValue(ref ids, false);
if (values[0] < score.Score)
{
return new List <int> {
ids[0]
}
}
;
if (player == room.Current)
{
values = ai.SortByUseValue(ref ids, false);
if (values[0] < score.Score)
{
return new List <int> {
ids[0]
}
}
;
}
}
}
}
return(new List <int>());
}
}
public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
if (ai.Room.GetTag("chuanxin_data") is DamageStruct damage)
{
double value = ai.GetDamageScore(damage).Score;
if (ai.IsFriend(damage.To))
{
return(value < -6);
}
else if (ai.DamageEffect(damage, DamageStruct.DamageStep.Done) > 1 && value > 4)
{
return(false);
}
else
{
return(value < 5.5);
}
}
return(true);
}
public override List <Player> OnPlayerChosen(TrustedAI ai, Player player, List <Player> targets, int min, int max)
{
Room room = ai.Room;
if (room.GetTag("extra_target_skill") is CardUseStruct use)
{
List <Player> result = new List <Player>();
if (use.Card.Name == ExNihilo.ClassName)
{
foreach (Player p in targets)
{
if (ai.IsFriend(p) && !ai.HasSkill("zishu", p))
{
return new List <Player> {
p
}
}
}
;
}
else if (use.Card.Name.Contains(Slash.ClassName))
{
List <ScoreStruct> scores = ai.CaculateSlashIncome(player, new List <WrappedCard> {
use.Card
}, targets, false);
if (scores.Count > 0 && scores[0].Score > 0)
{
return(scores[0].Players);
}
}
else if (use.Card.Name == Snatch.ClassName)
{
foreach (Player p in targets)
{
if (ai.FindCards2Discard(player, p, use.Card.Name, "hej", HandlingMethod.MethodGet).Score > 0)
{
return new List <Player> {
p
}
}
;
}
}
else if (use.Card.Name == Dismantlement.ClassName)
{
foreach (Player p in targets)
{
if (ai.FindCards2Discard(player, p, use.Card.Name, "hej", HandlingMethod.MethodDiscard).Score > 0)
{
return new List <Player> {
p
}
}
;
}
}
else if (use.Card.Name == IronChain.ClassName)
{
foreach (Player p in targets)
{
if (ai.IsFriend(p) && !ai.HasSkill("jieying", p) && p.Chained)
{
return new List <Player> {
p
}
}
;
}
foreach (Player p in targets)
{
if (ai.IsEnemy(p) && !p.Chained)
{
return new List <Player> {
p
}
}
;
}
}
else if (use.Card.Name == FireAttack.ClassName)
{
foreach (Player p in targets)
{
if (ai.IsEnemy(p))
{
return new List <Player> {
p
}
}
;
}
}
else if (use.Card.Name == Duel.ClassName)
{
WrappedCard duel = use.Card;
List <Player> enemies = ai.Exclude(ai.GetEnemies(player), duel);
List <Player> friends = ai.Exclude(ai.FriendNoSelf, duel);
int n1 = ai.GetKnownCardsNums(Slash.ClassName, "he", player);
if (ai.HasSkill("wushuang"))
{
n1 *= 2;
}
List <ScoreStruct> scores = new List <ScoreStruct>();
foreach (Player p in friends)
{
if (!targets.Contains(p))
{
continue;
}
bool fuyin = false;
if (ai.HasSkill("fuyin", p) && p.GetMark("fuyin") == 0)
{
int count = player.HandcardNum;
if (count > p.HandcardNum)
{
fuyin = true;
}
}
if (!fuyin)
{
ScoreStruct score = ai.GetDamageScore(new DamageStruct(duel, player, p));
score.Players = new List <Player> {
p
};
foreach (string skill in ai.GetKnownSkills(p))
{
SkillEvent skill_e = Engine.GetSkillEvent(skill);
if (skill_e != null)
{
score.Score += skill_e.TargetValueAdjust(ai, duel, player, new List <Player> {
p
}, p);
}
}
scores.Add(score);
}
}
foreach (Player p in enemies)
{
if (!targets.Contains(p))
{
continue;
}
bool fuyin = false;
if (ai.HasSkill("fuyin", p) && p.GetMark("fuyin") == 0)
{
int count = player.HandcardNum;
foreach (int id in duel.SubCards)
{
if (room.GetCardPlace(id) == Place.PlaceHand)
{
count--;
}
}
if (count > p.HandcardNum)
{
ScoreStruct score = new ScoreStruct
{
Score = 1,
Players = new List <Player> {
p
}
};
scores.Add(score);
fuyin = true;
}
}
if (!fuyin)
{
bool no_red = p.GetMark("@qianxi_red") > 0;
bool no_black = p.GetMark("@qianxi_black") > 0;
double n2 = ai.GetKnownCardsNums(Slash.ClassName, "he", p, player);
bool fuqi = false;
if (player.ContainsTag("wenji") && player.GetTag("wenji") is List <string> names && names.Contains(Name))
{
fuqi = true;
}
if (ai.HasSkill("fuqi", player) && RoomLogic.DistanceTo(room, player, p) == 1)
{
fuqi = true;
}
if (!fuqi && !ai.IsLackCard(p, Slash.ClassName))
{
int rate = 4;
if (ai.GetKnownCards(p).Count != p.HandcardNum)
{
rate = 5;
if (ai.HasSkill("longdan", p))
{
rate -= 2;
if (no_black || no_red)
{
rate += 1;
}
}
if (ai.HasSkill("wusheng", p) && !no_red)
{
rate -= 2;
}
int count = p.HandcardNum - ai.GetKnownCards(p).Count;
count += p.GetHandPile(true).Count - ai.GetKnownHandPileCards(p).Count;
if (no_red)
{
rate += 1;
}
if (no_black)
{
rate += 2;
}
n2 += ((double)count / rate);
}
if (ai.HasSkill("wushuang", p))
{
n2 *= 2;
}
}
ScoreStruct score = new ScoreStruct
{
Players = new List <Player> {
p
}
};
if (fuqi)
{
score.Score = ai.GetDamageScore(new DamageStruct(duel, player, p)).Score;
}
else if (n2 > n1)
{
score.Score = ai.GetDamageScore(new DamageStruct(duel, p, player)).Score;
}
else
{
score.Score = ai.GetDamageScore(new DamageStruct(duel, p, player)).Score - (n2 - 1) * 0.4;
}
foreach (string skill in ai.GetKnownSkills(p))
{
SkillEvent skill_e = Engine.GetSkillEvent(skill);
if (skill_e != null)
{
score.Score += skill_e.TargetValueAdjust(ai, duel, player, new List <Player> {
p
}, p);
}
}
scores.Add(score);
}
}
if (scores.Count > 0)
{
scores.Sort((x, y) => { return(x.Score > y.Score ? -1 : 1); });
if (scores[0].Score > 1)
{
return(scores[0].Players);
}
}
}
}
return(new List <Player>());
}
public override NulliResult OnNullification(TrustedAI ai, CardEffectStruct effect, bool positive, bool keep)
{
NulliResult result = new NulliResult();
Room room = ai.Room;
Player from = effect.From, to = effect.To;
WrappedCard trick = effect.Card;
Player player = ai.Self;
List <Player> players = new List <Player>();
foreach (Player p in room.GetAlivePlayers())
{
if (p.IsFemale())
{
players.Add(p);
}
}
int count = Math.Min(players.Count, to.HandcardNum);
if (positive)
{
if (ai.IsFriend(to))
{
double value = -count;
if (from.HandcardNum + count < to.HandcardNum)
{
DamageStruct damage = new DamageStruct(trick, from, to);
value += ai.GetDamageScore(damage).Score;
}
if (count <= -2)
{
result.Null = true;
}
}
}
else
{
if (ai.IsFriend(from))
{
double value = count;
if (count > 0)
{
room.SortByActionOrder(ref players);
for (int i = 0; i < count; i++)
{
if (ai.IsFriend(players[i]) && players[i].HandcardNum > 0)
{
value += players[i].HandcardNum / 5;
}
}
}
if (from.HandcardNum + count < to.HandcardNum)
{
DamageStruct damage = new DamageStruct(trick, from, to);
value += ai.GetDamageScore(damage).Score;
}
if (count > 3)
{
result.Null = true;
}
}
}
return(result);
}
public override NulliResult OnNullification(TrustedAI ai, CardEffectStruct effect, bool positive, bool keep)
{
NulliResult result = new NulliResult();
Room room = ai.Room;
Player from = effect.From, to = effect.To;
WrappedCard trick = effect.Card;
Player player = ai.Self;
if (positive)
{
ScoreStruct score = new ScoreStruct
{
Score = 0
};
if (from.Alive)
{
DamageStruct damage = new DamageStruct(trick, from, to);
score = ai.GetDamageScore(damage);
}
if (to.IsWounded())
{
if (ai.IsFriend(to))
{
score.Score += 1 * to.GetLostHp();
}
else if (ai.IsEnemy(to))
{
score.Score -= 1 * to.GetLostHp();
}
}
if (score.Score <= -4)
{
result.Null = true;
}
}
else
{
ScoreStruct score = new ScoreStruct
{
Score = 0
};
if (from.Alive)
{
DamageStruct damage = new DamageStruct(trick, from, to);
score = ai.GetDamageScore(damage);
}
if (to.IsWounded())
{
if (ai.IsFriend(to))
{
score.Score += 1 * to.GetLostHp();
}
else if (ai.IsEnemy(to))
{
score.Score -= 1 * to.GetLostHp();
}
}
if (score.Score > 4)
{
result.Null = true;
}
}
return(result);
}
public override List <int> OnDiscard(TrustedAI ai, Player player, List <int> cards, int min, int max, bool option)
{
if (!ai.WillShowForAttack())
{
return(new List <int>());
}
Room room = ai.Room;
Player target = room.Current;
List <int> ids = new List <int>();
foreach (int id in player.HandCards)
{
if (RoomLogic.CanDiscard(room, player, player, id))
{
ids.Add(id);
}
}
ai.SortByKeepValue(ref ids, false);
double value = ai.GetKeepValue(ids[0], player);
if (ai.GetOverflow(player) > 1)
{
value /= 3;
}
DamageStruct damage = new DamageStruct(Name, player, target);
if (ai.IsFriend(target))
{
bool range = false;
foreach (Player p in room.GetOtherPlayers(target))
{
if (ai.GetPrioEnemies().Contains(p) && RoomLogic.InMyAttackRange(room, target, p))
{
range = true;
break;
}
}
if (range && target.HandcardNum + target.GetPile("wooden_ox").Count > 3)
{
if (ai.GetDamageScore(damage).Score < -3 && ai.HasSkill("wushuang|jianchu", target) && value < 3)
{
return new List <int> {
ids[0]
}
}
;
}
}
else
{
if (ai.GetDamageScore(damage).Score > 7 && value < 7)
{
return new List <int> {
ids[0]
}
}
;
else if (ai.GetDamageScore(damage).Score > 4 && value < 3)
{
if (ai.IsLackCard(target, Slash.ClassName) || target.HandcardNum + target.GetPile("wooden_ox").Count < 3)
{
return(new List <int> {
ids[0]
});
}
else
{
bool range = false;
foreach (Player p in room.GetOtherPlayers(target))
{
if (ai.IsFriend(p) && RoomLogic.InMyAttackRange(room, target, p))
{
range = true;
break;
}
}
if (!range)
{
return new List <int> {
ids[0]
}
}
;
}
}
}
return(new List <int>());
}
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct result = new CardUseStruct
{
From = player,
To = new List <Player>()
};
Room room = ai.Room;
int sub = -1;
foreach (int id in player.GetPile("sorcery"))
{
WrappedCard card = room.GetCard(id);
if (card.Suit == WrappedCard.CardSuit.Club || card.Suit == WrappedCard.CardSuit.Spade)
{
sub = id;
break;
}
}
if (sub == -1)
{
sub = player.GetPile("sorcery")[0];
}
WrappedCard qianhuan = new WrappedCard("QianhuanCard")
{
Mute = true,
Skill = Name
};
qianhuan.AddSubCard(sub);
if (room.ContainsTag("qianhuan_data") && room.GetTag("qianhuan_data") is CardUseStruct use)
{
if (ai.IsCancelTarget(use.Card, use.To[0], use.From) || !ai.IsCardEffect(use.Card, use.To[0], use.From))
{
return(result);
}
if (use.Card.Name == SupplyShortage.ClassName || use.Card.Name == Indulgence.ClassName || use.Card.Name == Snatch.ClassName)
{
if (use.From != null && ai.IsEnemy(use.From))
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == BurningCamps.ClassName)
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0], 1, DamageStruct.DamageNature.Fire);
if (player.GetPile("sorcery").Count >= 3 && ai.GetDamageScore(damage).Score < 0 || ai.GetDamageScore(damage).Score < -5)
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name.Contains(Slash.ClassName))
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0], 1 + use.Drank);
if (use.Card.Name == FireSlash.ClassName)
{
damage.Nature = DamageStruct.DamageNature.Fire;
}
else if (use.Card.Name == ThunderSlash.ClassName)
{
damage.Nature = DamageStruct.DamageNature.Thunder;
}
double value = ai.GetDamageScore(damage).Score;
if (value < -5 || (ai.IsWeak(use.To[0]) && value < 0) || (value < 0 && player.GetPile("sorcery").Count >= 3))
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == ArcheryAttack.ClassName)
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0]);
double value = ai.GetDamageScore(damage).Score;
if ((value < -5 || (ai.IsWeak(use.To[0]) && value < 0)) && player != use.To[0] ? ai.IsLackCard(use.To[0], Jink.ClassName) : ai.GetKnownCardsNums(Jink.ClassName, "he", use.To[0]) == 0)
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == SavageAssault.ClassName)
{
Player menghuo = ai.FindPlayerBySkill("huoshou");
DamageStruct damage = new DamageStruct(use.Card, menghuo ?? use.From, use.To[0]);
double value = ai.GetDamageScore(damage).Score;
if ((value < -5 || (ai.IsWeak(use.To[0]) && value < 0)) && (player != use.To[0] ? ai.IsLackCard(use.To[0], Slash.ClassName)
: ai.GetKnownCardsNums(Slash.ClassName, "he", use.To[0]) == 0 || RoomLogic.IsHandCardLimited(room, use.To[0], HandlingMethod.MethodResponse)))
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == Duel.ClassName)
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0]);
double value = ai.GetDamageScore(damage).Score;
if (value < -5 || ((ai.IsWeak(use.To[0]) || player.GetPile("sorcery").Count >= 3) && value < 0))
{
result.Card = qianhuan;
return(result);
}
}
}
return(result);
}
