/// <summary>
/// 运行法术
/// </summary>
/// <param name="game"></param>
/// <param name="IsMyAction"></param>
/// <param name="Ability"></param>
/// <returns></returns>
public static List <string> RunAbility(ActionStatus game, AbilityDefine Ability)
{
List <string> Result = new List <string>();
//对象选择处理
if (Ability.MainAbilityDefine.AbliltyPosPicker.IsNeedTargetSelect())
{
//如果是BS的话，可以通过game的上下文数据获得位置信息
if (SystemManager.游戏类型 == SystemManager.GameType.HTML版)
{
//如果是随从卡牌的时候，这里是战吼的动作，战吼的动作的话，前面已经对于指定位置的设置了
if (game.ActionName == "USESPELLCARD")
{
Ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos = CardUtility.指定位置结构体.FromString(game.Interrupt.SessionDic["SPELLPOSITION"]);
}
}
else
{
Ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos = ActionStatus.GetSelectTarget(Ability.MainAbilityDefine.AbliltyPosPicker);
}
}
//取消处理
if (Ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos.位置 == Client.BattleFieldInfo.UnknowPos)
{
Result.Clear();
return(Result);
}
//法术伤害对于攻击型效果的加成
if (Ability.MainAbilityDefine.效果条件 == CardUtility.strIgnore && Ability.MainAbilityDefine.EffectCount > 1)
{
Ability.MainAbilityDefine.EffectCount += game.AllRole.MyPublicInfo.BattleField.AbilityDamagePlus;
}
//按照回数执行效果
for (int cnt = 0; cnt < Ability.MainAbilityDefine.EffectCount; cnt++)
{
//系统法术:有些法术的True和False是不同的类型
RunEffect(game, Ability.MainAbilityDefine, Result);
ActionStatus.RandomSeed++;
//是否每次结算？这里的逻辑需要确认！
Result.AddRange(ActionStatus.Settle(game));
}
//追加条件计算
if (Ability.AppendAbilityDefine == null || (!ExpressHandler.AppendAbilityCondition(game, Ability)))
{
return(Result);
}
//按照回数执行追加效果
//继承主效果的选定位置信息
Ability.AppendAbilityDefine.AbliltyPosPicker.SelectedPos = Ability.MainAbilityDefine.AbliltyPosPicker.SelectedPos;
for (int cnt = 0; cnt < Ability.AppendAbilityDefine.EffectCount; cnt++)
{
//系统法术
RunEffect(game, Ability.AppendAbilityDefine, Result);
ActionStatus.RandomSeed++;
Result.AddRange(ActionStatus.Settle(game));
}
return(Result);
}
/// <summary>
/// 对随从动作
/// </summary>
/// <param name="game"></param>
/// <param name="Minion"></param>
/// <returns></returns>
string IAtomicEffect.DealMinion(ActionStatus game, MinionCard Minion)
{
int HealthPoint = ExpressHandler.GetEffectPoint(game, 生命值回复表达式);
if (Minion.设置被治疗后状态(HealthPoint))
{
game.battleEvenetHandler.事件池.Add(new EventCard.全局事件()
{
触发事件类型 = EventCard.事件类型枚举.治疗,
触发位置 = Minion.战场位置
});
}
return(Server.ActionCode.strHealth + CardUtility.strSplitMark + Minion.战场位置.ToString() +
CardUtility.strSplitMark + HealthPoint.ToString());
}
/// <summary>
/// 对英雄动作
/// </summary>
/// <param name="game"></param>
/// <param name="PlayInfo"></param>
/// <returns></returns>
string IAtomicEffect.DealHero(ActionStatus game, Client.PublicInfo PlayInfo)
{
int ShieldPoint = ExpressHandler.GetEffectPoint(game, 护甲回复表达式);
int HealthPoint = ExpressHandler.GetEffectPoint(game, 生命值回复表达式);
PlayInfo.Hero.AfterBeShield(ShieldPoint);
if (PlayInfo.Hero.AfterBeHealth(HealthPoint))
{
game.battleEvenetHandler.事件池.Add(new EventCard.全局事件()
{
触发事件类型 = EventCard.事件类型枚举.治疗,
触发位置 = PlayInfo.Hero.战场位置
});
}
return(Server.ActionCode.strHealth + CardUtility.strSplitMark + PlayInfo.Hero.战场位置.ToString() + CardUtility.strSplitMark +
HealthPoint.ToString() + CardUtility.strSplitMark + ShieldPoint.ToString());
}
/// <summary>
/// 根据施法对象获得不同法术
/// </summary>
/// <param name="singleEffect"></param>
/// <param name="game"></param>
/// <param name="PosInfo"></param>
/// <returns></returns>
private static IAtomicEffect GetEffectHandler(EffectDefine singleEffect, ActionStatus game, string PosInfo)
{
AtomicEffectDefine atomic;
if (string.IsNullOrEmpty(singleEffect.效果条件) ||
singleEffect.效果条件 == CardUtility.strIgnore ||
ExpressHandler.AtomicEffectPickCondition(game, PosInfo, singleEffect))
{
atomic = singleEffect.TrueAtomicEffect;
}
else
{
atomic = singleEffect.FalseAtomicEffect;
}
IAtomicEffect IAtomic = new AttackEffect();
switch (atomic.AtomicEffectType)
{
case AtomicEffectDefine.AtomicEffectEnum.攻击:
IAtomic = new AttackEffect();
break;
case AtomicEffectDefine.AtomicEffectEnum.回复:
IAtomic = new HealthEffect();
break;
case AtomicEffectDefine.AtomicEffectEnum.状态:
IAtomic = new StatusEffect();
break;
case AtomicEffectDefine.AtomicEffectEnum.增益:
IAtomic = new PointEffect();
break;
case AtomicEffectDefine.AtomicEffectEnum.变形:
IAtomic = new TransformEffect();
break;
case AtomicEffectDefine.AtomicEffectEnum.召回:
IAtomic = new CallBackEffect();
break;
}
IAtomic.GetField(atomic.InfoArray);
return((IAtomicEffect)IAtomic);
}
/// <summary>
/// 对随从动作
/// </summary>
/// <param name="game"></param>
/// <param name="Minion"></param>
/// <returns></returns>
String IAtomicEffect.DealMinion(ActionStatus game, Card.MinionCard Minion)
{
int AttackPoint = ExpressHandler.GetEffectPoint(game, 伤害效果表达式);
//调整伤害值
if (伤害加成)
{
AttackPoint += game.AllRole.MyPublicInfo.BattleField.AbilityDamagePlus;
}
if (Minion.设置被攻击后状态(AttackPoint))
{
game.battleEvenetHandler.事件池.Add(new Engine.Card.EventCard.全局事件()
{
触发事件类型 = EventCard.事件类型枚举.受伤,
触发位置 = Minion.战场位置
});
}
return(Server.ActionCode.strAttack + CardUtility.strSplitMark + Minion.战场位置.ToString() + CardUtility.strSplitMark + AttackPoint.ToString());
}
/// <summary>
/// 对英雄动作
/// </summary>
/// <param name="game"></param>
/// <param name="PlayInfo"></param>
/// <returns></returns>
String IAtomicEffect.DealHero(ActionStatus game, Client.PublicInfo PlayInfo)
{
int AttackPoint = ExpressHandler.GetEffectPoint(game, 伤害效果表达式);
//调整伤害值
if (伤害加成)
{
AttackPoint += game.AllRole.MyPublicInfo.BattleField.AbilityDamagePlus;
}
if (PlayInfo.Hero.AfterBeAttack(AttackPoint))
{
game.battleEvenetHandler.事件池.Add(new EventCard.全局事件()
{
触发事件类型 = EventCard.事件类型枚举.受伤,
触发位置 = PlayInfo.Hero.战场位置
});
}
return(Server.ActionCode.strAttack + CardUtility.strSplitMark + PlayInfo.Hero.战场位置.ToString() + CardUtility.strSplitMark + AttackPoint.ToString());
}
/// <summary>
/// 使用法术
/// </summary>
/// <param name="game"></param>
/// <param name="IsMyAction">对象方向转换</param>
public List <string> UseSpell(ActionStatus game)
{
List <string> Result = new List <string>();
CardUtility.抉择枚举 PickAbilityResult = CardUtility.抉择枚举.第一效果;
switch (效果选择类型)
{
case 效果选择类型枚举.无需选择:
break;
case 效果选择类型枚举.主动选择:
PickAbilityResult = ActionStatus.PickEffect(FirstAbilityDefine.描述, SecondAbilityDefine.描述);
if (PickAbilityResult == CardUtility.抉择枚举.取消)
{
return(new List <string>());
}
break;
case 效果选择类型枚举.自动判定:
if (!ExpressHandler.AbilityPickCondition(game, 效果选择条件))
{
PickAbilityResult = CardUtility.抉择枚举.第二效果;
}
break;
default:
break;
}
List <EffectDefine> SingleEffectList = new List <EffectDefine>();
AbilityDefine ability;
if (PickAbilityResult == CardUtility.抉择枚举.第一效果)
{
ability = FirstAbilityDefine;
}
else
{
ability = SecondAbilityDefine;
}
Result.AddRange(RunAbility(game, ability));
return(Result);
}
/// <summary>
/// 对随从动作
/// </summary>
/// <param name="game"></param>
/// <param name="Minion"></param>
/// <returns></returns>
String IAtomicEffect.DealMinion(ActionStatus game, Card.MinionCard Minion)
{
int TurnCount = int.Parse(持续回合);
if (TurnCount == CardUtility.Max)
{
Minion.攻击力 = ExpressHandler.PointProcess(Minion.攻击力, 攻击力);
Minion.生命值 = ExpressHandler.PointProcess(Minion.生命值, 生命值);
Minion.生命值上限 = ExpressHandler.PointProcess(Minion.生命值上限, 生命值);
return(Server.ActionCode.strPoint + CardUtility.strSplitMark + Minion.战场位置.ToString() + CardUtility.strSplitMark +
Minion.攻击力.ToString() + CardUtility.strSplitMark + Minion.生命值.ToString() + CardUtility.strSplitMark + Minion.生命值上限.ToString());
}
else
{
//本回合攻击力翻倍的对应
Minion.本回合攻击力加成 = ExpressHandler.PointProcess(Minion.攻击力, 攻击力) - Minion.攻击力;
Minion.本回合生命力加成 = ExpressHandler.PointProcess(Minion.生命值上限, 生命值) - Minion.生命值上限;
return(Server.ActionCode.strPoint + CardUtility.strSplitMark + Minion.战场位置.ToString() + CardUtility.strSplitMark +
Minion.本回合攻击力加成.ToString() + CardUtility.strSplitMark + Minion.本回合生命力加成.ToString());
}
}
/// <summary>
/// 对法力水晶的法术实施
/// </summary>
/// <param name="role"></param>
/// <param name="Ability"></param>
public List <string> RunEffect(ActionStatus game, Utility.CardUtility.目标选择方向枚举 Direct)
{
List <string> Result = new List <string>();
switch (Direct)
{
case CardUtility.目标选择方向枚举.本方:
game.AllRole.MyPublicInfo.crystal.CurrentRemainPoint = ExpressHandler.PointProcess(game.AllRole.MyPublicInfo.crystal.CurrentRemainPoint, 获得法力水晶);
game.AllRole.MyPublicInfo.crystal.CurrentFullPoint = ExpressHandler.PointProcess(game.AllRole.MyPublicInfo.crystal.CurrentFullPoint, 获得空法力水晶);
break;
case CardUtility.目标选择方向枚举.对方:
game.AllRole.YourPublicInfo.crystal.CurrentRemainPoint = ExpressHandler.PointProcess(game.AllRole.YourPublicInfo.crystal.CurrentRemainPoint, 获得法力水晶);
game.AllRole.YourPublicInfo.crystal.CurrentFullPoint = ExpressHandler.PointProcess(game.AllRole.YourPublicInfo.crystal.CurrentFullPoint, 获得空法力水晶);
break;
case CardUtility.目标选择方向枚举.双方:
game.AllRole.MyPublicInfo.crystal.CurrentRemainPoint = ExpressHandler.PointProcess(game.AllRole.MyPublicInfo.crystal.CurrentRemainPoint, 获得法力水晶);
game.AllRole.MyPublicInfo.crystal.CurrentFullPoint = ExpressHandler.PointProcess(game.AllRole.MyPublicInfo.crystal.CurrentFullPoint, 获得空法力水晶);
game.AllRole.YourPublicInfo.crystal.CurrentRemainPoint = ExpressHandler.PointProcess(game.AllRole.YourPublicInfo.crystal.CurrentRemainPoint, 获得法力水晶);
game.AllRole.YourPublicInfo.crystal.CurrentFullPoint = ExpressHandler.PointProcess(game.AllRole.YourPublicInfo.crystal.CurrentFullPoint, 获得空法力水晶);
break;
default:
break;
}
//Crystal#ME#4#4
if (Direct == CardUtility.目标选择方向枚举.本方)
{
Result.Add(ActionCode.strCrystal + CardUtility.strSplitMark + CardUtility.strMe + CardUtility.strSplitMark +
game.AllRole.MyPublicInfo.crystal.CurrentRemainPoint + CardUtility.strSplitMark + game.AllRole.MyPublicInfo.crystal.CurrentFullPoint);
}
else
{
Result.Add(ActionCode.strCrystal + CardUtility.strSplitMark + CardUtility.strYou + CardUtility.strSplitMark +
game.AllRole.YourPublicInfo.crystal.CurrentRemainPoint + CardUtility.strSplitMark + game.AllRole.YourPublicInfo.crystal.CurrentFullPoint);
}
return(Result);
}
/// <summary>
/// 获得效果信息
/// </summary>
/// <param name="InfoArray"></param>
void IAtomicEffect.GetField(List <string> InfoArray)
{
伤害效果表达式 = InfoArray[0];
伤害加成 = ExpressHandler.GetBooleanExpress(InfoArray[1]);
}
/// <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;
}
public ExpressApplication Delete(RegExp pathPattern, ExpressChainedHandler[] chainedHandlers, ExpressHandler handler)
{
return(null);
}
public ExpressApplication Delete(string path, ExpressChainedHandler[] chainedHandlers, ExpressHandler handler)
{
return(null);
}
public ExpressApplication Delete(string path, ExpressHandler handler)
{
return(null);
}
public ExpressApplication All(RegExp pathPattern, ExpressHandler handler)
{
return(null);
}
public ExpressApplication Options(string path, ExpressHandler handler)
{
return(null);
}
