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);
}
protected virtual void RewardAndPunish(Room room, Player killer, Player victim)
{
if (!killer.Alive || !killer.HasShownOneGeneral())
{
return;
}
if (!RoomLogic.IsFriendWith(room, killer, victim))
{
int n = 1;
foreach (Player p in room.GetOtherPlayers(victim))
{
if (RoomLogic.IsFriendWith(room, victim, p))
{
++n;
}
}
room.DrawCards(killer, n, "gamerule");
}
else
{
room.ThrowAllHandCardsAndEquips(killer);
}
}
public override List <TriggerStruct> Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data)
{
List <TriggerStruct> triggers = new List <TriggerStruct>();
if (triggerEvent == TriggerEvent.EventPhaseStart && player.Phase == Player.PlayerPhase.Finish && base.Triggerable(player, room) &&
!player.IsKongcheng() && ShefuVS.GuhuoCards(room, player).Count > 0)
{
triggers.Add(new TriggerStruct(Name, player));
}
else if (triggerEvent == TriggerEvent.CardUsed && data is CardUseStruct use && use.Card != null && use.To.Count > 0 && use.IsHandcard)
{
FunctionCard fcard = Engine.GetFunctionCard(use.Card.Name);
if (fcard is SkillCard)
{
return(triggers);
}
List <Player> chengyus = RoomLogic.FindPlayersBySkillName(room, Name);
string card_name = fcard.Name;
if (fcard is Slash)
{
card_name = Slash.ClassName;
}
foreach (Player p in chengyus)
{
if (p != player && p.Phase == Player.PlayerPhase.NotActive && p.ContainsTag(string.Format("shefu_{0}", card_name)) &&
p.GetTag(string.Format("shefu_{0}", card_name)) is int id && p.GetPile("ambush").Contains(id))
{
triggers.Add(new TriggerStruct(Name, p));
}
}
}
public override List <WrappedCard> GetTurnUse(TrustedAI ai, Player player)
{
Room room = ai.Room;
List <int> ids = player.GetCards("he");
ids.AddRange(player.GetHandPile());
foreach (int id in ids)
{
WrappedCard card = ai.Room.GetCard(id);
if (WrappedCard.IsRed(card.Suit))
{
WrappedCard slash = new WrappedCard(Slash.ClassName)
{
Skill = Name,
ShowSkill = Name
};
slash.AddSubCard(card);
slash = RoomLogic.ParseUseCard(room, slash);
return(new List <WrappedCard> {
slash
});
}
}
return(null);
}
public override double TargetValueAdjust(TrustedAI ai, WrappedCard card, Player to)
{
Room room = ai.Room;
double value = 0;
if (!RoomLogic.IsVirtualCard(room, card))
{
foreach (int id in card.SubCards)
{
if (ai.IsCard(id, Peach.ClassName, to))
{
value += 1;
}
if (ai.IsCard(id, Analeptic.ClassName, to))
{
value += 0.6;
}
}
if (ai.IsEnemy(to))
{
value = -value;
}
}
return(value);
}
public override TriggerStruct Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who)
{
if (triggerEvent == TriggerEvent.TargetChosen && data is CardUseStruct use)
{
FunctionCard fcard = use.Card != null?Engine.GetFunctionCard(use.Card.Name) : null;
if (base.Triggerable(player, room) && use.Card != null && fcard is Slash)
{
List <Player> targets = new List <Player>();
foreach (Player to in use.To)
{
if (RoomLogic.CanDiscard(room, to, to, "he"))
{
targets.Add(to);
}
}
if (targets.Count > 0)
{
return(new TriggerStruct(Name, player, targets));
}
}
}
else if (triggerEvent == TriggerEvent.Dying && data is DyingStruct dying && dying.Damage.Card != null && dying.Damage.Card.Name.Contains(Slash.ClassName) &&
!dying.Damage.Transfer && !dying.Damage.Chain &&
dying.Damage.From != null && dying.Damage.From.Alive && base.Triggerable(dying.Damage.From, room) && !player.IsKongcheng())
{
if (RoomLogic.CanGetCard(room, dying.Damage.From, player, "h"))
{
return(new TriggerStruct(Name, dying.Damage.From));
}
}
return(new TriggerStruct());
}
//服务器操作响应
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 List <WrappedCard> GetViewAsCards(TrustedAI ai, string pattern, Player player)
{
Room room = ai.Room;
Player jiaozhu = ai.FindPlayerBySkill("hongfa");
List <WrappedCard> result = new List <WrappedCard>();
if (jiaozhu != null && RoomLogic.WillBeFriendWith(room, player, jiaozhu) && pattern == Slash.ClassName)
{
foreach (int id in jiaozhu.GetPile("heavenly_army"))
{
WrappedCard hongfa = new WrappedCard("HongfaCard")
{
Skill = "hongfa"
};
hongfa.AddSubCard(id);
WrappedCard slash = new WrappedCard(Slash.ClassName)
{
Skill = "hongfa"
};
slash.AddSubCard(id);
slash = RoomLogic.ParseUseCard(room, slash);
slash.UserString = RoomLogic.CardToString(room, hongfa);
result.Add(slash);
}
}
return(result);
}
public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
Room room = ai.Room;
if (ai.WillSkipPlayPhase(player))
{
int count = 0;
foreach (Player p in room.GetOtherPlayers(player))
{
if (!p.IsAllNude() && RoomLogic.CanGetCard(room, player, p, "hej"))
{
count++;
}
}
Player erzhang = ai.FindPlayerBySkill("guzheng");
if (erzhang != null && !ai.IsFriend(erzhang) && player.HandcardNum + count > player.MaxHp + 2)
{
return(false);
}
}
double value = 0;
foreach (Player p in room.GetOtherPlayers(player))
{
if (!p.IsAllNude() && RoomLogic.CanGetCard(room, player, p, "hej"))
{
value += ai.FindCards2Discard(player, p, string.Empty, "he", HandlingMethod.MethodGet).Score;
}
}
return(value > 4);
}
public virtual void CheckBigKingdoms(Room room)
{
room.DoBroadcastNotify(CommandType.S_COMMAND_LOG_EVENT, new List <string> {
GameEventType.S_GAME_EVENT_BIG_KINGDOM.ToString(),
JsonUntity.Object2Json(RoomLogic.GetBigKingdoms(room))
});
}
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 bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
double value = 0;
Room room = ai.Room;
foreach (Player p in room.GetAlivePlayers())
{
if (p.Chained && RoomLogic.CanDiscard(room, player, p, "he"))
{
if (p == player)
{
List <int> ids = new List <int>();
foreach (int id in player.GetCards("he"))
{
if (RoomLogic.CanDiscard(room, player, player, id))
{
ids.Add(id);
}
}
ai.SortByKeepValue(ref ids, false);
value += ai.GetKeepValue(ids[0], player);
}
else
{
value += ai.FindCards2Discard(player, p, string.Empty, "he", HandlingMethod.MethodDiscard).Score;
}
}
}
return(value > 3);
}
public virtual bool ViewFilter(Room room, WrappedCard to_select, Player player)
{
if (!string.IsNullOrEmpty(filter_pattern))
{
string pat = filter_pattern;
if (pat.EndsWith("!"))
{
if (RoomLogic.IsJilei(room, player, to_select))
{
return(false);
}
pat = pat.Substring(0, pat.Length - 1);
}
if (response_or_use && pat.Contains("hand"))
{
List <string> handlist = new List <string> {
"hand"
};
foreach (string pile in player.GetPileNames())
{
if (pile.StartsWith("&") || pile == "wooden_ox")
{
handlist.Add(pile);
}
}
pat = pat.Replace("hand", string.Join(",", handlist));
}
return(Engine.MatchExpPattern(room, pat, player, to_select));
}
return(false);
}
public override bool TargetFilter(Room room, List <Player> targets, Player to_select, Player Self, WrappedCard card)
{
if (targets.Count > 0 || RoomLogic.IsCardLimited(room, Self, card, HandlingMethod.MethodUse))
{
return(false);
}
Game3v3Camp camp = to_select.Camp;
foreach (Player p in room.GetAlivePlayers())
{
if (Engine.IsProhibited(room, Self, p, card, targets) != null)
{
continue;
}
if (Self.Camp == camp && p.Camp == camp && p.Chained)
{
return(true);
}
else if (Self.Camp != camp && p.Camp == camp && !p.Chained)
{
return(true);
}
}
return(false);
}
private static void LEAVE_ROOM(byte[] bytes)
{
LeaveRoom input = LeaveRoom.Parser.ParseFrom(bytes);
bool ret = false;
RoomLogic roomLogic = ServerRoomManager.Instance.GetRoomLogic(input.RoomId);
if (roomLogic != null)
{
var pi = ServerRoomManager.Instance.GetPlayer(_args);
if (pi != null)
{ // 把当前玩家在房间的状态设置为离线
roomLogic.Offline(pi.Enter.TokenId);
string account = pi.Enter.Account;
ServerRoomManager.Instance.Log($"MSG: LEAVE_ROOM OK - Player leaves the battlefield! Account:{account} - Room:{roomLogic.RoomName}"); // 玩家离开战场！
}
// 通知大厅
ServerRoomManager.Instance.UpdateRoomInfoToLobby(roomLogic);
ret = true;
}
else
{
ServerRoomManager.Instance.Log($"MSG: LEAVE_ROOM Error - Battlefield is not found! RoomId:{input.RoomId}"); // 战场没有找到
}
LeaveRoomReply output = new LeaveRoomReply()
{
Ret = ret,
};
ServerRoomManager.Instance.SendMsg(_args, ROOM_REPLY.LeaveRoomReply, output.ToByteArray());
}
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 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 bool CanRecast(Room room, Player player, WrappedCard card)
{
bool rec = (card.CanRecast && room.GetRoomState().GetCurrentCardUseReason() == CardUseStruct.CardUseReason.CARD_USE_REASON_PLAY &&
!RoomLogic.IsCardLimited(room, player, card, HandlingMethod.MethodRecast));
if (!rec)
{
return(false);
}
List <int> hand_cards = player.HandCards;
if (card.SubCards.Count == 0)
{
return(false);
}
foreach (int id in card.SubCards)
{
if (!hand_cards.Contains(id))
{
rec = false;
break;
}
}
return(rec);
}
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 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);
}
//INDEX OUT OF RANGE??????? SOLVEEE (before was working)
public void SetRoom(TMP_InputField editedName)
{
RoomLogic room = GameObject.Instantiate(rooms[0], Vector3.zero, Quaternion.identity, GameObject.FindWithTag("ROOMS_LOGIC").transform);
roomsGameobjects.Add(room.gameObject);
room.petToSet.name = editedName.text;
editedName.gameObject.SetActive(false);
}
public override bool Triggerable(Player target, Room room)
{
if (target == null)
{
return(false);
}
return(RoomLogic.HasArmorEffect(room, target, Name));
}
private void btn_deleteroom_Click(object sender, EventArgs e)
{
RoomLogic Logic = new RoomLogic();
Logic.DeleteRoom((string)lbx_rooms.SelectedItem);
lbx_rooms.Items.Clear();
LoadRooms();
}
public override void OnUninstall(Room room, Player player, WrappedCard card)
{
if (!RoomLogic.PlayerHasShownSkill(room, player, "zhiheng"))
{
player.ClearHistory("ZhihengCard");
}
base.OnUninstall(room, player, card);
}
// Instantiating the questionLogic
public QuizController()
{
questionLogic = new QuestionLogic();
room_LevelsLogic = new Room_LevelsLogic();
player_StatusLogic = new Player_StatusLogic();
UserLogic = new UserLogic();
RoomLogic = new RoomLogic();
}
public override void OnUninstall(Room room, Player player, WrappedCard card)
{
if (player.Alive && RoomLogic.HasArmorEffect(room, player, Name, false))
{
player.SetFlags("peacespell_throwing");
}
base.OnUninstall(room, player, card);
}
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)
{
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;
}
}
}
}
protected virtual void OnPhaseChanging(Room room, Player player, ref object data)
{
PhaseChangeStruct change = (PhaseChangeStruct)data;
if (change.To == PlayerPhase.NotActive)
{
player.SetFlags(".");
RoomLogic.ClearPlayerCardLimitation(player, true);
foreach (Player p in room.GetAllPlayers())
{
if (p.GetMark("drank") > 0)
{
LogMessage log = new LogMessage
{
Type = "#UnsetDrankEndOfTurn",
From = p.Name
};
room.SendLog(log);
room.SetPlayerMark(p, "drank", 0);
}
}
if (room.ContainsTag("EdictInvoke") && (bool)room.GetTag("EdictInvoke"))
{
room.SetTag("EdictInvoke", false);
LogMessage log = new LogMessage
{
Type = "#EdictEffect",
From = player.Name,
Arg = Edict.ClassName
};
room.SendLog(log);
WrappedCard io = (WrappedCard)room.GetTag("EdictCard");
if (io != null)
{
FunctionCard fcard = Engine.GetFunctionCard(io.Name);
foreach (Player p in room.GetAllPlayers())
{
if (!p.HasShownOneGeneral() && Engine.IsProhibited(room, null, p, io) == null) // from is null!
{
room.CardEffect(io, null, p);
}
}
}
}
}
else if (change.To == PlayerPhase.Play)
{
player.AddHistory(".");
}
else if (change.To == PlayerPhase.Start)
{
if (!player.General1Showed && Engine.GetGeneral(player.ActualGeneral1, room.Setting.GameMode).IsLord())
{
room.ShowGeneral(player);
}
}
}
public override TriggerStruct Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who)
{
if (base.Triggerable(player, room) && data is DamageStruct damage && damage.To.Alive && damage.To != player && !damage.To.IsAllNude() &&
RoomLogic.CanGetCard(room, player, damage.To, "hej"))
{
return(new TriggerStruct(Name, player));
}
return(new TriggerStruct());
}
