public override void Use(Room room, CardUseStruct card_use)
{
List <Player> targets = card_use.To;
string str = RoomLogic.CardToString(room, card_use.Card);
if (targets.Count == 0 || RoomLogic.PlayerContainsTrick(room, targets[0], Name))
{
/*
* if (movable)
* {
* OnNullified(room, card_use.From, card_use.Card);
* if (room.GetCardOwner(card_use.Card.GetEffectiveId()) != card_use.From) return;
* }
*/
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_USE, card_use.From.Name, null, card_use.Card.Skill, null)
{
Card = card_use.Card
};
room.MoveCardTo(card_use.Card, null, Place.DiscardPile, reason, true);
return;
}
if (room.GetCardIdsOnTable(room.GetSubCards(card_use.Card)).Count == 0)
{
return;
}
CardMoveReason reason2 = new CardMoveReason(MoveReason.S_REASON_USE, card_use.From.Name, targets[0].Name, card_use.Card.Skill, null)
{
Card = card_use.Card
};
room.MoveCardTo(card_use.Card, null, targets[0], Place.PlaceDelayedTrick, reason2, true);
}
public override void Use(Room room, CardUseStruct card_use)
{
WrappedCard card = card_use.Card;
room.AddToPile(card_use.From, "wooden_ox", card.SubCards, false);
WrappedCard treasure = room.GetCard(card_use.From.Treasure.Key);
if (treasure != null)
{
List <Player> targets = new List <Player>();
foreach (Player p in room.GetOtherPlayers(card_use.From))
{
if (!p.GetTreasure() && RoomLogic.CanPutEquip(p, treasure))
{
targets.Add(p);
}
}
if (targets.Count == 0)
{
return;
}
Player target = room.AskForPlayerChosen(card_use.From, targets, "ClassicWoodenOx", "@wooden_ox-move", true);
if (target != null)
{
room.MoveCardTo(treasure, card_use.From, target, Place.PlaceEquip,
new CardMoveReason(MoveReason.S_REASON_TRANSFER, card_use.From.Name, "ClassicWoodenOx", null));
}
}
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
Room room = ai.Room;
Player target = null;
foreach (Player p in room.GetOtherPlayers(player))
{
if (ai.HasSkill("wendao", p))
{
target = p;
break;
}
}
bool will_use = true;
if (target != null && !ai.IsFriend(target, player))
{
will_use = false;
if (ai.GetOverflow(player) > 0 && room.GetCardPlace(card.GetEffectiveId()) == Player.Place.PlaceHand && room.GetCardOwner(card.GetEffectiveId()) == player)
{
will_use = true;
}
}
if (will_use)
{
ai.UseEquipCard(ref use, card);
}
}
public override void OnUse(Room room, CardUseStruct card_use)
{
Player source = card_use.From;
List <Player> targets = new List <Player>();
if (card_use.To.Count == 0)
{
List <Player> all_players = room.GetOtherPlayers(card_use.From);
foreach (Player player in all_players)
{
Skill skill = RoomLogic.IsProhibited(room, source, player, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.NotifySkillInvoked(player, skill.Name);
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, player, skill.Name);
string genral = gsk.General;
int skin_id = gsk.SkinId;
string skill_name = skill.Name;
int audio = -1;
skill.GetEffectIndex(room, player, card_use.Card, ref audio, ref skill_name, ref genral, ref skin_id);
if (audio >= -1)
{
room.BroadcastSkillInvoke(skill_name, "male", audio, genral, skin_id);
}
}
else
{
int audio = -1;
string skill_name = skill.Name;
string genral = string.Empty;
int skin_id = 0;
skill.GetEffectIndex(room, null, card_use.Card, ref audio, ref skill_name, ref genral, ref skin_id);
}
}
else
{
targets.Add(player);
}
}
}
else
{
targets = card_use.To;
}
card_use.To = targets;
base.OnUse(room, card_use);
}
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 CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct use = new CardUseStruct(null, player, new List <Player>());
string target_name = prompt.Split(':')[1];
Room room = ai.Room;
Player target = room.FindPlayer(target_name);
if (target != null)
{
if (ai.IsFriend(target))
{
foreach (int id in player.GetEquips())
{
if (ai.GetKeepValue(id, player) < 0 && RoomLogic.CanDiscard(room, target, player, id))
{
return(use);
}
}
//System.Diagnostics.Debug.Assert(room.GetAI(target) == null, "ai挑衅目标错误");
}
List <ScoreStruct> scores = ai.CaculateSlashIncome(player, null, new List <Player> {
target
});
if (scores.Count > 0 && scores[0].Score > -2 && scores[0].Card != null)
{
use.Card = scores[0].Card;
use.To.Add(target);
}
}
return(use);
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct use = new CardUseStruct(null, player, new List <Player>());
if (player.ContainsTag("ziliang_aidata") && player.GetTag("ziliang_aidata") is string player_name)
{
Room room = ai.Room;
Player target = room.FindPlayer(player_name);
if (target != null)
{
double best_v = 0;
int result = -1;
foreach (int id in player.GetPile("field"))
{
double value = Math.Max(ai.GetKeepValue(id, target, Player.Place.PlaceHand), ai.GetUseValue(id, target, Player.Place.PlaceHand));
if (value > best_v)
{
best_v = value;
result = id;
}
if (best_v > 2.5 && result >= 0)
{
use.Card = new WrappedCard("ZiliangCard")
{
Skill = Name, ShowSkill = Name
};
use.Card.AddSubCard(result);
}
}
}
}
return(use);
}
public override void OnUse(Room room, CardUseStruct use)
{
Player player = use.From;
if (use.To.Count == 0)
{
use.To.Add(player);
}
object data = use;
RoomThread thread = room.RoomThread;
thread.Trigger(TriggerEvent.PreCardUsed, room, player, ref data);
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, player.Name)
{
CardString = RoomLogic.CardToString(room, use.Card)
};
room.MoveCardTo(use.Card, player, Place.PlaceTable, reason, true);
Thread.Sleep(300);
room.RoomThread.Trigger(TriggerEvent.CardUsedAnnounced, room, use.From, ref data);
room.RoomThread.Trigger(TriggerEvent.CardTargetAnnounced, room, use.From, ref data);
thread.Trigger(TriggerEvent.CardUsed, room, player, ref data);
thread.Trigger(TriggerEvent.CardFinished, room, player, ref data);
}
//服务器操作响应
public override void Activate(ref CardUseStruct card_use)
{
UpdatePlayers();
to_use = GetTurnUse();
to_use.Sort((x, y) => { return(GetDynamicUsePriority(x) > GetDynamicUsePriority(y) ? -1 : 1); });
foreach (CardUseStruct use in to_use)
{
WrappedCard card = use.Card;
if (!RoomLogic.IsCardLimited(room, self, card, HandlingMethod.MethodUse) ||
(card.CanRecast && !RoomLogic.IsCardLimited(room, self, card, HandlingMethod.MethodRecast)))
{
string class_name = card.Name.Contains(Slash.ClassName) ? Slash.ClassName : card.Name;
UseCard _use = Engine.GetCardUsage(class_name);
if (_use != null)
{
_use.Use(this, self, ref card_use, card);
if (card_use.Card != null)
{
to_use.Clear();
return;
}
}
}
}
to_use.Clear();
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
Room room = ai.Room;
List <Player> friends = new List <Player>(ai.FriendNoSelf);
ai.SortByDefense(ref friends, false);
if (player.IsWounded())
{
foreach (Player p in friends)
{
if (ai.IsWeak(p) && RoomLogic.WillBeFriendWith(room, player, p, "cunsi"))
{
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
foreach (Player p in friends)
{
if (RoomLogic.WillBeFriendWith(room, player, p, "cunsi"))
{
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
if (ai.IsWeak(player))
{
use.Card = card;
use.To = new List <Player> {
player
};
return;
}
}
else
{
foreach (Player p in friends)
{
if (ai.IsWeak(p) && RoomLogic.WillBeFriendWith(room, player, p, "cunsi"))
{
use.Card = card;
use.To = new List <Player> {
p
};
return;
}
}
}
}
public override void Use(Room room, CardUseStruct card_use)
{
Player player = card_use.From;
Player target = card_use.To[0];
if (target.Alive && !target.IsKongcheng() && RoomLogic.CanGetCard(room, player, target, "h"))
{
target.SetFlags("daoshu_target");
string suit = room.AskForChoice(player, "daoshu", string.Join("+", suits));
target.SetFlags("-daoshu_target");
int id = room.AskForCardChosen(player, target, "h", "daoshu", false, HandlingMethod.MethodGet);
room.ObtainCard(player, id);
if (WrappedCard.GetSuitString(room.GetCard(id).Suit) == suit)
{
room.Damage(new DamageStruct("daoshu", player, target));
}
else
{
suit = WrappedCard.GetSuitString(room.GetCard(id).Suit);
player.SetFlags("daoshu");
List <int> ids = new List <int>();
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_GIVE, player.Name, target.Name, "daoshu", string.Empty);
foreach (int card_id in player.GetCards("h"))
{
if (WrappedCard.GetSuitString(room.GetCard(card_id).Suit) != suit)
{
ids.Add(card_id);
}
}
if (ids.Count == 0)
{
room.ShowAllCards(player, null, "daoshu");
}
else if (ids.Count == 1)
{
room.ObtainCard(target, ref ids, reason, true);
}
else
{
List <int> to_give = room.AskForExchange(player, "daoshu", 1, 1, "@daoshu-give:" + target.Name, string.Empty, string.Format(".|^{0}|.|hand", suit), card_use.Card.SkillPosition);
if (to_give.Count == 1)
{
room.ObtainCard(target, ref to_give, reason, true);
}
else
{
List <int> give = new List <int> {
ids[0]
};
room.ObtainCard(target, ref give, reason, true);
}
}
}
}
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
if (player.GetOffensiveHorse() && player.GetDefensiveHorse() && !ai.HasSkill(TrustedAI.LoseEquipSkill, player))
{
return;
}
ai.UseEquipCard(ref use, card);
}
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(Room room, CardUseStruct card_use)
{
Player player = card_use.From, target = card_use.To[0];
room.LoseHp(player);
if (target.Alive)
{
room.Damage(new DamageStruct("kuangxi", player, target));
}
}
public override WrappedCard Validate(Room room, CardUseStruct use)
{
BattleArraySkill skill = (BattleArraySkill)Engine.GetTriggerSkill(Name);
if (skill != null)
{
room.ShowSkill(use.From, Name, use.Card.SkillPosition);
skill.SummonFriends(room, use.From);
}
return(null);
}
public override void OnUse(Room room, CardUseStruct card_use)
{
if (card_use.To.Count == 0)
{
DoRecast(room, card_use);
}
else
{
Player player = card_use.From;
CardUseStruct use = new CardUseStruct(card_use.Card, player, new List <Player>());
List <Player> targets = new List <Player>();
Game3v3Camp camp = card_use.To[0].Camp;
foreach (Player p in room.GetAlivePlayers())
{
if (player.Camp == camp && p.Camp == camp && p.Chained)
{
targets.Add(p);
}
else if (player.Camp != camp && p.Camp == camp && !p.Chained)
{
targets.Add(p);
}
}
foreach (Player p in targets)
{
Skill skill = Engine.IsProhibited(room, player, p, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.BroadcastSkillInvoke(skill.Name, player);
room.NotifySkillInvoked(player, skill.Name);
}
}
else
{
use.To.Add(p);
}
}
room.SortByActionOrder(ref use);
base.OnUse(room, use);
}
}
protected virtual void OnAskforPeach(Room room, Player player, ref object data)
{
DyingStruct dying = (DyingStruct)data;
bool askforpeach = true;
Interactivity client = room.GetInteractivity(player);
List <Player> controlls = new List <Player> {
player
};
if (client != null)
{
controlls = room.GetPlayers(client.ClientId);
}
if (!controlls.Contains(dying.Who))
{
List <Player> players = room.GetAllPlayers();
int index = players.IndexOf(player);
for (int i = 0; i < index; i++)
{
Player p = players[i];
if (controlls.Contains(p))
{
askforpeach = false;
break;
}
}
}
else if (dying.Who != player)
{
askforpeach = false;
}
if (askforpeach)
{
while (dying.Who.Hp <= 0 && dying.Who.Alive)
{
CardUseStruct use = room.AskForSinglePeach(player, dying.Who, dying);
if (use.Card == null)
{
break;
}
else
{
room.UseCard(use, false);
}
}
}
}
public virtual void Use(Room room, CardUseStruct card_use)
{
WrappedCard card = card_use.Card;
List <Player> targets = card_use.To;
for (int index = 0; index < targets.Count; index++)
{
Player target = targets[index];
CardEffectStruct effect = new CardEffectStruct
{
Card = card,
From = card_use.From,
To = target,
Multiple = (targets.Count > 1),
Drank = card_use.Drank,
ExDamage = card_use.ExDamage,
BasicEffect = card_use.EffectCount.Count > index ? card_use.EffectCount[index] : new CardBasicEffect(target, 0, 0, 0)
};
List <Player> players = new List <Player>();
for (int i = index; i < targets.Count; i++)
{
if (card_use.EffectCount.Count <= i || !card_use.EffectCount[i].Nullified)
{
players.Add(targets[i]);
}
}
effect.StackPlayers = players;
room.CardEffect(effect);
}
List <int> table_cardids = room.GetCardIdsOnTable(room.GetSubCards(card));
if (table_cardids.Count > 0)
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_USE, card_use.From.Name, null, card.Skill, null)
{
Card = card
};
if (targets.Count == 1)
{
reason.TargetId = targets[0].Name;
}
CardsMoveStruct move = new CardsMoveStruct(table_cardids, card_use.From, null, Place.PlaceTable, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, true);
}
}
public virtual void OnCardAnnounce(Room room, CardUseStruct use, bool ignore_rule)
{
if (use.EffectCount == null)
{
use.EffectCount = new List <EffctCount>();
}
use.Card = RoomLogic.ParseUseCard(room, use.Card);
room.ShowSkill(use.From, use.Card.ShowSkill, use.Card.SkillPosition);
if (!ignore_rule)
{
CheckTargetModSkillShow(room, use);
}
WrappedCard use_card = use.Card;
//将卡牌转化为延时锦囊就相当于改写了该牌的牌名，必须对其重写以保证此延时锦囊将来可以正确生效
if (Engine.GetFunctionCard(use_card.Name) is DelayedTrick && RoomLogic.IsVirtualCard(room, use_card) && use_card.SubCards.Count == 1)
{
WrappedCard wrapped = room.GetCard(use_card.GetEffectiveId());
wrapped.TakeOver(use_card);
use.Card = wrapped;
}
//record big or small for fighttogether
if (Engine.GetFunctionCard(use_card.Name) is FightTogether && use.To.Count > 0)
{
List <string> big_kingdoms = RoomLogic.GetBigKingdoms(room);
if (big_kingdoms.Count > 0)
{
string target_kingdom = (use.To[0].HasShownOneGeneral() ?
(use.To[0].Role == "careerist" ? use.To[0].Name : use.To[0].Kingdom) : string.Empty);
bool big = big_kingdoms.Contains(target_kingdom);
if (big)
{
use.Pattern = "big";
}
else
{
use.Pattern = "small";
}
}
else
{
use.Pattern = "unknown";
}
}
OnUse(room, use);
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct use = new CardUseStruct(null, player, new List <Player>());
if (!ai.WillShowForAttack())
{
return(use);
}
List <int> ids = new List <int>();
Room room = ai.Room;
foreach (int id in player.GetCards("he"))
{
WrappedCard card = room.GetCard(id);
if (Engine.GetFunctionCard(card.Name) is EquipCard)
{
ids.Add(id);
}
}
if (ids.Count > 0)
{
ai.SortByKeepValue(ref ids, false);
foreach (int id in ids)
{
WrappedCard card = room.GetCard(id);
EquipCard equip = (EquipCard)Engine.GetFunctionCard(card.Name);
int index = (int)equip.EquipLocation();
List <Player> targets = ai.FriendNoSelf;
ai.SortByDefense(ref targets, false);
foreach (Player p in targets)
{
if (p.GetEquip(index) == -1 && RoomLogic.CanPutEquip(p, card))
{
use.Card = new WrappedCard(HuyuanCard.ClassName)
{
Skill = Name, Mute = true
};
use.Card.AddSubCard(id);
use.To.Add(p);
return(use);
}
}
}
}
return(use);
}
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 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 void Use(Room room, CardUseStruct card_use)
{
Player player = card_use.From;
int count = player.GetMark("chenglue") == 0 ? 1 : 2;
player.SetMark("chenglue", count == 1 ? 1 : 0);
List <string> arg = new List <string> {
GameEventType.S_GAME_EVENT_SKILL_TURN.ToString(),
player.Name,
"chenglue",
count == 1 ? true.ToString() : false.ToString(),
card_use.Card.SkillPosition
};
room.DoBroadcastNotify(CommandType.S_COMMAND_LOG_EVENT, arg);
room.DrawCards(player, count, "chenglue");
if (player.Alive)
{
List <int> ids = room.AskForExchange(player, "chenglue", count == 1 ? 2 : 1, count == 1 ? 2 : 1,
string.Format("@chenglue-discard:::{0}", count == 1 ? 2 : 1), string.Empty, ".!", card_use.Card.SkillPosition);
room.ThrowCard(ref ids, player);
string mark = string.Empty;
List <WrappedCard.CardSuit> discards = new List <WrappedCard.CardSuit>();
foreach (int id in ids)
{
WrappedCard.CardSuit suit = room.GetCard(id).Suit;
string suit_string = suits[suit];
if (!mark.Contains(suit_string))
{
mark += suit_string;
}
if (!discards.Contains(suit))
{
discards.Add(suit);
}
}
if (player.Alive && !string.IsNullOrEmpty(mark))
{
player.SetTag("chenglue", discards);
room.SetPlayerStringMark(player, "chenglue", mark);
}
}
}
public virtual void DoRecast(Room room, CardUseStruct use)
{
WrappedCard card = use.Card;
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_RECAST, use.From.Name)
{
SkillName = card.Skill
};
room.RecordSubCards(use.Card);
room.MoveCardTo(card, null, Place.PlaceTable, reason, true);
if (!string.IsNullOrEmpty(reason.SkillName))
{
room.BroadcastSkillInvoke(use.From, use.Card);
}
else
{
room.BroadcastSkillInvoke("@recast", use.From.IsMale() ? "male" : "female", -1);
}
if (!string.IsNullOrEmpty(card.Skill) && !card.Skill.StartsWith("-") && use.IsOwnerUse && RoomLogic.PlayerHasSkill(room, use.From, card.Skill))
{
room.NotifySkillInvoked(use.From, card.Skill);
}
LogMessage log = new LogMessage("#Card_Recast")
{
From = use.From.Name,
Card_str = RoomLogic.CardToString(room, card)
};
room.SendLog(log);
List <int> table_cardids = room.GetCardIdsOnTable(room.GetSubCards(card));
if (table_cardids.Count > 0)
{
CardsMoveStruct move = new CardsMoveStruct(table_cardids, use.From, null, Place.PlaceTable, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct>()
{
move
}, true);
room.RemoveSubCards(use.Card);
}
room.DrawCards(use.From, 1, "recast");
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct use = new CardUseStruct();
List <int> ids = new List <int>();
Room room = ai.Room;
foreach (int id in player.GetEquips())
{
if (RoomLogic.CanDiscard(room, player, player, id))
{
ids.Add(id);
}
}
ai.SortByKeepValue(ref ids, false);
use.Card = room.GetCard(ids[0]);
return(use);
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
List <Player> targets = new List <Player>();
Room room = ai.Room;
foreach (Player p in ai.FriendNoSelf)
{
if (Reinforcement.Instance.TargetFilter(room, targets, p, player, card))
{
targets.Add(p);
}
}
if (targets.Count > 0)
{
use.Card = card;
use.To = targets;
}
}
public override void OnUse(Room room, CardUseStruct card_use)
{
Player source = card_use.From;
List <Player> targets = new List <Player>();
if (card_use.To.Count == 0)
{
List <Player> all_players = room.GetOtherPlayers(card_use.From);
foreach (Player player in all_players)
{
Skill skill = RoomLogic.IsProhibited(room, source, player, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.BroadcastSkillInvoke(skill.Name, player);
room.NotifySkillInvoked(player, skill.Name);
}
}
else
{
targets.Add(player);
}
}
}
else
{
targets = card_use.To;
}
card_use.To = targets;
base.OnUse(room, card_use);
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct use = new CardUseStruct(null, player, new List <Player>());
WrappedCard card = new WrappedCard(Slash.ClassName)
{
Skill = Name, ShowSkill = Name, DistanceLimited = false
};
List <WrappedCard> slashes = new List <WrappedCard> {
card
};
List <ScoreStruct> scores = ai.CaculateSlashIncome(player, slashes, null, false);
if (scores.Count > 0 && scores[0].Score > 0 && scores[0].Players != null && scores[0].Players.Count > 0)
{
use.Card = scores[0].Card;
use.To = scores[0].Players;
}
return(use);
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
Room room = ai.Room;
Player target = null;
foreach (Player p in room.GetOtherPlayers(player))
{
if (ai.HasSkill("jubao", p))
{
target = p;
break;
}
}
if (target != null && !ai.IsFriend(target, player))
{
return;
}
ai.UseEquipCard(ref use, card);
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
List <Player> targets = new List <Player>();
Room room = ai.Room;
List <Player> friends = ai.GetFriends(player);
ai.SortByDefense(ref friends, false);
foreach (Player p in friends)
{
if (HoardUp.Instance.TargetFilter(room, targets, p, player, card))
{
targets.Add(p);
}
}
if (targets.Count > 0)
{
use.Card = card;
use.To = targets;
}
}
