/// <summary>
/// 获得卡牌信息
/// </summary>
/// <param name="CardSn"></param>
/// <returns></returns>
public static String GetCardInfo(String CardSn)
{
StringBuilder Status = new StringBuilder();
if (Card.CardUtility.GetCardInfoBySN(CardSn) != null)
{
Card.CardBasicInfo info = Card.CardUtility.GetCardInfoBySN(CardSn);
Status.AppendLine("==============");
Status.AppendLine("Description" + info.Description);
Status.AppendLine("StandardCostPoint" + info.StandardCostPoint);
Status.AppendLine("Type：" + info.CardType.ToString());
switch (CardSn.Substring(0, 1))
{
case "A":
break;
case "M":
Status.AppendLine("标准攻击力：" + ((Card.MinionCard)info).StandardAttackPoint.ToString());
Status.AppendLine("标准生命值：" + ((Card.MinionCard)info).标准生命值上限.ToString());
break;
case "W":
Status.AppendLine("标准攻击力：" + ((Card.WeaponCard)info).StandardAttackPoint.ToString());
Status.AppendLine("标准耐久度：" + ((Card.WeaponCard)info).标准耐久度.ToString());
break;
default:
break;
}
Status.AppendLine("==============");
}
return(Status.ToString());
}
/// <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>
/// <param name="Position"></param>
/// <param name="CardSn"></param>
public void PutToBattle(int Position, String CardSn)
{
Card.CardBasicInfo card = 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);
}
/// <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="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);
}
