//弹出一个指定窗口
public void Popup(ViewBaseView view)
{
if (view == null)
{
return;
}
bool err = true;
for (int i = views.Count - 1; i >= 0; --i)
{
if (views[i].GetInstanceID() == view.GetInstanceID())
{
views.RemoveAt(i);
PopupSingleView(view);
err = false;
break;
}
}
if (err)
{
UtilityLog.LogError(string.Format("Popup view failed. Can not find {0} in {1}", view.config.viewName, UIViewLayer));
return;
}
//刷新最大order
RefreshTopOrder();
}
//根据名称获取配置
private UIViewConfig GetConfig(UIViewName viewName)
{
if (uiViewConfig.ContainsKey(viewName) == false)
{
UtilityLog.LogError(string.Format("Get view config error: {0}", viewName));
return(null);
}
return(uiViewConfig[viewName]);
}
//获取指定玩家的信息
public PlayerItem getPlayerByPlayerCode(string playerCode)
{
PlayerItem returnItem = playerGroup.playerItems[playerCode];
if (returnItem == null)
{
UtilityLog.LogError("玩家信息为空");
}
return(returnItem);
}
//根据code获取一张卡信息
public CardInfo GetCardInfoByCode(string cardCode)
{
CardInfo cardInfo = cardDbItem.cardInfoMap[cardCode];
if (cardInfo == null)
{
UtilityLog.LogError("the card [" + cardCode + "]is null");
}
return(cardInfo);
}
public void AskTheUserOperating(EffectInfo effectInfo,
PlayerGroupProxy playerGroupProxy,
QuestStageCircuitProxy questStageCircuitProxy,
EffectInfoProxy effectInfoProxy,
GameContainerProxy gameContainerProxy)
{
effectInfo.effectInfoStage = EffectInfoStage.AskTheUser;
if (effectInfo.effectType == "Independent")
{
}
else if (effectInfo.effectType == "BeforeAndAfter")
{
//遍历每一个前置效果
foreach (EffectInfo preEffect in effectInfo.preEffectEntryList)
{
if (preEffect.effectInfoStage == EffectInfoStage.AskTheUser ||
preEffect.effectInfoStage == EffectInfoStage.ConfirmedTarget)
{
preEffect.effectInfoStage = EffectInfoStage.AskTheUser;
preEffect.checkCanExecution = true;
bool checkOver = EffectExecution(preEffect, EffectExeType.Check, gameContainerProxy);
if (!checkOver)
{
preEffect.checkCanExecution = false;
UtilityLog.Log(preEffect.code + ":检查为不能释放", LogUtType.Special);
}
//判断是否是必发
if (preEffect.mustBeLaunched == "N")
{
//不是必发，需要用户判断
effectInfo.needChoosePreEffect = preEffect;
//发送已经确认目标的效果到前台进行展示
CardEntry oneCardEntry = effectInfo.cardEntry;
oneCardEntry.needShowEffectInfo = effectInfo;
effectInfoProxy.effectSysItem.showEffectNum++;
SendNotification(UIViewSystemEvent.UI_EFFECT_DISPLAY_SYS, oneCardEntry, UIViewSystemEvent.UI_EFFECT_DISPLAY_SYS_ONE_EFFECT_NEED_CHOOSE_EXE);
return;
}
else
{
preEffect.effectInfoStage = EffectInfoStage.AskTheUserOver;
}
}
else
{
UtilityLog.LogError("逻辑错误：不应出现【用户判断】阶段前不是【宾语目标寻找结束】阶段");
}
}
}
effectInfo.effectInfoStage = EffectInfoStage.AskTheUserOver;
}
//读取玩家信息
public void LoadPlayerInfo()
{
if (playerItem == null)
{
UtilityLog.LogError("playerItem is null");
}
if (playerItem.shipCard != null)
{
LoadShipCard(playerItem.shipCard);
}
// LoadCardList(playerItem.cardDeck);
}
//从拼接的字符串中获取转发的NotificationName
public static string GeNotificationNameForNN(string str)
{
string[] sArray = Regex.Split(str, "=>", RegexOptions.IgnoreCase);
if (sArray.Length > 1)
{
return(sArray[1]);
}
else
{
UtilityLog.LogError("转发失败");
return("");
}
}
//删除一个状态
public void DeleteFSMState(FSMBaseState state)
{
if (state == null)
{
UtilityLog.LogError("状态为空");
return;
}
if (!stateDictionary.ContainsKey(state.name))
{
UtilityLog.LogError("状态在状态机中不存在");
return;
}
stateDictionary.Remove(state.name);
}
//获取N张随机牌池的牌
public List <CardEntry> GetSameCardEntry(int num)
{
if (num > cardDbItem.cardEntryPool.Count)
{
UtilityLog.LogError("need card number too much");
return(null);
}
List <int> randomList = RandomUtil.GetRandom(0, cardDbItem.cardEntryPool.Count - 1, num, false);
List <CardEntry> cardEntries = new List <CardEntry>();
foreach (int i in randomList)
{
cardEntries.Add(cardDbItem.cardEntryPool[i]);
}
return(cardEntries);
}
//展示界面
public void ShowView(UIViewName viewName, params object[] args)
{
//获取界面配置
UIViewConfig config = GetConfig(viewName);
if (config == null)
{
return;
}
ViewBaseView view = null;
if (config.unique)
{
//判断是否打开了
for (int i = 0; i < viewList.Count; ++i)
{
if (viewList[i].config.viewName == viewName)
{
view = viewList[i];
break;
}
}
//判断是否已被打开，没有打开个新的
if (view != null)
{
if (view.layerController == null)
{
UtilityLog.LogError(string.Format("Show view error: {0}, not layer", viewName));
return;
}
//设置参数，重新放入窗口层级控制器
// view.SetArguments(args);
view.layerController.Push(view);
}
else
{
ShowViewFromCacheOrCreateNew(config, args);
}
}
else
{
ShowViewFromCacheOrCreateNew(config, args);
}
//刷新显示、隐藏状态
UpdateViewHideState();
}
public void Action(FSMBaseSys fSMBaseSys)
{
//检测状态是否存在
if (!fSMBaseSys.CheckFSMState(from) || !fSMBaseSys.CheckFSMState(to))
{
UtilityLog.LogError("状态在状态机中不存在");
return;
}
if (fSMBaseSys.nowState.name != from.name)
{
UtilityLog.LogError("开始状态错误");
return;
}
fSMBaseSys.nowState.EndState();
fSMBaseSys.nowState = from;
fSMBaseSys.nowState.StartState();
}
//打开一个新的
private ViewBaseView ShowNewView(UIViewConfig config)
{
if (!UIControllerViews.ContainsKey(config.viewLayer))
{
UtilityLog.LogError("Show new view failed. Layer error.");
return(null);
}
//加载
ViewBaseView view = CreateUIView(config);
if (view)
{
//创建完毕，初始化
view.Init();
view.transform.SetParent(UIControllerViews[config.viewLayer].transform, false);
view.GetComponent <RectTransform>().Normalize();
}
return(view);
}
//根据指定牌添加生物
public void AddOneMinionByCard(HexCoordinates index, CardEntry cardEntry)
{
//判断这个坐标上是否已经有生物存在
if (CheckHasCardEntryByGameContainerTypeAndHexCoordinates("CardBattlefield", index) != null)
{
UtilityLog.LogError("该位置已存在生物");
return;
}
cardEntry.dtoType = "Minion";
cardEntry.IsEffectTarget = false;
cardEntry.nowIndex = index;
cardEntry.cardEntryVariableAttributeMap.CreateVariableAttributeByOriginalValueAndCodeAndBetterAndAutoRestore("Atk", cardEntry.atk, true);
cardEntry.cardEntryVariableAttributeMap.CreateVariableAttributeByOriginalValueAndCodeAndBetterAndAutoRestore("Def", cardEntry.def, true);
AddTimeTrigger(cardEntry);
SendNotification(MinionSystemEvent.MINION_VIEW, cardEntry, MinionSystemEvent.MINION_VIEW_ADD_ONE_MINION);
}
//先尝试从缓存中打开，如果失败则打开一个新的
private void ShowViewFromCacheOrCreateNew(UIViewConfig config, params object[] args)
{
//先尝试从缓存区中读取
ViewBaseView view = GetViewFromCache(config);
//缓存区内没有，打开新的
if (view == null)
{
view = ShowNewView(config);
}
if (view != null)
{
PushViewToLayer(view, args);
}
else
{
UtilityLog.LogError(string.Format("Show view failed -> {0}", config.viewName));
}
}
//录入事件前需要先录入状态
public void AddFSMEvent(FSMEvent fSMEvent)
{
if (fSMEvent == null)
{
UtilityLog.LogError("事件为空");
return;
}
//检测状态是否存在
if (!CheckFSMState(fSMEvent.from) || !CheckFSMState(fSMEvent.to))
{
UtilityLog.LogError("事件状态在状态机中不存在");
return;
}
if (eventDictionary.ContainsKey(fSMEvent.code))
{
UtilityLog.LogError("事件在状态机中已存在");
return;
}
eventDictionary.Add(fSMEvent.code, fSMEvent);
}
//根据指定界面
public void HideView(ViewBaseView view)
{
if (view == null)
{
return;
}
//在窗口栈中的界面都可以关闭
if (view.layerController != null)
{
viewList.Remove(view);
view.layerController.Popup(view);
SchemeViewCache(view);
UpdateViewHideState();
}
else
{
UtilityLog.LogError(string.Format("Attamp to hide a error view {0}, not in controller.", view.config.viewName));
}
}
//添加一个状态
public void AddFSMState(FSMBaseState state)
{
if (state == null)
{
UtilityLog.LogError("状态为空");
return;
}
if (nowState == null)
{
//状态运行
nowState = state;
nowState.StartState();
}
if (stateDictionary.ContainsKey(state.name))
{
UtilityLog.LogError("状态在状态机中已存在");
return;
}
stateDictionary.Add(state.name, state);
}
//移除一张手牌的实例
public void RemoveOneHandCellItem(CardEntry cardEntry)
{
int index = -1;
for (int i = 0; i < this.handCells.Count; i++)
{
if (this.handCells[i].uuid == cardEntry.uuid)
{
index = i;
break;
}
}
if (index < 0)
{
UtilityLog.LogError("This handCellItem index" + cardEntry.locationIndex + "is not exist");
}
else
{
this.handCells.RemoveAt(index);
}
}
//读入界面
private ViewBaseView CreateUIView(UIViewConfig config)
{
GameObject obj = null;
obj = UnityEditor.AssetDatabase.LoadAssetAtPath <GameObject>(string.Format("Assets/Resources/Prefabs/UIView/{0}.prefab", config.assetName));
if (obj != null)
{
obj = Instantiate(obj);
}
if (obj)
{
var viewBase = obj.GetComponent <ViewBaseView>();
return(viewBase);
}
else
{
UtilityLog.LogError(string.Format("Load view error: no view : {0}", config.assetName));
return(null);
}
}
//增加玩家
public void AddPlayer(string playerCode, PlayerType playerType)
{
PlayerItem playerItem = null;
if (playerType == PlayerType.HumanPlayer)
{
playerItem = playerGroup.AddHumanPlayer(playerCode);
}
else if (playerType == PlayerType.AIPlayer)
{
playerItem = playerGroup.AddAIPlayer(playerCode);
}
if (playerItem == null)
{
UtilityLog.LogError("玩家创建失败");
}
else
{
AddTimeTrigger(playerItem);
}
}
//移除一张手牌的实例
public void RemoveOneCardEntry(CardEntry cardEntry)
{
int index = -1;
for (int i = 0; i < this.cardEntryList.Count; i++)
{
if (this.cardEntryList[i].uuid == cardEntry.uuid)
{
index = i;
break;
}
}
if (index < 0)
{
UtilityLog.LogError("This handCellItem index" + cardEntry.locationIndex + "is not exist");
}
else
{
cardEntry.lastGameContainerType = this.gameContainerType;
this.cardEntryList.RemoveAt(index);
}
}
public TraitType getTraitTypeByString(string traitName)
{
TraitType traitType = TraitType.error;
if (traitName == "supremcy")
{
traitType = TraitType.supremcy;
}
else if (traitName == "innovation")
{
traitType = TraitType.innovation;
}
else if (traitName == "polymorphism")
{
traitType = TraitType.polymorphism;
}
if (traitType == TraitType.error)
{
UtilityLog.LogError("找不到对应的科技类型");
}
return(traitType);
}
//被压入到窗口栈中
public virtual void OnPush()
{
ViewState = UIViewState.Nonvisible;
if (!canvas.overrideSorting)
{
canvas.overrideSorting = true;
}
switch (config.viewLayer)
{
case UIViewLayer.Background:
canvas.sortingLayerID = UIVIewMetrics.SortingLayer_UI_Background;
break;
case UIViewLayer.Base:
canvas.sortingLayerID = UIVIewMetrics.SortingLayer_UI_Base;
break;
case UIViewLayer.Popup:
canvas.sortingLayerID = UIVIewMetrics.SortingLayer_UI_Popup;
break;
case UIViewLayer.Top:
canvas.sortingLayerID = UIVIewMetrics.SortingLayer_UI_Top;
break;
case UIViewLayer.Debug:
canvas.sortingLayerID = UIVIewMetrics.SortingLayer_UI_Debug;
break;
default:
UtilityLog.LogError(string.Format("Set Layer And Order failed: Error layer -> {0}", config.viewLayer));
break;
}
}
public override void Execute(INotification notification)
{
OperateSystemProxy operateSystemProxy =
Facade.RetrieveProxy(OperateSystemProxy.NAME) as OperateSystemProxy;
QuestStageCircuitProxy questStageCircuitProxy =
Facade.RetrieveProxy(QuestStageCircuitProxy.NAME) as QuestStageCircuitProxy;
PlayerGroupProxy playerGroupProxy =
Facade.RetrieveProxy(PlayerGroupProxy.NAME) as PlayerGroupProxy;
CardDbProxy cardDbProxy =
Facade.RetrieveProxy(CardDbProxy.NAME) as CardDbProxy;
EffectInfoProxy effectInfoProxy =
Facade.RetrieveProxy(EffectInfoProxy.NAME) as EffectInfoProxy;
GameModelProxy gameModelProxy =
Facade.RetrieveProxy(GameModelProxy.NAME) as GameModelProxy;
GameContainerProxy gameContainerProxy =
Facade.RetrieveProxy(GameContainerProxy.NAME) as GameContainerProxy;
HexGridProxy hexGridProxy =
Facade.RetrieveProxy(HexGridProxy.NAME) as HexGridProxy;
//获取当前操作玩家
string playerCode = questStageCircuitProxy.GetNowHaveStagePlayerCode();
if (playerCode == null)
{
return;
}
PlayerItem playerItem = playerGroupProxy.getPlayerByPlayerCode(playerCode);
CardEntry chooseHand = operateSystemProxy.operateSystemItem.onChooseCardEntry;
switch (notification.Type)
{
//判断手牌是否可用
case OperateSystemEvent.OPERATE_SYS_HAND_CAN_USE_JUDGE:
string playerCodeHandCanUseJudge = notification.Body as string;
PlayerItem playerItemHandCanUseJudge = playerGroupProxy.playerGroup.playerItems[playerCodeHandCanUseJudge];
GameContainerItem gameContainerItem = gameContainerProxy.GetGameContainerItemByPlayerItemAndGameContainerType(playerItemHandCanUseJudge, "CardHand");
gameContainerItem.ChangeHandCardCanUse(questStageCircuitProxy.circuitItem);
SendNotification(HandSystemEvent.HAND_CHANGE, gameContainerItem.cardEntryList, StringUtil.GetNTByNotificationTypeAndPlayerCode(HandSystemEvent.HAND_CHANGE_CAN_USE_JUDGE, playerCode));
break;
//选中战场上一个生物
case OperateSystemEvent.OPERATE_SYS_POINTER_DOWN_ONE_MINION:
CardEntry downMinionCard = notification.Body as CardEntry;
operateSystemProxy.IntoModeByType(downMinionCard, playerItem, OperateSystemItem.OperateType.MinionControling);
//渲染可移动区域
SendNotification(HexSystemEvent.HEX_VIEW_SYS, operateSystemProxy.operateSystemItem, HexSystemEvent.HEX_VIEW_RENDER_CAN_MOVE_AND_ATK);
//消息通知-划线组件激活
SendNotification(OperateSystemEvent.OPERATE_TRAIL_DRAW, null, OperateSystemEvent.OPERATE_TRAIL_DRAW_START);
break;
//选中手牌
case OperateSystemEvent.OPERATE_SYS_HAND_CHOOSE:
CardEntry handCellItem = notification.Body as CardEntry;
operateSystemProxy.IntoModeByType(handCellItem, playerItem, OperateSystemItem.OperateType.HandUse);
switch (handCellItem.WhichCard)
{
case CardEntry.CardType.MinionCard:
//渲染可召唤区域
SendNotification(HexSystemEvent.HEX_VIEW_SYS, operateSystemProxy.operateSystemItem, HexSystemEvent.HEX_VIEW_RENDER_CAN_CALL);
break;
case CardEntry.CardType.TacticsCard:
//渲染可释放
//获取效果信息
//判断是否存在用于渲染的目标效果
if (handCellItem.cardInfo.targetSetToChooseList != null)
{
foreach (string targetSetToChooseCode in handCellItem.cardInfo.targetSetToChooseList)
{
TargetSet targetSetToChoose = effectInfoProxy.GetDepthCloneTargetSetByName(targetSetToChooseCode);
foreach (TargetClaim targetClaim in targetSetToChoose.targetClaims)
{
if (targetClaim.claim == "Owner")
{
if (targetClaim.content == "Myself")
{
targetClaim.result.Add(playerItem.playerCode);
}
}
}
if (targetSetToChoose.target == "Minion")
{
//传入效果，根据效果目标进行筛选渲染
SendNotification(MinionSystemEvent.MINION_SYS, targetSetToChoose, MinionSystemEvent.MINION_SYS_EFFECT_HIGHLIGHT);
}
}
}
break;
}
break;
//划线结束选择了战场
case OperateSystemEvent.OPERATE_SYS_DRAW_END_HEX:
HexCellItem hexCellItem = notification.Body as HexCellItem;
HexCoordinates index = hexCellItem.coordinates;
//通知战场层去除渲染
SendNotification(HexSystemEvent.HEX_VIEW_SYS, null, HexSystemEvent.HEX_VIEW_RENDER_CAN_CALL_CANCEL);
//判断状态
if (operateSystemProxy.operateSystemItem.operateModeType == OperateSystemItem.OperateType.HandUse)
{
UtilityLog.Log("玩家【" + playerCode + "】尝试操作手牌，手牌种类为【" + chooseHand.WhichCard + "】", LogUtType.Operate);
//如果成功释放了，还需要去除掉目标渲染
bool checkUseSuccess = false;
string targetType = "Null";
switch (chooseHand.WhichCard)
{
case CardEntry.CardType.ResourceCard:
UtilityLog.Log("玩家【" + playerCode + "】进行操作手牌，手牌种类为【" + chooseHand.WhichCard + "】", LogUtType.Operate);
checkUseSuccess = true;
//执行卡牌
//SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, chooseHand, EffectExecutionEvent.EFFECT_EXECUTION_SYS_EXE_CARD);
break;
case CardEntry.CardType.MinionCard:
//检查是否可用释放
bool canUse = playerItem.CheckOneCardCanUse(chooseHand, questStageCircuitProxy.circuitItem);
bool canCall = playerItem.CheckOneCellCanCall(hexCellItem.coordinates);
//检查所选格子是否可用召唤
if (canUse && canCall)
{
checkUseSuccess = true;
chooseHand.nowIndex = index;
}
else
{
SendNotification(OperateSystemEvent.OPERATE_SYS, null, OperateSystemEvent.OPERATE_SYS_DRAW_END_NULL);
}
break;
case CardEntry.CardType.TacticsCard:
//如果存在目标，则需要先选择目标再释放
if (chooseHand.cardInfo.targetSetToChooseList != null)
{
bool hasTarget = false;
foreach (string targetSetToChooseCode in chooseHand.cardInfo.targetSetToChooseList)
{
TargetSet targetSetToChoose = effectInfoProxy.GetDepthCloneTargetSetByName(targetSetToChooseCode);
if (targetSetToChoose.target == "Minion")
{
targetType = "Minion";
//判断格子上是否有生物
CardEntry minionCellItem = gameContainerProxy.CheckHasCardEntryByGameContainerTypeAndHexCoordinates("CardBattlefield", index);
if (minionCellItem != null)
{
//检查是否满足效果释放条件
if (targetSetToChoose.checkEffectToTargetMinionCellItem(minionCellItem))
{
//确认目标
chooseHand.targetBasicGameDto = minionCellItem;
hasTarget = true;
}
}
}
}
if (hasTarget)
{
checkUseSuccess = true;
}
}
//如果不需要选择目标或者需要选择多个目标则先执行
else
{
checkUseSuccess = true;
}
break;
}
if (checkUseSuccess)
{
//减少费用-预先减少
playerItem.ChangeManaUsableByUseHand(chooseHand);
chooseHand.nextGameContainerType = "CardIsReleasing";
chooseHand.ttNeedChangeGameContainerType(chooseHand);
//减少费用-预先减少
playerItem.ChangeManaUsableByUseHand(chooseHand);
if (targetType == "Minion")
{
//取消渲染
SendNotification(MinionSystemEvent.MINION_SYS, null, MinionSystemEvent.MINION_SYS_EFFECT_HIGHLIGHT_CLOSE);
}
//执行卡牌
SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, chooseHand, EffectExecutionEvent.EFFECT_EXECUTION_SYS_EXE_CARD);
}
}
else if (operateSystemProxy.operateSystemItem.operateModeType == OperateSystemItem.OperateType.MinionControling)
{
UtilityLog.Log("玩家【" + playerCode + "】尝试操作生物", LogUtType.Special);
if (operateSystemProxy.operateSystemItem.onChooseCardEntry.canBeMovedCellMap.ContainsKey(index))
{
HexCellItem endHexCellItem = operateSystemProxy.operateSystemItem.onChooseCardEntry.canBeMovedCellMap[index];
List <HexCellItem> cellRoute = new List <HexCellItem>();
cellRoute.Add(endHexCellItem);
bool isOver = false;
while (!isOver)
{
if (endHexCellItem.pathfindingLastCell.coordinates.X == operateSystemProxy.operateSystemItem.onChooseCardEntry.nowIndex.X &&
endHexCellItem.pathfindingLastCell.coordinates.Z == operateSystemProxy.operateSystemItem.onChooseCardEntry.nowIndex.Z)
{
isOver = true;
}
else
{
cellRoute.Add(endHexCellItem.pathfindingLastCell);
endHexCellItem = endHexCellItem.pathfindingLastCell;
}
}
//路径是倒的，需要换成正序的
List <HexCellItem> positiveCellRoute = new List <HexCellItem>();
for (int n = cellRoute.Count - 1; n > -1; n--)
{
positiveCellRoute.Add(cellRoute[n]);
}
operateSystemProxy.operateSystemItem.onChooseCardEntry.cellRoute = positiveCellRoute;
effectInfoProxy.effectSysItem.showEffectNum++;
operateSystemProxy.operateSystemItem.onChooseCardEntry.MoveToTargetHexCoordinates(index);
}
}
break;
case OperateSystemEvent.OPERATE_SYS_HAND_CHOOSE_EXE_OVER:
//如果是战术，资源牌，放入墓地
if (chooseHand.WhichCard == CardEntry.CardType.ResourceCard || chooseHand.WhichCard == CardEntry.CardType.TacticsCard)
{
//在墓地添加手牌
chooseHand.nextGameContainerType = "CardGraveyard";
chooseHand.ttNeedChangeGameContainerType(chooseHand);
}
else if (chooseHand.WhichCard == CardEntry.CardType.MinionCard)
{
gameContainerProxy.AddOneMinionByCard(chooseHand.nowIndex, chooseHand);
chooseHand.nextGameContainerType = "CardBattlefield";
chooseHand.ttNeedChangeGameContainerType(chooseHand);
}
//移除手牌
playerItem.RemoveOneCardByUse(chooseHand);
UtilityLog.Log("手牌【" + chooseHand.name + "】使用完毕：", LogUtType.Operate);
//结束，改变模式为初始，清除手牌
operateSystemProxy.IntoModeClose();
break;
case OperateSystemEvent.OPERATE_SYS_DRAW_END_NULL:
//什么都没选
switch (operateSystemProxy.operateSystemItem.operateModeType)
{
//手牌使用状态
case OperateSystemItem.OperateType.HandUse:
//手牌回复原位
SendNotification(HandSystemEvent.HAND_CHANGE, chooseHand, StringUtil.GetNTByNotificationTypeAndPlayerCode(HandSystemEvent.HAND_CHANGE_UNCHECK_STATUS, playerItem.playerCode));
switch (chooseHand.WhichCard)
{
case CardEntry.CardType.MinionCard:
//通知战场层取消渲染
SendNotification(HexSystemEvent.HEX_VIEW_SYS, null, HexSystemEvent.HEX_VIEW_RENDER_CAN_CALL_CANCEL);
operateSystemProxy.IntoModeClose();
break;
case CardEntry.CardType.TacticsCard:
EffectInfo effectInfo = effectInfoProxy.GetDepthCloneEffectByName(chooseHand.cardInfo.effectCodeList[0]);
foreach (TargetSet targetSet in effectInfo.operationalTarget.selectTargetList)
{
if (targetSet.target == "Minion")
{
//取消渲染
SendNotification(MinionSystemEvent.MINION_SYS, effectInfo, MinionSystemEvent.MINION_SYS_EFFECT_HIGHLIGHT_CLOSE);
}
}
break;
}
break;
}
break;
//选择一个生物作为某次选择的结果
case OperateSystemEvent.OPERATE_SYS_CHOOSE_ONE_MINION:
CardEntry oneChooseMinionCellItem = notification.Body as CardEntry;
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
EffectInfo effect = effectInfoProxy.effectSysItem.effectInfos[n];
if (effect.effectInfoStage == EffectInfoStage.ConfirmingTarget)
{
//遍历每一个前置效果
foreach (EffectInfo preEffect in effect.preEffectEntryList)
{
if (preEffect.effectInfoStage == EffectInfoStage.ConfirmingTarget)
{
preEffect.effectInfoStage = EffectInfoStage.ConfirmedTarget;
preEffect.needPlayerToChooseTargetSet.targetMinionCellItems.Add(oneChooseMinionCellItem);
break;
}
}
//遍历每一个后置效果
foreach (EffectInfo postEffect in effect.postEffectEntryList)
{
if (postEffect.effectInfoStage == EffectInfoStage.ConfirmingTarget)
{
postEffect.effectInfoStage = EffectInfoStage.ConfirmedTarget;
postEffect.needPlayerToChooseTargetSet.targetMinionCellItems.Add(oneChooseMinionCellItem);
break;
}
}
effectInfoProxy.effectSysItem.showEffectNum--;
//返回继续执行效果选择的信号
SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, null, EffectExecutionEvent.EFFECT_EXECUTION_SYS_FIND_TARGET);
}
}
break;
//选择一个效果的某一个选项
case OperateSystemEvent.OPERATE_SYS_CHOOSE_ONE_USER_SELECTION_ITEM:
OneUserSelectionItem oneUserSelectionItem = notification.Body as OneUserSelectionItem;
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
EffectInfo effect = effectInfoProxy.effectSysItem.effectInfos[n];
if (effect.effectInfoStage == EffectInfoStage.AskTheUser)
{
//遍历每一个前置效果
foreach (EffectInfo preEffect in effect.preEffectEntryList)
{
if (preEffect.effectInfoStage == EffectInfoStage.AskTheUser)
{
preEffect.userChooseExecution = oneUserSelectionItem.isExecute;
preEffect.effectInfoStage = EffectInfoStage.AskTheUserOver;
UtilityLog.Log("收到前台的反馈并修改了", LogUtType.Special);
break;
}
}
effect.effectInfoStage = EffectInfoStage.AskTheUserOver;
effectInfoProxy.effectSysItem.showEffectNum--;
//返回继续执行效果选择的信号
SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, null, EffectExecutionEvent.EFFECT_EXECUTION_SYS_ASK_THE_USER);
}
}
break;
//选择一个效果类型，选择了目标
case OperateSystemEvent.OPERATE_SYS_CHOOSE_ONE_EFFECT:
CardEntry effectCard = notification.Body as CardEntry;
//逻辑上可以确定只能有一个效果字段？
if (effectCard.effectCodeList.Length > 1)
{
UtilityLog.LogError("this chooseEffect has many Effect");
}
EffectInfo chooseEffect = effectInfoProxy.GetDepthCloneEffectByName(effectCard.effectCodeList[0]);
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
EffectInfo effect = effectInfoProxy.effectSysItem.effectInfos[n];
if (effect.effectInfoStage == EffectInfoStage.ConfirmingTarget)
{
foreach (TargetSet targetSet in effect.operationalTarget.selectTargetList)
{
if (targetSet.target == "ChooseEffect")
{
//确认目标
targetSet.targetEffectInfos.Add(chooseEffect);
//设置为确认完毕
effect.effectInfoStage = EffectInfoStage.ConfirmedTarget;
//添加新效果
//设置状态
chooseEffect.effectInfoStage = EffectInfoStage.UnStart;
//设置所有者,手牌操作模式，所有者是当前玩家
chooseEffect.player = playerItem;
//设置所属卡牌
chooseEffect.cardEntry = chooseHand;
//将这个效果添加到队列中
effectInfoProxy.effectSysItem.effectInfos.Add(chooseEffect);
//返回一个选择完毕的信号
SendNotification(
UIViewSystemEvent.UI_VIEW_CURRENT,
UIViewConfig.getNameStrByUIViewName(UIViewName.ChooseStage),
StringUtil.GetNTByNotificationTypeAndUIViewNameAndMaskLayer(
UIViewSystemEvent.UI_VIEW_CURRENT_CLOSE_ONE_VIEW,
UIViewConfig.getNameStrByUIViewName(UIViewName.ChooseStage),
"N"
)
);
//返回继续执行效果选择的信号
SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, null, EffectExecutionEvent.EFFECT_EXECUTION_SYS_FIND_TARGET);
return;
}
else
{
UtilityLog.LogError("this effectType is not ChooseEffect");
}
}
}
}
break;
//打开了墓地
case OperateSystemEvent.OPERATE_SYS_GRAVEYARD_LIST_LOAD:
string playerCodeOpenGraveyard = notification.Body as string;
PlayerItem playerItemOpenGraveyard = playerGroupProxy.getPlayerByPlayerCode(playerCodeOpenGraveyard);
//获取墓地的牌，并发送给前台
SendNotification(
UIViewSystemEvent.UI_VIEW_CURRENT,
gameContainerProxy.GetGameContainerItemByPlayerItemAndGameContainerType(playerItemOpenGraveyard, "CardGraveyard"),
StringUtil.GetNTByNotificationTypeAndUIViewNameAndMaskLayer(
UIViewSystemEvent.UI_VIEW_CURRENT_OPEN_ONE_VIEW,
UIViewConfig.getNameStrByUIViewName(UIViewName.GraveyardListView),
"Y"
)
);
break;
}
}
public bool FindTargetOrObejct(EffectInfo effectInfo, TargetSet targetSet,
EffectInfoProxy effectInfoProxy,
PlayerGroupProxy playerGroupProxy,
QuestStageCircuitProxy questStageCircuitProxy,
GameContainerProxy gameContainerProxy)
{
bool designationTargetOver = false;
effectInfo.needPlayerToChooseTargetSet = targetSet;
//先判断是否已经指定了目标
switch (targetSet.target)
{
case "Minion":
if (targetSet.targetMinionCellItems.Count == targetSet.targetClaimsNums)
{
designationTargetOver = true;
}
break;
}
if (designationTargetOver)
{
targetSet.hasTarget = true;
return(true);
}
//条件
TargetClaim[] targetClaims = targetSet.targetClaims;
//目标玩家
PlayerItem targetPlayer = null;
//类型
switch (targetSet.target)
{
case "Card":
List <CardEntry> cardEntries = new List <CardEntry>();
string gameContainerType = targetSet.targetSource;
PlayerItem gameContainerControllerPlayerItem = null;
for (int n = 0; n < targetClaims.Length; n++)
{
//判断所有权
if (targetClaims[n].claim == "Owner")
{
//是自己选
if (targetClaims[n].content == "Myself")
{
gameContainerControllerPlayerItem = effectInfo.player;
}
}
}
GameContainerItem gameContainerItem = gameContainerProxy.GetGameContainerItemByPlayerItemAndGameContainerType(gameContainerControllerPlayerItem, gameContainerType);
for (int n = 0; n < targetClaims.Length; n++)
{
//判断所有权
if (targetClaims[n].claim == "locationIndex")
{
cardEntries.Add(gameContainerItem.cardEntryList[Convert.ToInt32(targetClaims[n].content)]);
}
else if (targetClaims[n].claim == "CardCode")
{
CardEntry cardEntryByCode = gameContainerItem.GetOneCardByCardCode(targetClaims[n].content);
if (cardEntryByCode != null)
{
cardEntries.Add(cardEntryByCode);
}
}
}
if (cardEntries.Count > 0)
{
if (targetSet.targetClaimsNums == 1)
{
targetSet.hasTarget = true;
targetSet.targetCardEntries.Add(cardEntries[0]);
}
}
break;
case "Minion":
List <CardEntry> minionCellItems = new List <CardEntry>();
List <GameContainerItem> returnGameContainerItemList = gameContainerProxy.GetGameContainerItemGameContainerType("CardBattlefield");
foreach (GameContainerItem gameContainerItemMinion in returnGameContainerItemList)
{
foreach (CardEntry minionCellItem in gameContainerItemMinion.cardEntryList)
{
for (int n = 0; n < targetClaims.Length; n++)
{
//判断所有权
if (targetClaims[n].claim == "Owner")
{
//是自己的
if (targetClaims[n].content == "Myself")
{
targetClaims[n].result.Add(effectInfo.player.playerCode);
if (minionCellItem.controllerPlayerItem.playerCode == effectInfo.player.playerCode)
{
minionCellItems.Add(minionCellItem);
}
}
//不是自己的
else if (targetClaims[n].content == "Enemy")
{
targetClaims[n].result.Add(effectInfo.player.playerCode);
if (minionCellItem.controllerPlayerItem.playerCode != effectInfo.player.playerCode)
{
minionCellItems.Add(minionCellItem);
}
}
}
}
}
}
if (minionCellItems.Count <= targetSet.targetClaimsNums)
{
//符合数量限制
targetSet.hasTarget = true;
targetSet.targetMinionCellItems = minionCellItems;
}
else
{
//超出目标上限，需要用户选择
if (effectInfo.operationalTarget.whoOperate == "MyselfPlayer")
{
effectInfo.chooseByPlayer = effectInfo.player;
//发送已经确认目标的效果到前台进行展示
CardEntry oneCardEntry = effectInfo.cardEntry;
oneCardEntry.needShowEffectInfo = effectInfo;
effectInfoProxy.effectSysItem.showEffectNum++;
SendNotification(UIViewSystemEvent.UI_EFFECT_DISPLAY_SYS, oneCardEntry, UIViewSystemEvent.UI_EFFECT_DISPLAY_SYS_ONE_EFFECT_NEED_CHOOSE_TARGET);
//发布用户需要选择信号
SendNotification(LogicalSysEvent.LOGICAL_SYS, effectInfo, LogicalSysEvent.LOGICAL_SYS_NEED_PLAYER_CHOOSE);
}
else
{
UtilityLog.LogError("找不到需要选择的用户");
}
return(false);
}
break;
//效果选择
case "ChooseEffect":
//获取玩家，根据条件筛选出复合条件的释放者和选择者
//筛选结果
foreach (PlayerItem playerItem in playerGroupProxy.playerGroup.playerItems.Values)
{
for (int n = 0; n < targetClaims.Length; n++)
{
//判断所有权
if (targetClaims[n].claim == "Owner")
{
//是自己选
if (targetClaims[n].content == "Myself")
{
if (playerItem.playerCode == effectInfo.player.playerCode)
{
targetPlayer = playerItem;
}
}
}
}
}
if (targetPlayer != null)
{
effectInfo.chooseByPlayer = targetPlayer;
//发布用户需要选择信号
SendNotification(LogicalSysEvent.LOGICAL_SYS, effectInfo, LogicalSysEvent.LOGICAL_SYS_NEED_PLAYER_CHOOSE);
return(false);
//
}
else
{
UtilityLog.LogError("no player can ChooseEffect");
}
break;
//玩家
case "Player":
//获取玩家，根据条件筛选出复合条件的释放者和选择者
//筛选结果
foreach (PlayerItem playerItem in playerGroupProxy.playerGroup.playerItems.Values)
{
for (int n = 0; n < targetClaims.Length; n++)
{
//判断所有权
if (targetClaims[n].claim == "Owner")
{
//是自己选
if (targetClaims[n].content == "Myself")
{
if (playerItem.playerCode == effectInfo.player.playerCode)
{
targetPlayer = playerItem;
}
}
}
}
}
if (targetPlayer != null)
{
//玩家确认
targetSet.targetPlayerItems.Add(targetPlayer);
targetSet.hasTarget = true;
}
else
{
UtilityLog.LogError("no player can add TargetPlayerItems");
}
break;
}
return(true);
}
public override void Execute(INotification notification)
{
EffectInfoProxy effectInfoProxy =
Facade.RetrieveProxy(EffectInfoProxy.NAME) as EffectInfoProxy;
PlayerGroupProxy playerGroupProxy =
Facade.RetrieveProxy(PlayerGroupProxy.NAME) as PlayerGroupProxy;
OperateSystemProxy operateSystemProxy =
Facade.RetrieveProxy(OperateSystemProxy.NAME) as OperateSystemProxy;
QuestStageCircuitProxy questStageCircuitProxy =
Facade.RetrieveProxy(QuestStageCircuitProxy.NAME) as QuestStageCircuitProxy;
GameContainerProxy gameContainerProxy =
Facade.RetrieveProxy(GameContainerProxy.NAME) as GameContainerProxy;
//待执行的卡牌
CardEntry exeEffectCard = null;
switch (notification.Type)
{
//执行一张卡
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_EXE_CARD:
exeEffectCard = notification.Body as CardEntry;
operateSystemProxy.IntoModeByType(exeEffectCard, exeEffectCard.controllerPlayerItem, OperateSystemItem.OperateType.CardIsReleasing);
//提取待执行的卡牌效果
List <EffectInfo> oneExeEffectCardEffects = new List <EffectInfo>();
//遍历卡牌的效果
foreach (string effectCode in exeEffectCard.effectCodeList)
{
EffectInfo oneEffectInfo = effectInfoProxy.GetDepthCloneEffectByName(effectCode);
if (oneEffectInfo.impactTimeTriggers == null)
{
//设置状态
oneEffectInfo.effectInfoStage = EffectInfoStage.UnStart;
//设置所有者,手牌操作模式，所有者是当前玩家
oneEffectInfo.player = exeEffectCard.controllerPlayerItem;
//设置所属卡牌
oneEffectInfo.cardEntry = exeEffectCard;
//是否有预先选定的目标对象
if (exeEffectCard.targetBasicGameDto != null)
{
if (exeEffectCard.targetBasicGameDto.dtoType == "Minion")
{
foreach (TargetSet targetSet in oneEffectInfo.operationalTarget.selectTargetList)
{
if (targetSet.target == "Minion")
{
targetSet.targetMinionCellItems.Add(exeEffectCard.targetBasicGameDto as CardEntry);
}
}
}
}
oneExeEffectCardEffects.Add(oneEffectInfo);
}
}
//存入效果，进行结算
effectInfoProxy.IntoModeCardSettle(exeEffectCard, oneExeEffectCardEffects);
break;
//执行一张已经触发效果的卡
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_EXE_TRIGGERED_CARD:
exeEffectCard = notification.Body as CardEntry;
//提取待执行的卡牌效果
List <EffectInfo> oneTriggeredEffectCardEffects = new List <EffectInfo>();
oneTriggeredEffectCardEffects.Add(exeEffectCard.triggeredEffectInfo);
effectInfoProxy.IntoModeCardSettle(exeEffectCard, oneTriggeredEffectCardEffects);
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_FIND_TARGET:
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
EffectInfo effect = effectInfoProxy.effectSysItem.effectInfos[n];
if (effect.effectType == "Independent")
{
bool hasTarget = ExecutionEffectFindTarget(effect, effectInfoProxy, playerGroupProxy, questStageCircuitProxy, gameContainerProxy);
//没能正确的寻找到目标，防止循环继续执行下去导致效果执行两边，直接返回
if (!hasTarget)
{
return;
}
}
else if (effect.effectType == "BeforeAndAfter")
{
bool allHasTarget = ExecutionEffectFindTargetForBeforeAndAfter(effect, playerGroupProxy, questStageCircuitProxy, effectInfoProxy, gameContainerProxy);
if (!allHasTarget)
{
return;
}
}
}
//判断是否所有效果都存在了目标
bool allEffectHasTarget = true;
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
if (effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage == EffectInfoStage.UnStart ||
effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage == EffectInfoStage.ConfirmingTarget)
{
allEffectHasTarget = false;
}
}
//询问是否需要用户操作
if (allEffectHasTarget)
{
SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, null, EffectExecutionEvent.EFFECT_EXECUTION_SYS_ASK_THE_USER);
}
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_ASK_THE_USER:
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
EffectInfo effect = effectInfoProxy.effectSysItem.effectInfos[n];
if (effect.effectInfoStage == EffectInfoStage.ConfirmedTarget)
{
AskTheUserOperating(effect,
playerGroupProxy,
questStageCircuitProxy,
effectInfoProxy,
gameContainerProxy
);
}
}
//判断是否所有效果都进行了用户选择
bool allEffectHasUserSelect = true;
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
if (effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage == EffectInfoStage.UnStart ||
effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage == EffectInfoStage.ConfirmingTarget ||
effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage == EffectInfoStage.ConfirmedTarget ||
effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage == EffectInfoStage.AskTheUser
)
{
allEffectHasUserSelect = false;
}
}
if (allEffectHasUserSelect)
{
//执行效果
SendNotification(EffectExecutionEvent.EFFECT_EXECUTION_SYS, null, EffectExecutionEvent.EFFECT_EXECUTION_SYS_EXE_EFFECT);
}
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_EFFECT_SHOW_OVER:
effectInfoProxy.effectSysItem.showEffectNum--;
if (effectInfoProxy.effectSysItem.effectSysItemStage == EffectSysItemStage.UnStart)
{
if (effectInfoProxy.effectSysItem.cardEntryQueue.Count == 0)
{
if (effectInfoProxy.effectSysItem.showEffectNum == 0)
{
UtilityLog.Log("所有效果展示完毕" + System.Guid.NewGuid().ToString("N"), LogUtType.Effect);
//通知回合控制器当前堆叠已经全部执行完毕
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_NEED_CHECK_END_STAGE_STATE);
}
}
}
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_MINION_BUFF_NEED_REMOVE:
CardEntry needRemoveBuffMinionCellItem = notification.Body as CardEntry;
UtilityLog.Log("生物【" + needRemoveBuffMinionCellItem.name + "】的buff需要被清除", LogUtType.Effect);
foreach (EffectInfo oneEffectInfoBuffCheck in needRemoveBuffMinionCellItem.effectBuffInfoList)
{
if (oneEffectInfoBuffCheck.effectiveTime.ContinuousRound == 0)
{
//提取待执行的卡牌效果
List <EffectInfo> oneBuffCleanEffectCardEffects = new List <EffectInfo>();
UtilityLog.Log("生物【" + needRemoveBuffMinionCellItem.name + "】的buff【" + oneEffectInfoBuffCheck.code + "】需要被清除", LogUtType.Special);
EffectInfo oneReverseEffectInfo = effectInfoProxy.GetDepthCloneEffectByName(oneEffectInfoBuffCheck.code);
foreach (TargetSet targetSet in oneReverseEffectInfo.operationalTarget.selectTargetList)
{
targetSet.targetMinionCellItems.Add(needRemoveBuffMinionCellItem);
}
oneReverseEffectInfo.effectInfoStage = EffectInfoStage.ConfirmedTarget;
oneReverseEffectInfo.whetherToshow = "N";
oneReverseEffectInfo.isReverse = true;
CardEntry cardEntry = new CardEntry();
cardEntry.name = "BuffClean";
cardEntry.controllerPlayerItem = needRemoveBuffMinionCellItem.controllerPlayerItem;
oneReverseEffectInfo.cardEntry = cardEntry;
oneBuffCleanEffectCardEffects.Add(oneReverseEffectInfo);
effectInfoProxy.IntoModeCardSettle(cardEntry, oneBuffCleanEffectCardEffects);
}
}
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_EXE_EFFECT:
ExecutionEffectContentList(effectInfoProxy, gameContainerProxy);
//判断是否所有效果都执行完毕了
bool allEffectHasFinished = true;
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
if (effectInfoProxy.effectSysItem.effectInfos[n].effectInfoStage != EffectInfoStage.Finished)
{
allEffectHasFinished = false;
}
}
if (allEffectHasFinished)
{
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
if (effectInfoProxy.effectSysItem.effectInfos[n].impactTimeTriggertMonitorListWhenOver != null)
{
//把效果结算完毕的时点都发送出去
foreach (string impactTimeTriggertMonitor in effectInfoProxy.effectSysItem.effectInfos[n].impactTimeTriggertMonitorListWhenOver)
{
SendNotification(TimeTriggerEvent.TIME_TRIGGER_SYS, null, StringUtil.GetNTByNotificationTypeAndPlayerCode(impactTimeTriggertMonitor, effectInfoProxy.effectSysItem.effectInfos[n].player.playerCode));
}
}
}
//判断这一组效果是不是都是一张卡的，逻辑上来说都是一张卡
CardEntry cardCheck = new CardEntry();
bool cardCheckOver = true;
for (int n = 0; n < effectInfoProxy.effectSysItem.effectInfos.Count; n++)
{
if (n == 0)
{
cardCheck = effectInfoProxy.effectSysItem.effectInfos[n].cardEntry;
}
else
{
if (effectInfoProxy.effectSysItem.effectInfos[n].cardEntry.uuid != cardCheck.uuid)
{
cardCheckOver = false;
break;
}
else
{
cardCheck = effectInfoProxy.effectSysItem.effectInfos[n].cardEntry;
}
}
}
if (effectInfoProxy.effectSysItem.effectInfos.Count == 0)
{
cardCheck = effectInfoProxy.effectSysItem.cardEntry;
}
if (!cardCheckOver)
{
UtilityLog.LogError("同一个效果组来源多余一个实体");
}
else
{
if (cardCheck.lastGameContainerType == "CardHand")
{
SendNotification(OperateSystemEvent.OPERATE_SYS, null, OperateSystemEvent.OPERATE_SYS_HAND_CHOOSE_EXE_OVER);
}
}
//执行下一组效果
effectInfoProxy.effectSysItem.effectSysItemStage = EffectSysItemStage.UnStart;
//通知时点触发器这一组效果执行完毕了
SendNotification(TimeTriggerEvent.TIME_TRIGGER_SYS, null, TimeTriggerEvent.TIME_TRIGGER_EXE_NEXT_DELAY_NOTIFICATION);
effectInfoProxy.ExeEffectQueue();
}
else
{
UtilityLog.LogError("效果执行失败");
}
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_LAUNCH_AN_ATTACK:
CardEntry attackMinionCellItem = notification.Body as CardEntry;
PlayerItem playerItemAttack = attackMinionCellItem.controllerPlayerItem;
HexCoordinates vectorHexCoordinates = new HexCoordinates(playerItemAttack.playerSiteOne.attackDefaultDirection.x, playerItemAttack.playerSiteOne.attackDefaultDirection.z);
HexCoordinates targetHexCoordinates = HexUtil.GetTargetHexCoordinatesByStartPointAndVector(attackMinionCellItem.nowIndex, vectorHexCoordinates);
CardEntry defensiveMinionCellItem = gameContainerProxy.CheckHasCardEntryByGameContainerTypeAndHexCoordinates("CardBattlefield", targetHexCoordinates);
//判断目标单元格上有没有生物
if (defensiveMinionCellItem != null)
{
//如果有生物，需要再判断是自己的生物还是对手的生物
if (defensiveMinionCellItem.controllerPlayerItem != attackMinionCellItem.controllerPlayerItem)
{
UtilityLog.Log("【" + attackMinionCellItem.name + "】进行攻击", LogUtType.Attack);
//攻击
effectInfoProxy.effectSysItem.showEffectNum++;
attackMinionCellItem.AttackTargetMinion(defensiveMinionCellItem);
//反击
effectInfoProxy.effectSysItem.showEffectNum++;
defensiveMinionCellItem.CounterAttackTargetMinion(attackMinionCellItem);
}
}
break;
case EffectExecutionEvent.EFFECT_EXECUTION_SYS_LAUNCH_AN_MOVE:
CardEntry moveMinionCellItem = notification.Body as CardEntry;
PlayerItem playerItemMove = moveMinionCellItem.controllerPlayerItem;
HexCoordinates vectorHexCoordinatesMove = new HexCoordinates(playerItemMove.playerSiteOne.attackDefaultDirection.x, playerItemMove.playerSiteOne.attackDefaultDirection.z);
HexCoordinates targetMoveHexCoordinates = HexUtil.GetTargetHexCoordinatesByStartPointAndVector(moveMinionCellItem.nowIndex, vectorHexCoordinatesMove);
//判断目标单元格是否在可移动范围内
if (playerItemMove.CheckOneHexCanMove(targetMoveHexCoordinates))
{
CardEntry moveHexCoordinatesCard = gameContainerProxy.CheckHasCardEntryByGameContainerTypeAndHexCoordinates("CardBattlefield", targetMoveHexCoordinates);
//判断目标单元格上有没有生物,没有生物才能移动
if (moveHexCoordinatesCard == null)
{
effectInfoProxy.effectSysItem.showEffectNum++;
moveMinionCellItem.MoveToTargetHexCoordinates(targetMoveHexCoordinates);
}
}
break;
//case EffectExecutionEvent.EFFECT_EXECUTION_SYS_MINION_ENTER_THE_BATTLEFIELD:
// CardEntry enterTBFMinionCellItem = notification.Body as CardEntry;
// exeEffectCard = enterTBFMinionCellItem;
// 提取待执行的卡牌效果
// List<EffectInfo> oneMinionEffectCardEffects = new List<EffectInfo>();
// 遍历卡牌的效果
// foreach (string effectCode in exeEffectCard.effectCodeList)
// {
// EffectInfo oneEffectInfo = effectInfoProxy.GetDepthCloneEffectByName(effectCode);
// bool canExe = false;
// foreach (string impactTimeTrigger in oneEffectInfo.impactTimeTriggers) {
// if (impactTimeTrigger == "MyselfEnterTheBattlefield") {
// canExe = true;
// break;
// }
// }
// if (canExe) {
// 设置状态
// oneEffectInfo.effectInfoStage = EffectInfoStage.UnStart;
// 设置所有者,手牌操作模式，所有者是当前玩家
// oneEffectInfo.player = exeEffectCard.controllerPlayerItem;
// 设置所属卡牌
// oneEffectInfo.cardEntry = exeEffectCard;
// oneMinionEffectCardEffects.Add(oneEffectInfo);
// }
// }
// 存入效果，进行结算
// effectInfoProxy.IntoModeCardSettle(exeEffectCard, oneMinionEffectCardEffects);
// break;
}
}
public override void Execute(INotification notification)
{
QuestStageCircuitProxy questStageCircuitProxy =
Facade.RetrieveProxy(QuestStageCircuitProxy.NAME) as QuestStageCircuitProxy;
EffectInfoProxy effectInfoProxy =
Facade.RetrieveProxy(EffectInfoProxy.NAME) as EffectInfoProxy;
OperateSystemProxy operateSystemProxy =
Facade.RetrieveProxy(OperateSystemProxy.NAME) as OperateSystemProxy;
//获取当前回合玩家
PlayerGroupProxy playerGroupProxy =
Facade.RetrieveProxy(PlayerGroupProxy.NAME) as PlayerGroupProxy;
PlayerItem turnHavePlayerItem = playerGroupProxy.getPlayerByPlayerCode(questStageCircuitProxy.GetNowHaveTurnPlayerCode());
switch (notification.Type)
{
//开始一个回合
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_START_OF_TRUN:
questStageCircuitProxy.circuitItem.turnNum++;
UtilityLog.Log("玩家【" + turnHavePlayerItem.playerCode + "】第【" + questStageCircuitProxy.circuitItem.turnNum + "】回合开始", LogUtType.Stage);
questStageCircuitProxy.circuitItem.oneTurnStage = questStageCircuitProxy.circuitItem.questOneTurnStageList[0];
//开始一个阶段
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_START_OF_STAGE);
break;
//从指定阶段开始回合
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_ASSIGN_START_OF_TRUN:
GM_OneStageSite oneStageSite = questStageCircuitProxy.circuitItem.getOneStageSiteByStageCode("ActivePhase");
if (oneStageSite != null)
{
questStageCircuitProxy.circuitItem.oneTurnStage = oneStageSite;
questStageCircuitProxy.circuitItem.turnNum++;
UtilityLog.Log("一个回合从指定阶段开始", LogUtType.Stage);
}
else
{
UtilityLog.LogError("找不到指定阶段的配置信息");
}
//开始一个阶段
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_START_OF_STAGE);
break;
//结束一个回合
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_END_OF_TRUN:
UtilityLog.Log("玩家【" + turnHavePlayerItem.playerCode + "】第【" + questStageCircuitProxy.circuitItem.turnNum + "】回合结束", LogUtType.Stage);
questStageCircuitProxy.IntoNextTurn();
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_START_OF_TRUN);
break;
//开始一个阶段
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_START_OF_STAGE:
questStageCircuitProxy.circuitItem.autoNextStage = true;
if (questStageCircuitProxy.circuitItem.oneTurnStage.operatingPlayer == "Myself")
{
questStageCircuitProxy.SetNowHaveStagePlayerCode(questStageCircuitProxy.GetNowHaveTurnPlayerCode());
}
else if (questStageCircuitProxy.circuitItem.oneTurnStage.operatingPlayer == "Enemy")
{
questStageCircuitProxy.SetNowHaveStagePlayerCode(playerGroupProxy.getEnemytPlayerByPlayerCode(questStageCircuitProxy.GetNowHaveTurnPlayerCode()).playerCode);
}
questStageCircuitProxy.circuitItem.questTurnStageState = QuestTurnStageState.StartOfState;
UtilityLog.Log("第【" + questStageCircuitProxy.circuitItem.turnNum + "】回合" + "开始一个阶段【" + questStageCircuitProxy.circuitItem.oneTurnStage.name + "】", LogUtType.Stage);
SendNotification(UIViewSystemEvent.UI_TURN_STAGE_SYS, questStageCircuitProxy.circuitItem, UIViewSystemEvent.UI_TURN_STAGE_SYS_STAGE_CHANGE);
effectInfoProxy.effectSysItem.showEffectNum++;
questStageCircuitProxy.circuitItem.oneStageStartAction(turnHavePlayerItem);
if (questStageCircuitProxy.circuitItem.autoNextStage)
{
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_NEED_CHECK_END_STAGE_STATE);
}
break;
//执行一个阶段
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_EXECUTION_OF_STAGE:
PlayerItem stageHavePlayerItemForExe = playerGroupProxy.getPlayerByPlayerCode(questStageCircuitProxy.GetNowHaveStagePlayerCode());
stageHavePlayerItemForExe.ttPlayerHandCanUseJudge();
questStageCircuitProxy.circuitItem.autoNextStage = true;
questStageCircuitProxy.circuitItem.questTurnStageState = QuestTurnStageState.ExecutionOfState;
UtilityLog.Log("第【" + questStageCircuitProxy.circuitItem.turnNum + "】回合" + "执行一个阶段【" + questStageCircuitProxy.circuitItem.oneTurnStage.name + "】", LogUtType.Stage);
questStageCircuitProxy.circuitItem.oneStageExecutionAction(turnHavePlayerItem);
if (questStageCircuitProxy.circuitItem.oneTurnStage.automatic == "N")
{
questStageCircuitProxy.circuitItem.autoNextStage = false;
//判断当前玩家的种类
//AI玩家
if (stageHavePlayerItemForExe.playerType == PlayerType.AIPlayer)
{
//切入到AI逻辑操作
SendNotification(LogicalSysEvent.LOGICAL_SYS, null, LogicalSysEvent.LOGICAL_SYS_ACTIVE_PHASE_ACTION);
}
//人类玩家
else if (stageHavePlayerItemForExe.playerType == PlayerType.HumanPlayer)
{
//显示结束阶段按钮
SendNotification(UIViewSystemEvent.UI_NEXT_TURN_SHOW_SYS, null, StringUtil.GetNTByNotificationTypeAndPlayerCode(UIViewSystemEvent.UI_NEXT_TURN_SHOW_SYS_SHOW, stageHavePlayerItemForExe.playerCode));
}
//直接返回
return;
}
if (questStageCircuitProxy.circuitItem.autoNextStage)
{
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_NEED_CHECK_END_STAGE_STATE);
}
break;
//结束一个阶段
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_END_OF_STAGE:
questStageCircuitProxy.circuitItem.questTurnStageState = QuestTurnStageState.EndOfState;
UtilityLog.Log("第【" + questStageCircuitProxy.circuitItem.turnNum + "】回合" + "结束一个阶段【" + questStageCircuitProxy.circuitItem.oneTurnStage.name + "】", LogUtType.Stage);
questStageCircuitProxy.circuitItem.oneStageEndAction(turnHavePlayerItem);
int nowStageIndex = questStageCircuitProxy.circuitItem.questOneTurnStageList.IndexOf(questStageCircuitProxy.circuitItem.oneTurnStage);
if (nowStageIndex < questStageCircuitProxy.circuitItem.questOneTurnStageList.Count - 1)
{
questStageCircuitProxy.circuitItem.oneTurnStage = questStageCircuitProxy.circuitItem.questOneTurnStageList[nowStageIndex + 1];
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_START_OF_STAGE);
}
else
{
questStageCircuitProxy.circuitItem.oneTurnEndAction(turnHavePlayerItem);
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_END_OF_TRUN);
}
break;
//检查当前阶段是否可以结束
case UIViewSystemEvent.UI_QUEST_TURN_STAGE_NEED_CHECK_END_STAGE_STATE:
PlayerItem stageHavePlayerItemForCheckEnd = playerGroupProxy.getPlayerByPlayerCode(questStageCircuitProxy.GetNowHaveStagePlayerCode());
UtilityLog.Log("第【" + questStageCircuitProxy.circuitItem.turnNum + "】回合" + "检查【" + questStageCircuitProxy.circuitItem.oneTurnStage.name + "】&&状态【" + questStageCircuitProxy.circuitItem.questTurnStageState.ToString() + "】是否可以进入下一个状态", LogUtType.Stage);
bool nextStageState = true;
if (questStageCircuitProxy.circuitItem.questTurnStageState == QuestTurnStageState.ExecutionOfState)
{
if (questStageCircuitProxy.circuitItem.oneTurnStage.automatic == "N")
{
nextStageState = false;
//判断当前玩家的种类
//AI玩家
if (stageHavePlayerItemForCheckEnd.playerType == PlayerType.AIPlayer)
{
//切入到AI逻辑操作
SendNotification(LogicalSysEvent.LOGICAL_SYS, null, LogicalSysEvent.LOGICAL_SYS_ACTIVE_PHASE_ACTION);
}
//人类玩家
else if (stageHavePlayerItemForCheckEnd.playerType == PlayerType.HumanPlayer)
{
//人类玩家自行操作
}
}
}
if (nextStageState)
{
//检查操作控制器和效果控制器是否都处于初始状态
if (operateSystemProxy.operateSystemItem.operateModeType == OperateSystemItem.OperateType.Close)
{
if (effectInfoProxy.effectSysItem.effectSysItemStage == EffectSysItemStage.UnStart)
{
//检查效果是否都展示完毕
if (effectInfoProxy.effectSysItem.showEffectNum == 0)
{
if (questStageCircuitProxy.circuitItem.questTurnStageState == QuestTurnStageState.StartOfState)
{
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_EXECUTION_OF_STAGE);
}
else if (questStageCircuitProxy.circuitItem.questTurnStageState == QuestTurnStageState.ExecutionOfState)
{
SendNotification(UIViewSystemEvent.UI_QUEST_TURN_STAGE, null, UIViewSystemEvent.UI_QUEST_TURN_STAGE_END_OF_STAGE);
}
}
}
}
}
break;
}
}