/// <summary> /// 运行奥秘 /// </summary> /// <param name="SecretCardSN"></param> /// <param name="ActionCode"></param> /// <param name="HitMySelf"></param> /// <returns></returns> public static List <string> RunSecretHit(string SecretCardSN, string ActionCode, bool HitMySelf, ActionStatus game) { List <string> ActionLst = new List <string>(); SecretCard card = (SecretCard)CardUtility.GetCardInfoBySN(SecretCardSN); var actiontype = Server.ActionCode.GetActionType(ActionCode); var actionField = ActionCode.Split(CardUtility.strSplitMark.ToCharArray()); ActionLst.Add(Server.ActionCode.strHitSecret + CardUtility.strSplitMark + (HitMySelf ? CardUtility.strMe : CardUtility.strYou) + CardUtility.strSplitMark + SecretCardSN); //HitMySelf 在自己的回合运行自己的奥秘 switch (card.Condition) { case SecretCondition.对方召唤随从: //如果是召唤系的 if (HitMySelf) { //在自己的回合运行自己的奥秘 //SUMMON#YOU#M000001#POS //例如:亡语的时候可能召唤一个新的随从 //PointEffect.RunPointEffect(game.AllRole.YourBattleInfo.BattleMinions[int.Parse(actionField[3]) - 1],card.AdditionInfo); ActionLst.Add(Server.ActionCode.strPoint + CardUtility.strSplitMark + CardUtility.strYou + CardUtility.strSplitMark + actionField[3] + CardUtility.strSplitMark + card.AdditionInfo); } else { //在自己的回合运行别人的奥秘 if (actiontype == Server.ActionCode.ActionType.Summon) { //SUMMON#YOU#M000001#POS //PointEffect.RunPointEffect(game.MyInfo.BattleField.BattleMinions[int.Parse(actionField[3]) - 1], card.AdditionInfo); ActionLst.Add(Server.ActionCode.strPoint + CardUtility.strSplitMark + CardUtility.strMe + CardUtility.strSplitMark + actionField[3] + CardUtility.strSplitMark + card.AdditionInfo); } else { //MINION#M000001#1 //PointEffect.RunPointEffect(game.MyInfo.BattleField.BattleMinions[int.Parse(actionField[2]) - 1], card.AdditionInfo); ActionLst.Add(Server.ActionCode.strPoint + CardUtility.strSplitMark + CardUtility.strMe + CardUtility.strSplitMark + actionField[2] + CardUtility.strSplitMark + card.AdditionInfo); } } break; default: break; } return(ActionLst); }
/// <summary> /// 使用手牌 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnUseHandCard_Click(object sender, EventArgs e) { if (((Button)sender).Tag == null) { return; } CardBasicInfo card; if (((Button)sender).Name == "btnMyHeroAblity") { card = CardUtility.GetCardInfoBySN(((Button)sender).Tag.ToString()); } else { card = (CardBasicInfo)((Button)sender).Tag; } var msg = game.CheckCondition(card); if (!String.IsNullOrEmpty(msg)) { MessageBox.Show(msg); return; } var actionlst = RunAction.StartAction(game, card.SN); if (actionlst.Count != 0) { game.MySelf.RoleInfo.crystal.CurrentRemainPoint -= card.ActualCostPoint; if (((Button)sender).Name != "btnMyHeroAblity") { game.RemoveUsedCard(card.SN); } else { game.MySelf.RoleInfo.IsUsedHeroAbility = true; } actionlst.Add(ActionCode.strCrystal + CardUtility.strSplitMark + CardUtility.strMe + CardUtility.strSplitMark + game.MySelf.RoleInfo.crystal.CurrentRemainPoint + CardUtility.strSplitMark + game.MySelf.RoleInfo.crystal.CurrentFullPoint); //奥秘计算 actionlst.AddRange(game.奥秘计算(actionlst)); game.MySelf.ResetHandCardCost(); Card.Client.ClientRequest.WriteAction(game.GameId.ToString(GameServer.GameIdFormat), actionlst); DisplayMyInfo(); } }
/// <summary> /// 初始化 /// </summary> public void Init() { //手牌设定 var HandCard = Card.Client.ClientRequest.DrawCard(GameId.ToString(GameServer.GameIdFormat), IsFirst, IsFirst ? PlayerBasicInfo.BasicHandCardCount : (PlayerBasicInfo.BasicHandCardCount + 1)); MySelf.RoleInfo.crystal.CurrentFullPoint = 0; MySelf.RoleInfo.crystal.CurrentRemainPoint = 0; YourInfo.crystal.CurrentFullPoint = 0; YourInfo.crystal.CurrentRemainPoint = 0; //DEBUG START MySelf.RoleInfo.crystal.CurrentFullPoint = 5; MySelf.RoleInfo.crystal.CurrentRemainPoint = 5; YourInfo.crystal.CurrentFullPoint = 5; YourInfo.crystal.CurrentRemainPoint = 5; HandCard.Add("M000024"); HandCard.Add("M000115"); //DEBUG END //英雄技能:奥术飞弹 MySelf.RoleInfo.HeroAbility = (Card.AbilityCard)Card.CardUtility.GetCardInfoBySN("A200001"); YourInfo.HeroAbility = (Card.AbilityCard)Card.CardUtility.GetCardInfoBySN("A200001"); if (!IsFirst) { HandCard.Add(Card.CardUtility.SN幸运币); } foreach (var card in HandCard) { MySelf.handCards.Add(CardUtility.GetCardInfoBySN(card)); } MySelf.RoleInfo.HandCardCount = HandCard.Count; if (IsFirst) { MySelf.RoleInfo.RemainCardDeckCount = Card.Client.CardDeck.MaxCards - 3; YourInfo.RemainCardDeckCount = Card.Client.CardDeck.MaxCards - 4; } else { MySelf.RoleInfo.RemainCardDeckCount = Card.Client.CardDeck.MaxCards - 4; YourInfo.RemainCardDeckCount = Card.Client.CardDeck.MaxCards - 3; } }
/// <summary> /// 使用手牌 /// </summary> /// <param name="GameId"></param> /// <param name="IsHost"></param> /// <param name="CardSn"></param> /// <returns></returns> public static FullServerManager.Interrupt UseHandCard(int GameId, bool IsHost, string CardSn, int Step, string SessionData) { var gamestatus = GameRunning_BS[GameId].gameStatus(IsHost); gamestatus.Interrupt.IsHost = IsHost; gamestatus.Interrupt.GameId = GameId.ToString(GameIdFormat); gamestatus.GameId = GameId; gamestatus.Interrupt.Step = Step; gamestatus.Interrupt.SessionData = SessionData; RunAction.StartAction(gamestatus, CardSn); if (gamestatus.Interrupt.ActionName == CardUtility.strOK) { gamestatus.AllRole.MyPublicInfo.crystal.CurrentRemainPoint -= CardUtility.GetCardInfoBySN(CardSn).使用成本; gamestatus.AllRole.MyPublicInfo.HandCardCount--; gamestatus.AllRole.MyPrivateInfo.RemoveUsedCard(CardSn); } gamestatus.Interrupt.ActionCard = new MinimizeBattleInfo.HandCardInfo(); gamestatus.Interrupt.ActionCard.Init(CardUtility.GetCardInfoBySN(CardSn)); return(gamestatus.Interrupt); }
/// <summary> /// 奥秘是否命中 /// </summary> /// <param name="SecretCardSN"></param> /// <param name="ActionCode"></param> /// <param name="HitMySelf">是否检查自己是否触发自己的奥秘</param> /// <returns></returns> public static bool IsSecretHit(string SecretCardSN, string ActionCode, bool HitMySelf) { //HitMySelf //这里需要关注方向性问题 SecretCard card = (SecretCard)CardUtility.GetCardInfoBySN(SecretCardSN); var actiontype = Server.ActionCode.GetActionType(ActionCode); var actionField = ActionCode.Split(CardUtility.strSplitMark.ToCharArray()); bool IsHit = false; switch (card.Condition) { case SecretCondition.对方召唤随从: if (HitMySelf) { //在自己的回合检查否触发自己的奥秘,如果是召唤系的 //SUMMON#YOU#M000001 //HitMySelf的时候,是YOU if (actiontype == Server.ActionCode.ActionType.Summon && actionField[1] == CardUtility.strYou) { IsHit = true; } } else { //在别人的回合检查否触发自己的奥秘,是ME if (actiontype == Server.ActionCode.ActionType.Summon && actionField[1] == CardUtility.strMe) { IsHit = true; } if (actiontype == Server.ActionCode.ActionType.UseMinion) { IsHit = true; } } break; default: break; } return(IsHit); }
/// <summary> /// 事件处理方法 /// </summary> /// <param name="事件"></param> /// <param name="game"></param> /// <returns></returns> public List <string> 事件处理方法(EventCard.全局事件 事件, ActionStatus game) { List <string> ActionLst = new List <string>(); if (!沉默状态 && 自身事件效果.触发效果事件类型 == 事件.触发事件类型) { if (自身事件效果.触发效果事件方向 != CardUtility.目标选择方向枚举.双方) { if (自身事件效果.触发效果事件方向 == CardUtility.目标选择方向枚举.本方 && (!事件.触发位置.本方对方标识)) { return(ActionLst); } if (自身事件效果.触发效果事件方向 == CardUtility.目标选择方向枚举.对方 && (事件.触发位置.本方对方标识)) { return(ActionLst); } } if (!string.IsNullOrEmpty(自身事件效果.限制信息) && !SelectUtility.符合选择条件(this, 自身事件效果.限制信息)) { return(ActionLst); } ActionLst.Add(Server.ActionCode.strHitEvent + CardUtility.strSplitMark); //这里有可能是一个增益表达式!! if (自身事件效果.效果编号.StartsWith("A")) { ActionLst.AddRange(((SpellCard)CardUtility.GetCardInfoBySN(自身事件效果.效果编号)).UseSpell(game)); } else { Effect.PointEffect t = new Effect.PointEffect(); string[] opt = 自身事件效果.效果编号.Split("/".ToCharArray()); t.持续回合 = CardUtility.Max.ToString(); t.攻击力 = opt[0]; t.生命值 = opt[1]; ((Effect.IAtomicEffect)t).DealMinion(game, this); } 潜行特性 = false; } return(ActionLst); }
/// <summary> /// /// </summary> /// <param name="singleEffect"></param> /// <param name="game"></param> /// <returns></returns> public static List <string> RunEffect(EffectDefine singleEffect, Client.GameManager game, CardUtility.TargetPosition Pos) { List <string> Result = new List <string>(); var Summon = (Card.MinionCard)CardUtility.GetCardInfoBySN(singleEffect.AddtionInfo); //一定要初始化,不然的话,生命值是-1; Summon.Init(); if (Pos.MeOrYou) { game.MySelf.RoleInfo.BattleField.BattleMinions[Pos.Postion - 1] = Summon; //TRANSFORM#ME#1#M9000001 Result.Add(ActionCode.strTransform + Card.CardUtility.strSplitMark + CardUtility.strMe + Card.CardUtility.strSplitMark + Pos.Postion + Card.CardUtility.strSplitMark + singleEffect.AddtionInfo); } else { game.YourInfo.BattleField.BattleMinions[Pos.Postion - 1] = Summon; Result.Add(ActionCode.strTransform + Card.CardUtility.strSplitMark + CardUtility.strYou + Card.CardUtility.strSplitMark + Pos.Postion + Card.CardUtility.strSplitMark + singleEffect.AddtionInfo); } return(Result); }
/// <summary> /// 对方复原操作 /// </summary> /// <param name="game"></param> /// <param name="actField"></param> public static void ReRunEffect(int GameId, ActionStatus game, string[] actField) { if (actField[1] == CardUtility.strYou) { if (actField.Length == 3) { //如果有第三参数,则获得指定手牌 game.AllRole.MyPrivateInfo.handCards.Add(CardUtility.GetCardInfoBySN(actField[2])); game.AllRole.MyPublicInfo.HandCardCount++; } else { var drawCards = ClientRequest.DrawCard(GameId.ToString(GameServer.GameIdFormat), game.IsHost, 1); game.AllRole.MyPrivateInfo.handCards.Add(CardUtility.GetCardInfoBySN(drawCards[0])); game.AllRole.MyPublicInfo.HandCardCount++; game.AllRole.MyPublicInfo.RemainCardDeckCount--; } } else { game.AllRole.YourPublicInfo.HandCardCount++; game.AllRole.YourPublicInfo.RemainCardDeckCount--; } }
/// <summary> /// 初始化手牌(CS) /// </summary> /// <param name="IsHost"></param> public void InitHandCard() { int DrawCardCnt = IsFirst ? PublicInfo.BasicHandCardCount : (PublicInfo.BasicHandCardCount + 1); foreach (var card in ClientRequest.DrawCard(GameId.ToString(GameServer.GameIdFormat), IsHost, DrawCardCnt)) { actionStatus.AllRole.MyPrivateInfo.handCards.Add(CardUtility.GetCardInfoBySN(card)); } if (IsFirst) { actionStatus.AllRole.MyPublicInfo.RemainCardDeckCount = CardDeck.MaxCards - 3; actionStatus.AllRole.YourPublicInfo.RemainCardDeckCount = CardDeck.MaxCards - 4; actionStatus.AllRole.MyPublicInfo.HandCardCount = PublicInfo.BasicHandCardCount; actionStatus.AllRole.YourPublicInfo.HandCardCount = PublicInfo.BasicHandCardCount + 1 + 1; } else { actionStatus.AllRole.MyPrivateInfo.handCards.Add(CardUtility.GetCardInfoBySN(SpellCard.SN幸运币)); actionStatus.AllRole.MyPublicInfo.RemainCardDeckCount = CardDeck.MaxCards - 4; actionStatus.AllRole.YourPublicInfo.RemainCardDeckCount = CardDeck.MaxCards - 3; actionStatus.AllRole.MyPublicInfo.HandCardCount = PublicInfo.BasicHandCardCount + 1 + 1; actionStatus.AllRole.YourPublicInfo.HandCardCount = PublicInfo.BasicHandCardCount; } }
/// <summary> /// 开始一个动作 /// </summary> /// <param name="game"></param> /// <param name="CardSn"></param> /// <param name="ConvertPosDirect">亡语的时候,需要倒置方向</param> /// <returns></returns> public static List <String> StartAction(GameManager game, String CardSn, Boolean ConvertPosDirect = false) { Card.CardBasicInfo card = Card.CardUtility.GetCardInfoBySN(CardSn); List <String> ActionCodeLst = new List <string>(); switch (card.CardType) { case CardBasicInfo.CardTypeEnum.法术: ActionCodeLst.Add(UseAbility(CardSn)); //初始化 Buff效果等等 Card.AbilityCard ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(CardSn); ablity.CardAbility.Init(); var ResultArg = game.UseAbility(ablity, ConvertPosDirect); if (ResultArg.Count != 0) { ActionCodeLst.AddRange(ResultArg); //英雄技能的时候,不算[本方施法] A900001 幸运币 if (CardSn.Substring(1, 1) != "2") { ActionCodeLst.AddRange(game.MySelf.RoleInfo.BattleField.触发事件(MinionCard.事件类型列表.本方施法, game)); } } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.随从: int MinionPos = GetPutPos(game); if (MinionPos != -1) { ActionCodeLst.Add(UseMinion(CardSn, MinionPos)); var minion = (Card.MinionCard)card; //初始化 minion.Init(); game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); ActionCodeLst.AddRange(minion.发动战吼(game)); game.MySelf.RoleInfo.BattleField.ResetBuff(); } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.武器: ActionCodeLst.Add(UseWeapon(CardSn)); game.MySelf.RoleInfo.Weapon = (Card.WeaponCard)card; break; case CardBasicInfo.CardTypeEnum.奥秘: ActionCodeLst.Add(UseSecret(CardSn)); game.MySelf.奥秘列表.Add((Card.SecretCard)card); break; default: break; } return(ActionCodeLst); }
/// <summary> /// 新的回合 /// </summary> public void TurnStart() { if (IsMyTurn) { //对手回合加成属性的去除 int ExistMinionCount = YourInfo.BattleField.MinionCount; for (int i = 0; i < ExistMinionCount; i++) { if (YourInfo.BattleField.BattleMinions[i] != null) { YourInfo.BattleField.BattleMinions[i].本回合生命力加成 = 0; YourInfo.BattleField.BattleMinions[i].本回合攻击力加成 = 0; if (YourInfo.BattleField.BattleMinions[i].特殊效果 == MinionCard.特殊效果列表.回合结束死亡) { YourInfo.BattleField.BattleMinions[i] = null; } } } YourInfo.BattleField.ClearDead(this, false); //魔法水晶的增加 MyInfo.crystal.NewTurn(); //过载的清算 if (OverloadPoint != 0) { MyInfo.crystal.ReduceCurrentPoint(OverloadPoint); OverloadPoint = 0; } //连击的重置 MyInfo.连击状态 = false; //手牌 var NewCardList = Card.Client.ClientRequest.DrawCard(GameId.ToString(GameServer.GameIdFormat), IsFirst, 1); foreach (var card in NewCardList) { if (MySelfInfo.handCards.Count < PublicInfo.MaxHandCardCount) { MySelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(card)); } } MyInfo.HandCardCount++; MyInfo.RemainCardDeckCount--; MyInfo.RemainAttactTimes = 1; MyInfo.IsUsedHeroAbility = false; foreach (var minion in MyInfo.BattleField.BattleMinions) { if (minion != null) { switch (minion.冰冻状态) { case CardUtility.EffectTurn.效果命中: //如果上回合被命中的,这回合就是作用中 minion.冰冻状态 = CardUtility.EffectTurn.效果作用; break; case CardUtility.EffectTurn.效果作用: //如果上回合作用中的,这回合就是解除 minion.冰冻状态 = CardUtility.EffectTurn.无效果; break; } } } //重置攻击次数,必须放在状态变化之后! //原因是剩余攻击回数和状态有关! foreach (var minion in MyInfo.BattleField.BattleMinions) { if (minion != null) { minion.ResetAttackTimes(); } } //手牌消耗的计算 MySelfInfo.ResetHandCardCost(this); } else { YourInfo.crystal.NewTurn(); if (YourInfo.HandCardCount < PublicInfo.MaxHandCardCount) { YourInfo.HandCardCount++; } YourInfo.RemainCardDeckCount--; YourInfo.RemainAttactTimes = 1; YourInfo.IsUsedHeroAbility = false; //重置攻击次数 foreach (var minion in YourInfo.BattleField.BattleMinions) { if (minion != null) { minion.ResetAttackTimes(); } } //如果对手有可以解除冰冻的,解除冰冻 foreach (var minion in YourInfo.BattleField.BattleMinions) { if (minion != null) { switch (minion.冰冻状态) { case CardUtility.EffectTurn.效果命中: //如果上回合被命中的,这回合就是作用中 minion.冰冻状态 = CardUtility.EffectTurn.效果作用; break; case CardUtility.EffectTurn.效果作用: //如果上回合作用中的,这回合就是解除 minion.冰冻状态 = CardUtility.EffectTurn.无效果; break; } } } } }
/// <summary> /// 新的回合 /// </summary> public void TurnStart() { if (IsMyTurn) { //魔法水晶的增加 MySelf.RoleInfo.crystal.NewTurn(); //过载的清算 if (OverloadPoint != 0) { MySelf.RoleInfo.crystal.ReduceCurrentPoint(OverloadPoint); OverloadPoint = 0; } //手牌 var NewCardList = Card.Client.ClientRequest.DrawCard(GameId.ToString(GameServer.GameIdFormat), IsFirst, 1); foreach (var card in NewCardList) { if (MySelf.handCards.Count < PlayerBasicInfo.MaxHandCardCount) { MySelf.handCards.Add(CardUtility.GetCardInfoBySN(card)); } } MySelf.RoleInfo.HandCardCount++; MySelf.RoleInfo.RemainCardDeckCount--; MySelf.RoleInfo.RemainAttactTimes = 1; MySelf.RoleInfo.IsUsedHeroAbility = false; foreach (var minion in MySelf.RoleInfo.BattleField.BattleMinions) { if (minion != null) { switch (minion.冰冻状态) { case CardUtility.EffectTurn.效果命中: //如果上回合被命中的,这回合就是作用中 minion.冰冻状态 = CardUtility.EffectTurn.效果作用; break; case CardUtility.EffectTurn.效果作用: //如果上回合作用中的,这回合就是解除 minion.冰冻状态 = CardUtility.EffectTurn.无效果; break; } } } //重置攻击次数,必须放在状态变化之后! //原因是剩余攻击回数和状态有关! foreach (var minion in MySelf.RoleInfo.BattleField.BattleMinions) { if (minion != null) { minion.ResetAttackTimes(); } } //手牌消耗的计算 MySelf.ResetHandCardCost(); } else { YourInfo.crystal.NewTurn(); if (YourInfo.HandCardCount < PlayerBasicInfo.MaxHandCardCount) { YourInfo.HandCardCount++; } YourInfo.RemainCardDeckCount--; YourInfo.RemainAttactTimes = 1; YourInfo.IsUsedHeroAbility = false; //重置攻击次数 foreach (var minion in YourInfo.BattleField.BattleMinions) { if (minion != null) { minion.ResetAttackTimes(); } } //如果对手有可以解除冰冻的,解除冰冻 foreach (var minion in YourInfo.BattleField.BattleMinions) { if (minion != null) { switch (minion.冰冻状态) { case CardUtility.EffectTurn.效果命中: //如果上回合被命中的,这回合就是作用中 minion.冰冻状态 = CardUtility.EffectTurn.效果作用; break; case CardUtility.EffectTurn.效果作用: //如果上回合作用中的,这回合就是解除 minion.冰冻状态 = CardUtility.EffectTurn.无效果; break; } } } } }
/// <summary> /// 使用法术 /// </summary> /// <param name="game"></param> /// <param name="IsMyAction">对象方向转换</param> public static void RunBS(ActionStatus game, string CardSn) { List <string> Result = new List <string>(); SpellCard spell = (SpellCard)CardUtility.GetCardInfoBySN(CardSn); //Step1 CardUtility.抉择枚举 PickAbilityResult = CardUtility.抉择枚举.第一效果; SpellCard.AbilityDefine ability = new SpellCard.AbilityDefine(); if (game.Interrupt.Step == 1) { switch (spell.效果选择类型) { case SpellCard.效果选择类型枚举.无需选择: game.Interrupt.ExternalInfo = "1"; break; case SpellCard.效果选择类型枚举.主动选择: game.Interrupt.Step = 2; game.Interrupt.ActionName = "SPELLDECIDE"; game.Interrupt.ExternalInfo = spell.FirstAbilityDefine.描述 + CardUtility.strSplitArrayMark + spell.SecondAbilityDefine.描述; return; case SpellCard.效果选择类型枚举.自动判定: game.Interrupt.ExternalInfo = "1"; if (!ExpressHandler.AbilityPickCondition(game, spell.效果选择条件)) { PickAbilityResult = CardUtility.抉择枚举.第二效果; game.Interrupt.ExternalInfo = "2"; } break; default: break; } game.Interrupt.Step = 2; } //Step2 if (game.Interrupt.Step == 2) { if (spell.效果选择类型 == SpellCard.效果选择类型枚举.主动选择 && SystemManager.游戏类型 == SystemManager.GameType.HTML版) { switch (game.Interrupt.SessionDic["SPELLDECIDE"]) { case "1": PickAbilityResult = CardUtility.抉择枚举.第一效果; break; case "2": PickAbilityResult = CardUtility.抉择枚举.第二效果; break; default: PickAbilityResult = CardUtility.抉择枚举.取消; break; } } if (PickAbilityResult != CardUtility.抉择枚举.取消) { List <EffectDefine> SingleEffectList = new List <EffectDefine>(); if (PickAbilityResult == CardUtility.抉择枚举.第一效果) { ability = spell.FirstAbilityDefine; } else { ability = spell.SecondAbilityDefine; } if (game.ActionName == "USEMINIONCARD") { //如果整个大的动作时随从入场,并且如果这个战吼不需要指定位置,则现在的话,将入场随从设定为指定位置 ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos.本方对方标识 = true; ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos.位置 = int.Parse(game.Interrupt.SessionDic["MINIONPOSITION"]); } if (ability.IsNeedTargetSelect()) { if (game.ActionName == "USEMINIONCARD" && game.Interrupt.SessionDic.ContainsKey("BATTLECRYPOSITION")) { ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos = CardUtility.指定位置结构体.FromString(game.Interrupt.SessionDic["BATTLECRYPOSITION"]); } else { if (game.ActionName == "USESPELLCARD" && game.Interrupt.SessionDic.ContainsKey("SPELLPOSITION")) { ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos = CardUtility.指定位置结构体.FromString(game.Interrupt.SessionDic["SPELLPOSITION"]); } else { ability.MainAbilityDefine.AbliltyPosPicker.CanNotSelectPos.位置 = BattleFieldInfo.UnknowPos; SelectUtility.SetTargetSelectEnable(ability.MainAbilityDefine.AbliltyPosPicker, game); game.Interrupt.ExternalInfo = SelectUtility.GetTargetListString(game); game.Interrupt.ActionName = "SPELLPOSITION"; return; } } } game.Interrupt.Step = 3; } else { game.Interrupt.Step = -1; return; } } if (game.Interrupt.Step == 3) { SpellCard.RunAbility(game, ability); if (spell.法术卡牌类型 == CardBasicInfo.法术卡牌类型枚举.普通卡牌) { game.battleEvenetHandler.事件池.Add(new EventCard.全局事件() { 触发事件类型 = EventCard.事件类型枚举.施法, 触发位置 = new CardUtility.指定位置结构体() { 位置 = BattleFieldInfo.HeroPos, 本方对方标识 = true } }); } } game.Interrupt.Step = 99; game.Interrupt.ActionName = CardUtility.strOK; }
/// <summary> /// 开始回合 /// </summary> /// <param name="IsHost"></param> public void TurnStart(bool IsHost) { gameStatus(IsHost).AllRole.MyPrivateInfo.handCards.Add(CardUtility.GetCardInfoBySN(DrawCard(IsHost, 1)[0])); TurnAction.TurnStart(gameStatus(IsHost)); }
/// <summary> /// 处理对方的动作 /// </summary> /// <param name="ActionCommand"></param> /// <param name="game"></param> public static void Process(string ActionCommand, ActionStatus game) { string[] actField = ActionCommand.Split(CardUtility.strSplitMark.ToCharArray()); switch (ActionCode.GetActionType(ActionCommand)) { case ActionCode.ActionType.Card: CardEffect.ReRunEffect(1, game, actField); break; case ActionCode.ActionType.UseMinion: int Pos = int.Parse(actField[2]); var minion = (MinionCard)CardUtility.GetCardInfoBySN(actField[1]); minion.初始化(); game.AllRole.YourPublicInfo.BattleField.PutToBattle(Pos, minion); Buff.ResetBuff(game); break; case ActionCode.ActionType.UseWeapon: game.AllRole.YourPublicInfo.Hero.Weapon = (WeaponCard)CardUtility.GetCardInfoBySN(actField[1]); break; case ActionCode.ActionType.UseSecret: game.AllRole.YourPublicInfo.Hero.SecretCount++;; break; case ActionCode.ActionType.UseAbility: break; case ActionCode.ActionType.Fight: //FIGHT#1#2 FightHandler.Fight(int.Parse(actField[2]), int.Parse(actField[1]), game, false); break; case ActionCode.ActionType.Point: IAtomicEffect point = new PointEffect(); point.ReRunEffect(game, actField); break; case ActionCode.ActionType.Health: IAtomicEffect health = new HealthEffect(); health.ReRunEffect(game, actField); break; case ActionCode.ActionType.Status: IAtomicEffect status = new StatusEffect(); status.ReRunEffect(game, actField); break; case ActionCode.ActionType.Transform: IAtomicEffect transform = new TransformEffect(); transform.ReRunEffect(game, actField); break; case ActionCode.ActionType.Attack: IAtomicEffect attack = new AttackEffect(); attack.ReRunEffect(game, actField); break; case ActionCode.ActionType.HitSecret: SecretCard.ReRunSecret(game, actField); break; case ActionCode.ActionType.Control: ControlEffect.ReRunEffect(game, actField); break; case ActionCode.ActionType.Summon: SummonEffect.ReRunEffect(game, actField); break; case ActionCode.ActionType.Crystal: CrystalEffect.ReRunEffect(game, actField); break; case ActionCode.ActionType.WeaponPoint: WeaponPointEffect.ReRunEffect(game, actField); break; case ActionCode.ActionType.Settle: ActionStatus.Settle(game); break; } }
/// <summary> /// 对方复原操作 /// </summary> /// <param name="game"></param> /// <param name="actField"></param> void IAtomicEffect.ReRunEffect(ActionStatus game, string[] actField) { if (actField[1] == CardUtility.strYou) { //MyInfo game.AllRole.MyPublicInfo.BattleField.BattleMinions[int.Parse(actField[2]) - 1] = (Engine.Card.MinionCard)CardUtility.GetCardInfoBySN(actField[3]); } else { game.AllRole.YourPublicInfo.BattleField.BattleMinions[int.Parse(actField[2]) - 1] = (Engine.Card.MinionCard)CardUtility.GetCardInfoBySN(actField[3]); } }
/// <summary> /// 初始化 /// </summary> public void InitPlayInfo() { //位置 HostStatus.BasicInfo.Hero.战场位置 = new CardUtility.指定位置结构体() { 本方对方标识 = true, 位置 = BattleFieldInfo.HeroPos }; GuestStatus.BasicInfo.Hero.战场位置 = new CardUtility.指定位置结构体() { 本方对方标识 = false, 位置 = BattleFieldInfo.HeroPos }; HostStatus.BasicInfo.BattleField.本方对方标识 = true; GuestStatus.BasicInfo.BattleField.本方对方标识 = false; //水晶 HostStatus.BasicInfo.crystal.CurrentFullPoint = 0; HostStatus.BasicInfo.crystal.CurrentRemainPoint = 0; GuestStatus.BasicInfo.crystal.CurrentFullPoint = 0; GuestStatus.BasicInfo.crystal.CurrentRemainPoint = 0; HeroCard HostHero = new HeroCard(); HeroCard GuestHero = new HeroCard(); HostStatus.BasicInfo.Hero = HostHero; GuestStatus.BasicInfo.Hero = GuestHero; //英雄技能:法术火球 HostHero.HeroSkillCardSN = "A100002"; //英雄技能:召唤蜘蛛 GuestHero.HeroSkillCardSN = "A110002"; //TEST START //法术测试:闷棍 //HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN("A000073")); //战吼测试:叫嚣的中士 //HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN("M000054")); //亡语测试:鬼灵爬行者 //HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN("M9A0003")); //亡语测试:阿努巴尔伏击者[亡语] //HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN("A300003")); //TEST END //初始化双方手牌 int DrawCardCnt = 0; if (HostAsFirst) { DrawCardCnt = PublicInfo.BasicHandCardCount; foreach (var card in DrawCard(true, DrawCardCnt)) { HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(card)); } DrawCardCnt = PublicInfo.BasicHandCardCount + 1; foreach (var card in DrawCard(false, DrawCardCnt)) { GuestStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(card)); } GuestStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(Card.SpellCard.SN幸运币)); HostStatus.BasicInfo.RemainCardDeckCount = CardDeck.MaxCards - 3; GuestStatus.BasicInfo.RemainCardDeckCount = CardDeck.MaxCards - 4; HostStatus.BasicInfo.HandCardCount = PublicInfo.BasicHandCardCount; GuestStatus.BasicInfo.HandCardCount = PublicInfo.BasicHandCardCount + 1 + 1; TurnStart(true); } else { DrawCardCnt = PublicInfo.BasicHandCardCount + 1; foreach (var card in DrawCard(true, DrawCardCnt)) { HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(card)); } HostStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(Card.SpellCard.SN幸运币)); DrawCardCnt = PublicInfo.BasicHandCardCount; foreach (var card in DrawCard(false, DrawCardCnt)) { GuestStatus.SelfInfo.handCards.Add(CardUtility.GetCardInfoBySN(card)); } HostStatus.BasicInfo.RemainCardDeckCount = CardDeck.MaxCards - 4; GuestStatus.BasicInfo.RemainCardDeckCount = CardDeck.MaxCards - 3; HostStatus.BasicInfo.HandCardCount = PublicInfo.BasicHandCardCount + 1 + 1; GuestStatus.BasicInfo.HandCardCount = PublicInfo.BasicHandCardCount; TurnStart(false); } }
/// <summary> /// 随从卡牌 /// </summary> /// <param name="game"></param> /// <param name="CardSn"></param> public static void RunBS(ActionStatus game, string CardSn) { int MinionPos = -1; MinionCard minion = minion = (MinionCard)CardUtility.GetCardInfoBySN(CardSn); //Step1 if (game.Interrupt.Step == 1) { if (game.AllRole.MyPublicInfo.BattleField.MinionCount != 0) { game.Interrupt.Step = 2; game.Interrupt.ActionName = "MINIONPOSITION"; return; } else { game.Interrupt.SessionData = "MINIONPOSITION:1|"; } MinionPos = 1; game.Interrupt.Step = 2; } //Step2 if (game.Interrupt.Step == 2) { if (MinionPos == -1) { MinionPos = int.Parse(game.Interrupt.SessionDic["MINIONPOSITION"]); } //初始化 minion.初始化(); //随从入场 game.AllRole.MyPublicInfo.BattleField.PutToBattle(MinionPos, minion); //必须在放入之前做得原因是,被放入的随从不能被触发这个事件 game.battleEvenetHandler.事件池.Add(new EventCard.全局事件() { 触发事件类型 = EventCard.事件类型枚举.召唤, 触发位置 = new CardUtility.指定位置结构体() { 位置 = MinionPos, 本方对方标识 = game.IsHost } }); game.Interrupt.Step = 3; } //Step3 if (game.Interrupt.Step == 3 && !string.IsNullOrEmpty(minion.战吼效果)) { SpellCard spell = (SpellCard)CardUtility.GetCardInfoBySN(minion.战吼效果); game.Interrupt.Step = 4; if (spell.FirstAbilityDefine.IsNeedTargetSelect()) { //这里先简单假设所有战吼,如果需要指定位置,则自身不能成为指定位置 spell.FirstAbilityDefine.MainAbilityDefine.AbliltyPosPicker.CanNotSelectPos.本方对方标识 = true; spell.FirstAbilityDefine.MainAbilityDefine.AbliltyPosPicker.CanNotSelectPos.位置 = int.Parse(game.Interrupt.SessionDic["MINIONPOSITION"]); SelectUtility.SetTargetSelectEnable(spell.FirstAbilityDefine.MainAbilityDefine.AbliltyPosPicker, game); game.Interrupt.ExternalInfo = SelectUtility.GetTargetListString(game); game.Interrupt.ActionName = "BATTLECRYPOSITION"; return; } } if (game.Interrupt.Step == 4) { //法术位置信息包含在SessionData中,传递下去 //这种类型的战吼,直接转换为施法 //这里约定:战吼是无需抉择的 game.Interrupt.ActionName = "RUNBATTLECRY"; game.Interrupt.Step = 1; if (game.Interrupt.SessionDic.ContainsKey("BATTLECRYPOSITION") && game.Interrupt.SessionDic["BATTLECRYPOSITION"] == "-1") { //放弃战吼,例如没有友方的时候的叫嚣的中士 game.Interrupt.Step = 99; } else { UseSpellAction.RunBS(game, minion.战吼效果); } } game.Interrupt.Step = 99; game.Interrupt.ActionName = CardUtility.strOK; }
/// <summary> /// 开始一个动作 /// </summary> /// <param name="game"></param> /// <param name="CardSn"></param> /// <param name="ConvertPosDirect">亡语的时候,需要倒置方向</param> /// <returns></returns> public static List <String> StartAction(GameManager game, String CardSn, Boolean ConvertPosDirect = false) { Card.CardBasicInfo card = Card.CardUtility.GetCardInfoBySN(CardSn); List <String> ActionCodeLst = new List <string>(); switch (card.CardType) { case CardBasicInfo.CardTypeEnum.法术: ActionCodeLst.Add(UseAbility(CardSn)); //初始化 Buff效果等等 Card.AbilityCard ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(CardSn); //连击效果的法术修改 if (game.MySelf.RoleInfo.IsCombit && (!String.IsNullOrEmpty(card.连击效果))) { ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(card.连击效果); } ablity.CardAbility.Init(); var ResultArg = game.UseAbility(ablity, ConvertPosDirect); if (ResultArg.Count != 0) { ActionCodeLst.AddRange(ResultArg); //英雄技能等的时候,不算[本方施法] if (CardSn.Substring(1, 1) == "0") { ActionCodeLst.AddRange(game.MySelf.RoleInfo.BattleField.触发事件(new Card.CardUtility.全局事件() { 事件类型 = CardUtility.事件类型列表.施法 }, game)); } } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.随从: int MinionPos = 1; if (game.MySelf.RoleInfo.BattleField.MinionCount != 0) { MinionPos = GetPutPos(game); } if (MinionPos != -1) { ActionCodeLst.Add(UseMinion(CardSn, MinionPos)); var minion = (Card.MinionCard)card; //初始化 minion.Init(); //必须在放入之前做得原因是,被放入的随从不能被触发这个事件 ActionCodeLst.AddRange(game.MySelf.RoleInfo.BattleField.触发事件( new Card.CardUtility.全局事件() { 事件类型 = CardUtility.事件类型列表.召唤, 附加信息 = minion.种族.ToString() }, game)); switch (minion.战吼类型) { case MinionCard.战吼类型列表.默认: game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); ActionCodeLst.AddRange(minion.发动战吼(game)); break; case MinionCard.战吼类型列表.抢先: //战吼中,其他 系列的法术效果 foreach (var result in minion.发动战吼(game)) { var resultArray = result.Split(CardUtility.strSplitMark.ToCharArray()); if (int.Parse(resultArray[2]) < MinionPos) { ActionCodeLst.Add(result); } else { ActionCodeLst.Add(resultArray[0] + CardUtility.strSplitMark + resultArray[1] + CardUtility.strSplitMark + (int.Parse(resultArray[2]) + 1).ToString() + CardUtility.strSplitMark + resultArray[3]); } } game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); break; case MinionCard.战吼类型列表.相邻: case MinionCard.战吼类型列表.自身: game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); game.MySelf.RoleInfo.BattleField.发动战吼(MinionPos); break; default: break; } game.MySelf.RoleInfo.BattleField.ResetBuff(); } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.武器: ActionCodeLst.Add(UseWeapon(CardSn)); game.MySelf.RoleInfo.Weapon = (Card.WeaponCard)card; break; case CardBasicInfo.CardTypeEnum.奥秘: ActionCodeLst.Add(UseSecret(CardSn)); game.MySelf.奥秘列表.Add((Card.SecretCard)card); game.MySelf.RoleInfo.SecretCount = game.MySelf.奥秘列表.Count; break; default: break; } //连击启动(法术的时候是修改法术内容) if (card.CardType != CardBasicInfo.CardTypeEnum.法术 && game.MySelf.RoleInfo.IsCombit) { if (!String.IsNullOrEmpty(card.连击效果)) { //初始化 Buff效果等等 Card.AbilityCard ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(card.连击效果); ablity.CardAbility.Init(); var ResultArg = game.UseAbility(ablity, ConvertPosDirect); if (ResultArg.Count != 0) { ActionCodeLst.AddRange(ResultArg); //英雄技能等的时候,不算[本方施法] if (CardSn.Substring(1, 1) == "0") { ActionCodeLst.AddRange(game.MySelf.RoleInfo.BattleField.触发事件(new Card.CardUtility.全局事件() { 事件类型 = CardUtility.事件类型列表.施法 }, game)); } } } } if (ActionCodeLst.Count != 0) { game.MySelf.RoleInfo.IsCombit = true; } return(ActionCodeLst); }
/// <summary> /// 开始一个动作 /// </summary> /// <param name="game"></param> /// <param name="CardSn"></param> /// <param name="ConvertPosDirect">亡语的时候,需要倒置方向</param> /// <returns></returns> public static List <String> StartAction(GameManager game, String CardSn, Boolean ConvertPosDirect = false) { Card.CardBasicInfo card = Card.CardUtility.GetCardInfoBySN(CardSn); List <String> ActionCodeLst = new List <string>(); switch (card.CardType) { case CardBasicInfo.CardTypeEnum.法术: ActionCodeLst.Add(UseAbility(CardSn)); //初始化 Buff效果等等 Card.AbilityCard ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(CardSn); ablity.CardAbility.Init(); var ResultArg = game.UseAbility(ablity, ConvertPosDirect); if (ResultArg.Count != 0) { ActionCodeLst.AddRange(ResultArg); //英雄技能的时候,不算[本方施法] A900001 幸运币 if (CardSn.Substring(1, 1) != "2") { ActionCodeLst.AddRange(game.MySelf.RoleInfo.BattleField.触发事件(MinionCard.事件类型列表.本方施法, game)); } } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.随从: int MinionPos = GetPutPos(game); if (MinionPos != -1) { ActionCodeLst.Add(UseMinion(CardSn, MinionPos)); var minion = (Card.MinionCard)card; //初始化 minion.Init(); switch (minion.战吼类型) { case MinionCard.战吼类型列表.默认: game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); ActionCodeLst.AddRange(minion.发动战吼(game)); break; case MinionCard.战吼类型列表.抢先: //战吼中,其他 系列的法术效果 foreach (var result in minion.发动战吼(game)) { var resultArray = result.Split(CardUtility.strSplitMark.ToCharArray()); if (int.Parse(resultArray[2]) < MinionPos) { ActionCodeLst.Add(result); } else { ActionCodeLst.Add(resultArray[0] + CardUtility.strSplitMark + resultArray[1] + CardUtility.strSplitMark + (int.Parse(resultArray[2]) + 1).ToString() + CardUtility.strSplitMark + resultArray[3]); } } game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); break; case MinionCard.战吼类型列表.相邻: case MinionCard.战吼类型列表.自身: game.MySelf.RoleInfo.BattleField.PutToBattle(MinionPos, minion); game.MySelf.RoleInfo.BattleField.发动战吼(MinionPos); break; default: break; } game.MySelf.RoleInfo.BattleField.ResetBuff(); } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.武器: ActionCodeLst.Add(UseWeapon(CardSn)); game.MySelf.RoleInfo.Weapon = (Card.WeaponCard)card; break; case CardBasicInfo.CardTypeEnum.奥秘: ActionCodeLst.Add(UseSecret(CardSn)); game.MySelf.奥秘列表.Add((Card.SecretCard)card); break; default: break; } return(ActionCodeLst); }
/// <summary> /// 运行效果 /// </summary> /// <param name="singleEffect"></param> /// <param name="game"></param> /// <param name="Seed"></param> /// <returns></returns> public List <string> RunEffect(ActionStatus game, CardUtility.目标选择方向枚举 Direct) { List <string> Result = new List <string>(); var MinionLst = 指定卡牌编号数组.Split(CardUtility.strSplitMark.ToCharArray()); Random random = new Random(DateTime.Now.Millisecond); var CardSN = MinionLst[random.Next(0, MinionLst.Length)]; var Minion = (MinionCard)CardUtility.GetCardInfoBySN(CardSN); switch (Direct) { case CardUtility.目标选择方向枚举.本方: if (game.AllRole.MyPublicInfo.BattleField.MinionCount < SystemManager.MaxMinionCount) { game.AllRole.MyPublicInfo.BattleField.AppendToBattle(Minion); //SUMMON#YOU#M000001#POS Result.Add(Server.ActionCode.strSummon + CardUtility.strSplitMark + CardUtility.strMe + CardUtility.strSplitMark + CardSN + CardUtility.strSplitMark + game.AllRole.MyPublicInfo.BattleField.MinionCount); game.battleEvenetHandler.事件池.Add(new EventCard.全局事件() { 触发事件类型 = EventCard.事件类型枚举.召唤, 触发位置 = Minion.战场位置 }); } break; case CardUtility.目标选择方向枚举.对方: if (game.AllRole.YourPublicInfo.BattleField.MinionCount < SystemManager.MaxMinionCount) { game.AllRole.YourPublicInfo.BattleField.AppendToBattle(Minion); Result.Add(Server.ActionCode.strSummon + CardUtility.strSplitMark + CardUtility.strYou + CardUtility.strSplitMark + CardSN + CardUtility.strSplitMark + game.AllRole.YourPublicInfo.BattleField.MinionCount); game.battleEvenetHandler.事件池.Add(new EventCard.全局事件() { 触发事件类型 = EventCard.事件类型枚举.召唤, 触发位置 = Minion.战场位置 }); } break; case CardUtility.目标选择方向枚举.双方: if (game.AllRole.MyPublicInfo.BattleField.MinionCount < SystemManager.MaxMinionCount) { game.AllRole.MyPublicInfo.BattleField.AppendToBattle(Minion); //SUMMON#YOU#M000001#POS Result.Add(Server.ActionCode.strSummon + CardUtility.strSplitMark + CardUtility.strMe + CardUtility.strSplitMark + CardSN + CardUtility.strSplitMark + game.AllRole.MyPublicInfo.BattleField.MinionCount); game.battleEvenetHandler.事件池.Add(new EventCard.全局事件() { 触发事件类型 = EventCard.事件类型枚举.召唤, 触发位置 = Minion.战场位置 }); } if (game.AllRole.MyPublicInfo.BattleField.MinionCount < SystemManager.MaxMinionCount) { game.AllRole.MyPublicInfo.BattleField.AppendToBattle(Minion); Result.Add(Server.ActionCode.strSummon + CardUtility.strSplitMark + CardUtility.strYou + CardUtility.strSplitMark + CardSN + CardUtility.strSplitMark + game.AllRole.MyPublicInfo.BattleField.MinionCount); game.battleEvenetHandler.事件池.Add(new EventCard.全局事件() { 触发事件类型 = EventCard.事件类型枚举.召唤, 触发位置 = Minion.战场位置 }); } break; } return(Result); }
/// <summary> /// 卡牌入战场 /// </summary> /// <param name="Position"></param> /// <param name="CardSn"></param> public void PutToBattle(int Position, string CardSn) { CardBasicInfo card = CardUtility.GetCardInfoBySN(CardSn); PutToBattle(Position, (MinionCard)card); }
/// <summary> /// 开始一个动作 /// </summary> /// <param name="game"></param> /// <param name="CardSn"></param> /// <param name="ConvertPosDirect">亡语的时候,需要倒置方向</param> /// <returns></returns> public static List <String> StartAction(GameManager game, String CardSn, Boolean ConvertPosDirect = false) { //清除事件池,注意,事件将在动作结束后整体结算 game.事件池.Clear(); Card.CardBasicInfo card = Card.CardUtility.GetCardInfoBySN(CardSn); List <String> ActionCodeLst = new List <string>(); switch (card.CardType) { case CardBasicInfo.CardTypeEnum.法术: ActionCodeLst.Add(ActionCode.strAbility + CardUtility.strSplitMark + CardSn); //初始化 Buff效果等等 Card.AbilityCard ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(CardSn); //连击效果的法术修改 if (game.MyInfo.连击状态 && (!String.IsNullOrEmpty(card.连击效果))) { ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(card.连击效果); } ablity.CardAbility.Init(); var ResultArg = game.UseAbility(ablity, ConvertPosDirect); if (ResultArg.Count != 0) { ActionCodeLst.AddRange(ResultArg); //英雄技能等的时候,不算[本方施法] if (CardSn.Substring(1, 1) == Card.AbilityCard.原生法术) { game.事件池.Add(new Card.CardUtility.全局事件() { 事件类型 = CardUtility.事件类型列表.施法, 触发方向 = CardUtility.TargetSelectDirectEnum.本方, 触发位置 = Card.Client.BattleFieldInfo.HeroPos }); } } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.随从: int MinionPos = 1; if (game.MyInfo.BattleField.MinionCount != 0) { MinionPos = GetPutPos(game); } if (MinionPos != -1) { ActionCodeLst.Add(ActionCode.strMinion + CardUtility.strSplitMark + CardSn + CardUtility.strSplitMark + MinionPos.ToString("D1")); var minion = (Card.MinionCard)card; //初始化 minion.Init(); //必须在放入之前做得原因是,被放入的随从不能被触发这个事件 game.事件池.Add(new Card.CardUtility.全局事件() { 事件类型 = CardUtility.事件类型列表.召唤, 附加信息 = minion.种族.ToString(), 触发位置 = MinionPos }); switch (minion.战吼类型) { case MinionCard.战吼类型列表.默认: game.MyInfo.BattleField.PutToBattle(MinionPos, minion); ActionCodeLst.AddRange(minion.发动战吼(game)); break; case MinionCard.战吼类型列表.抢先: //战吼中,其他 系列的法术效果 foreach (var result in minion.发动战吼(game)) { var resultArray = result.Split(CardUtility.strSplitMark.ToCharArray()); if (int.Parse(resultArray[2]) < MinionPos) { ActionCodeLst.Add(result); } else { ActionCodeLst.Add(resultArray[0] + CardUtility.strSplitMark + resultArray[1] + CardUtility.strSplitMark + (int.Parse(resultArray[2]) + 1).ToString() + CardUtility.strSplitMark + resultArray[3]); } } game.MyInfo.BattleField.PutToBattle(MinionPos, minion); break; case MinionCard.战吼类型列表.相邻: case MinionCard.战吼类型列表.自身: game.MyInfo.BattleField.PutToBattle(MinionPos, minion); game.MyInfo.BattleField.发动战吼(MinionPos); break; default: break; } game.MyInfo.BattleField.ResetBuff(); } else { ActionCodeLst.Clear(); } break; case CardBasicInfo.CardTypeEnum.武器: ActionCodeLst.Add(ActionCode.strWeapon + CardUtility.strSplitMark + CardSn); game.MyInfo.Weapon = (Card.WeaponCard)card; break; case CardBasicInfo.CardTypeEnum.奥秘: ActionCodeLst.Add(ActionCode.strSecret + CardUtility.strSplitMark + CardSn); game.MySelfInfo.奥秘列表.Add((Card.SecretCard)card); game.MyInfo.SecretCount = game.MySelfInfo.奥秘列表.Count; break; default: break; } //随从卡牌的连击效果启动 if (card.CardType != CardBasicInfo.CardTypeEnum.法术 && game.MyInfo.连击状态) { if (!String.IsNullOrEmpty(card.连击效果)) { //初始化 Buff效果等等 Card.AbilityCard ablity = (Card.AbilityCard)CardUtility.GetCardInfoBySN(card.连击效果); ablity.CardAbility.Init(); var ResultArg = game.UseAbility(ablity, ConvertPosDirect); if (ResultArg.Count != 0) { ActionCodeLst.AddRange(ResultArg); //英雄技能等的时候,不算[本方施法] if (CardSn.Substring(1, 1) == Card.AbilityCard.原生法术) { game.事件池.Add(new Card.CardUtility.全局事件() { 事件类型 = CardUtility.事件类型列表.施法, 触发方向 = CardUtility.TargetSelectDirectEnum.本方, 触发位置 = Card.Client.BattleFieldInfo.HeroPos }); } } } } if (ActionCodeLst.Count != 0) { game.MyInfo.连击状态 = true; ActionCodeLst.AddRange(game.事件处理()); } return(ActionCodeLst); }