/// <summary>
/// 可攻击目标列表的取得
/// </summary>
/// <param name="GameId"></param>
/// <param name="IsHost"></param>
/// <returns></returns>
public static string GetFightTargetList(int GameId, bool IsHost)
{
var gamestatus = GameRunning_BS[GameId].gameStatus(IsHost);
SelectUtility.SetTargetSelectEnable(SelectUtility.GetFightSelectOpt(), gamestatus);
return(SelectUtility.GetTargetListString(gamestatus));
}
public void OnSelect(SelectInfo selectInfo)
{
ISelectable[] selectionChanged;
//! 選択を反転
if (Keyboard.Modifiers == ModifierKeys.Control)
{
selectionChanged = SelectUtility.ToggleSelect(selectInfo.AllNodes.Concat(selectInfo.Connections), selectInfo.NewSelectNodes.Concat(selectInfo.NewConnections));
}
//! 追加選択
else if (Keyboard.Modifiers == ModifierKeys.Shift)
{
selectionChanged = SelectUtility.AddSelect(selectInfo.AllNodes.Concat(selectInfo.Connections), selectInfo.NewSelectNodes.Concat(selectInfo.NewConnections));
}
//! 選択されたものだけを選択するが、既に選択済みの場合は何もしない(Nodeをまとめてドラッグする際にこのモードを利用する)
else if (selectInfo.NewSelectNodes.Any())
{
selectionChanged = SelectUtility.SingleSelect(selectInfo.AllNodes.Concat(selectInfo.Connections), selectInfo.NewSelectNodes);
}
//! 選択されたものだけを選択状態とする
else
{
selectionChanged = SelectUtility.OnlySelect(selectInfo.AllNodes.Concat(selectInfo.Connections), selectInfo.NewConnections);
}
//! 選択が変更されたことをイベントで通知する(undo / redo 等に使用)
if (selectionChanged.Any())
{
SelectionChanged?.Execute(new SelectionChangedEventArgs(selectionChanged));
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TargetSelect_Load(object sender, EventArgs e)
{
SelectUtility.SetTargetSelectEnable(SelectOption, actionStatus);
int Megrate = 3;
btnMyHero.Hero = actionStatus.AllRole.MyPublicInfo.Hero;
btnYourHero.Hero = actionStatus.AllRole.YourPublicInfo.Hero;
int LeftPos = (Width - (actionStatus.AllRole.MyPublicInfo.BattleField.MinionCount * btnMe1.Width +
(actionStatus.AllRole.MyPublicInfo.BattleField.MinionCount - 1) * Megrate)) / 2;
for (int i = 0; i < actionStatus.AllRole.MyPublicInfo.BattleField.MinionCount; i++)
{
Controls.Find("btnMe" + (i + 1).ToString(), true)[0].Visible = actionStatus.AllRole.MyPublicInfo.BattleField.BattleMinions[i].能否成为动作对象;
((ctlCard)Controls.Find("btnMe" + (i + 1).ToString(), true)[0]).CardInfo = actionStatus.AllRole.MyPublicInfo.BattleField.BattleMinions[i];
Controls.Find("btnMe" + (i + 1).ToString(), true)[0].Left = LeftPos;
((ctlCard)Controls.Find("btnMe" + (i + 1).ToString(), true)[0]).FightClick += (x, y) =>
{
Position.本方对方标识 = true;
//这里千万不能使用 i ,每次 i 都是固定值
Position.位置 = int.Parse(((Button)x).Parent.Name.Substring("btnMe".Length));
Close();
};
LeftPos += btnMe1.Width + Megrate;
}
LeftPos = (Width - (actionStatus.AllRole.YourPublicInfo.BattleField.MinionCount * btnMe1.Width + (actionStatus.AllRole.YourPublicInfo.BattleField.MinionCount - 1) * Megrate)) / 2;
for (int i = 0; i < actionStatus.AllRole.YourPublicInfo.BattleField.MinionCount; i++)
{
Controls.Find("btnYou" + (i + 1).ToString(), true)[0].Visible = actionStatus.AllRole.YourPublicInfo.BattleField.BattleMinions[i].能否成为动作对象;
((ctlCard)Controls.Find("btnYou" + (i + 1).ToString(), true)[0]).CardInfo = actionStatus.AllRole.YourPublicInfo.BattleField.BattleMinions[i];
Controls.Find("btnYou" + (i + 1).ToString(), true)[0].Left = LeftPos;
((ctlCard)Controls.Find("btnYou" + (i + 1).ToString(), true)[0]).FightClick += (x, y) =>
{
Position.本方对方标识 = false;
//这里千万不能使用 i ,每次 i 都是固定值
//pos.Postion = i + 1;
Position.位置 = int.Parse(((Button)x).Parent.Name.Substring("btnYou".Length));
Close();
};
LeftPos += btnMe1.Width + Megrate;
}
btnMyHero.Enabled = actionStatus.AllRole.MyPublicInfo.Hero.能否成为动作对象;
btnMyHero.Left = (Width - btnMyHero.Width) / 2;
btnMyHero.Click += (x, y) =>
{
Position.本方对方标识 = true;
Position.位置 = 0;
Close();
};
btnYourHero.Enabled = actionStatus.AllRole.YourPublicInfo.Hero.能否成为动作对象;;
btnYourHero.Left = (Width - btnYourHero.Width) / 2;
btnYourHero.Click += (x, y) =>
{
Position.本方对方标识 = false;
Position.位置 = 0;
Close();
};
}
/// <summary>
/// 攻击
/// </summary>
/// <param name="MyPos"></param>
private void Fight(int MyPos)
{
GameManager.MyClientManager.CurrentActiveCard = GameManager.MyClientManager.actionStatus.AllRole.MyPublicInfo.BattleField.BattleMinions[MyPos - 1];
var YourPos = SelectPanel(SelectUtility.GetFightSelectOpt());
List <string> actionlst = RunAction.Fight(GameManager.MyClientManager.actionStatus, MyPos, YourPos.位置, true);
actionlst.AddRange(SecretCard.奥秘计算(actionlst, GameManager.MyClientManager.actionStatus, GameManager.MyClientManager.GameId));
GameManager.MyClientManager.actionStatus.AllRole.MyPrivateInfo.ResetHandCardCost(GameManager.MyClientManager.actionStatus);
if (SystemManager.游戏类型 != SystemManager.GameType.单机版)
{
ClientRequest.WriteAction(GameManager.MyClientManager.GameId.ToString(GameServer.GameIdFormat), actionlst);
}
DisplayMyInfo();
}
public void OnSelect()
{
var selectNodes = _panel.GetHitTestChildrenWithRect <NodeControl>(_rect).ToArray();
if (selectNodes.Any())
{
var changed = SelectUtility.OnlySelect(_nodes.OfType <ISelectable>().Concat(_connections), selectNodes);
SelectionChangedCommand?.Execute(new SelectionChangedEventArgs(changed));
return;
}
var selectConnections = _connections.Where(x => x.HitTestRect(_rect)).ToArray();
if (selectConnections.Any())
{
var changed = SelectUtility.OnlySelect(_nodes.OfType <ISelectable>().Concat(_connections), selectConnections);
SelectionChangedCommand?.Execute(new SelectionChangedEventArgs(changed));
}
}
/// <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="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="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="singleEffect"></param>
/// <param name="game"></param>
/// <param name="RandomSeed"></param>
/// <returns></returns>
public static List <string> RunSingleEffect(EffectDefine singleEffect, ActionStatus game, int RandomSeed)
{
List <string> Result = new List <string>();
List <string> PosList = SelectUtility.GetTargetList(singleEffect.AbliltyPosPicker, game, RandomSeed);
foreach (string PosInfo in PosList)
{
var PosField = PosInfo.Split(CardUtility.strSplitMark.ToCharArray());
var strResult = string.Empty;
if (PosField[0] == CardUtility.strMe)
{
switch (int.Parse(PosField[1]))
{
case BattleFieldInfo.HeroPos:
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strMe + CardUtility.strSplitMark + BattleFieldInfo.HeroPos.ToString("D1")).DealHero(game, game.AllRole.MyPublicInfo));
break;
case BattleFieldInfo.AllMinionPos:
for (int i = 0; i < game.AllRole.MyPublicInfo.BattleField.MinionCount; i++)
{
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strMe + CardUtility.strSplitMark + (i + 1).ToString("D1")).DealMinion(game, game.AllRole.MyPublicInfo.BattleField.BattleMinions[i]));
}
break;
case BattleFieldInfo.AllRolePos:
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strMe + CardUtility.strSplitMark + BattleFieldInfo.HeroPos.ToString("D1")).DealHero(game, game.AllRole.MyPublicInfo));
for (int i = 0; i < game.AllRole.MyPublicInfo.BattleField.MinionCount; i++)
{
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strMe + CardUtility.strSplitMark + (i + 1).ToString("D1")).DealMinion(game, game.AllRole.MyPublicInfo.BattleField.BattleMinions[i]));
}
break;
default:
Result.Add(GetEffectHandler(singleEffect, game, PosInfo).DealMinion(game, game.AllRole.MyPublicInfo.BattleField.BattleMinions[int.Parse(PosField[1]) - 1]));
break;
}
}
else
{
switch (int.Parse(PosField[1]))
{
case BattleFieldInfo.HeroPos:
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strYou + CardUtility.strSplitMark + BattleFieldInfo.HeroPos.ToString("D1")).DealHero(game, game.AllRole.YourPublicInfo));
break;
case BattleFieldInfo.AllMinionPos:
for (int i = 0; i < game.AllRole.YourPublicInfo.BattleField.MinionCount; i++)
{
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strYou + CardUtility.strSplitMark + (i + 1).ToString("D1")).DealMinion(game, game.AllRole.YourPublicInfo.BattleField.BattleMinions[i]));
}
break;
case BattleFieldInfo.AllRolePos:
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strYou + CardUtility.strSplitMark + BattleFieldInfo.HeroPos.ToString("D1")).DealHero(game, game.AllRole.YourPublicInfo));
for (int i = 0; i < game.AllRole.YourPublicInfo.BattleField.MinionCount; i++)
{
Result.Add(GetEffectHandler(singleEffect, game, CardUtility.strYou + CardUtility.strSplitMark + (i + 1).ToString("D1")).DealMinion(game, game.AllRole.YourPublicInfo.BattleField.BattleMinions[i]));
}
break;
default:
Result.Add(GetEffectHandler(singleEffect, game, PosInfo).DealMinion(game, game.AllRole.YourPublicInfo.BattleField.BattleMinions[int.Parse(PosField[1]) - 1]));
break;
}
}
}
return(Result);
}
