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; } }