public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
int self_count = 0, enemies = 0;
Room room = ai.Room;
foreach (Player p in ai.GetFriends(player))
{
if (p.Chained && GDFighttogether.Instance.TargetFilter(room, new List <Player>(), p, player, card))
{
self_count++;
}
}
List <Player> _enemies = ai.GetEnemies(player);
bool vine = false;
foreach (Player p in room.GetAlivePlayers())
{
if (p.HasArmor(Vine.ClassName) && (p.Chained || _enemies.Contains(p)) && !ai.HasSkill("gangzhi", p))
{
vine = true;
break;
}
}
foreach (Player p in _enemies)
{
if (!p.Chained && GDFighttogether.Instance.TargetFilter(room, new List <Player>(), p, player, card))
{
enemies++;
if (RoomLogic.PlayerHasSkill(room, p, "gangzhi"))
{
enemies++;
}
}
}
if (enemies > 0 && vine)
{
enemies++;
}
use.Card = card;
if (self_count < enemies && _enemies.Count > 1)
{
use.To.Add(ai.GetEnemies(player)[0]);
}
else if (self_count > 1)
{
use.To.Add(player);
}
if (use.To.Count == 0 && !GDFighttogether.Instance.CanRecast(room, player, card))
{
use.Card = null;
}
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
Room room = ai.Room;
List <ScoreStruct> scores = new List <ScoreStruct>();
foreach (Player p in ai.GetEnemies(player))
{
if (!p.Chained && RoomLogic.CanBeChainedBy(room, p, player))
{
ScoreStruct score = ai.FindCards2Discard(player, p, string.Empty, "he", HandlingMethod.MethodDiscard);
score.Players = new List <Player> {
p
};
scores.Add(score);
}
}
if (scores.Count > 0)
{
ai.CompareByScore(ref scores);
if (scores[0].Score > 0)
{
use.Card = card;
use.To = scores[0].Players;
}
}
}
public override double CardValue(TrustedAI ai, Player player, bool use, WrappedCard card, Player.Place place)
{
double value = ai.AjustWeaponRangeValue(player, card);
foreach (Player p in ai.GetEnemies(player))
{
if (ai.HasSkill(TrustedAI.MasochismSkill, p))
{
value += 1;
}
}
return(value);
}
public override double CardValue(TrustedAI ai, Player player, bool use, WrappedCard card, Player.Place place)
{
double value = ai.AjustWeaponRangeValue(player, card);
foreach (Player p in ai.GetEnemies(player))
{
if (RoomLogic.HasShownArmorEffect(ai.Room, p) && RoomLogic.DistanceTo(ai.Room, player, p, null, true) <= 2)
{
value += 0.5;
}
}
return(value);
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
List <Player> targets = ai.GetEnemies(player);
ai.SortByDefense(ref targets, false);
foreach (Player p in targets)
{
if (!p.IsKongcheng())
{
use.Card = card;
use.To.Add(p);
return;
}
}
}
public override List <Player> OnPlayerChosen(TrustedAI ai, Player player, List <Player> targets, int min, int max)
{
List <Player> enemies = ai.GetEnemies(player);
if (enemies.Count > 0)
{
ai.SortByDefense(ref enemies, false);
foreach (Player p in enemies)
{
if (targets.Contains(p))
{
return new List <Player> {
p
}
}
}
;
}
return(new List <Player>());
}
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 CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
Room room = ai.Room;
string[] strs = prompt.Split(':');
CardUseStruct use = new CardUseStruct(null, player, new List <Player>());
Player target = room.FindPlayer(strs[1]);
if (target != null)
{
use.To.Add(target);
List <ScoreStruct> values = ai.CaculateSlashIncome(player, null, new List <Player> {
target
});
if (values.Count > 0 && values[0].Score > 0)
{
bool will_slash = false;
if (values[0].Score >= 10)
{
will_slash = true;
}
else if (ai.GetEnemies(player).Count == 1 && ai.GetOverflow(player) > 0)
{
foreach (int id in values[0].Card.SubCards)
{
if (room.GetCardPlace(id) == Player.Place.PlaceHand)
{
will_slash = true;
break;
}
}
}
else
{
foreach (Player p in values[0].Players)
{
if (ai.GetPrioEnemies().Contains(p))
{
will_slash = true;
break;
}
}
}
//todo: adjust ai personality
if (!will_slash && ai.GetOverflow(player) > 0)
{
foreach (int id in values[0].Card.SubCards)
{
if (room.GetCardPlace(id) == Player.Place.PlaceHand)
{
will_slash = true;
break;
}
}
}
if (will_slash)
{
use.Card = values[0].Card;
}
}
}
return(use);
}
public static List <Player> FindTuxiTargets(TrustedAI ai, Player player, int max)
{
List <Player> result = new List <Player>();
List <Player> enemies = ai.GetEnemies(player);
ai.SortByHandcards(ref enemies, false);
Room room = ai.Room;
Player zhugeliang = ai.FindPlayerBySkill("kongcheng");
if (zhugeliang != null && ai.IsFriend(zhugeliang) && zhugeliang.HandcardNum == 1 && ai.GetEnemisBySeat(zhugeliang) > 0 && zhugeliang != player)
{
if (ai.IsWeak(zhugeliang))
{
result.Add(zhugeliang);
}
else
{
List <int> ids = ai.GetKnownCards(zhugeliang);
if (ids.Count == 1)
{
int id = ids[0];
if (!ai.IsCard(id, Jink.ClassName, zhugeliang) && !!ai.IsCard(id, Peach.ClassName, zhugeliang) && !ai.IsCard(id, Analeptic.ClassName, zhugeliang))
{
result.Add(zhugeliang);
}
}
}
}
foreach (Player p in enemies)
{
if (result.Contains(p) || !RoomLogic.CanGetCard(room, player, p, "h"))
{
continue;
}
List <int> ids = ai.GetKnownCards(p);
foreach (int id in ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == Peach.ClassName || card.Name == Nullification.ClassName || card.Name.Contains(Nullification.ClassName))
{
result.Add(p);
break;
}
}
if (result.Count >= max)
{
break;
}
}
if (result.Count < max)
{
foreach (Player p in enemies)
{
if (result.Contains(p) || !RoomLogic.CanGetCard(room, player, p, "h"))
{
continue;
}
if (ai.HasSkill("jijiu|qingnang|leiji|jieyin|beige|kanpo|liuli|qiaobian|zhiheng|guidao|tianxiang|lijian", p))
{
result.Add(p);
}
if (result.Count >= max)
{
break;
}
}
}
if (result.Count < max)
{
foreach (Player p in enemies)
{
if (result.Contains(p) || !RoomLogic.CanGetCard(room, player, p, "h"))
{
continue;
}
int x = p.HandcardNum;
bool good = true;
if (x == 1 && ai.NeedKongcheng(p))
{
good = false;
}
if (x >= 2 && ai.HasSkill("tuntian", p))
{
good = false;
}
if (good)
{
result.Add(p);
}
if (result.Count >= max)
{
break;
}
}
}
return(result);
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
ai.Choice["shangyi"] = null;
Room room = ai.Room;
foreach (Player p in room.GetOtherPlayers(player))
{
if (ai.GetPlayerTendency(p) == "unknown")
{
ai.Choice["shangyi"] = "hidden_general";
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
List <Player> enemies = ai.GetPrioEnemies();
ai.SortByDefense(ref enemies, false);
foreach (Player p in enemies)
{
if (p.HandcardNum - ai.GetKnownCards(p).Count > 2)
{
ai.Choice[Name] = "handcards";
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
enemies = ai.GetEnemies(player);
ai.SortByDefense(ref enemies, false);
foreach (Player p in enemies)
{
if (p.HandcardNum - ai.GetKnownCards(p).Count > 2)
{
ai.Choice["shangyi"] = "handcards";
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
foreach (Player p in enemies)
{
if (p.HandcardNum > ai.GetKnownCards(p).Count)
{
ai.Choice["shangyi"] = "handcards";
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
}
