void Start()
{
anim = GetComponent <Animator>();
col = GetComponent <Collider>();
set = gameObject.GetComponentInParent <TargetSet>();
Activate(true);
}
public void NoRulesValidationsAreSelected()
{
//Arrange
var catalog = new ValidationCatalog();
catalog.AddValidations(ValidationFinder.ScanAssembly(GetType().Assembly, t => t == typeof(CustomerSimple)));
var targetSet = new TargetSet();
targetSet.Add(new CustomerInstance());
//Act
var selected = ValidationSelector.Select(catalog, targetSet);
//Assert
var output = new Output();
output.FormatTable(selected.Select(s => new
{
Method = s.Validation.Method.Name,
Inputs = string.Join(", ", s.Targets.Select(t => t.GetType().Name))
}));
output.Report.Verify();
}
public void Add(TargetSet targetSet)
{
if (targetSet == null)
{
throw new ArgumentNullException("targetSet");
}
this.targetSets.Add(targetSet);
}
public Target(TargetSet targetSet, string url, string text)
{
if (targetSet == null)
{
throw new ArgumentNullException("targetSet");
}
this.targetSet = targetSet;
this.url = url;
this.text = text;
}
public void EntitiesAreKnownToSet()
{
//Arrange
var set = new TargetSet();
var customer = new Customer();
//Act
set.Add(customer);
//Assert
set.Contains(customer);
}
/*
* Generate Code Input
* @param TargetSet set
* @param int array
* @param int from
* @param int to
*/
public void GenerateCodeInput(TargetSet set, int array, int from, int to)
{
for(int i = from; i <= to; i++)
{
string oldCode = set.spawns[array][i];
string newCode = GUILayout.TextField(oldCode, GUILayout.Width (20));
if(newCode != oldCode)
{
Round.current.ChangeTargetCode(currentSet, array, i, newCode);
}
}
}
public override void Execute(INotification notification)
{
GameContainerProxy gameContainerProxy =
Facade.RetrieveProxy(GameContainerProxy.NAME) as GameContainerProxy;
PlayerGroupProxy playerGroupProxy =
Facade.RetrieveProxy(PlayerGroupProxy.NAME) as PlayerGroupProxy;
switch (notification.Type)
{
//根据效果渲染高亮
case MinionSystemEvent.MINION_SYS_EFFECT_HIGHLIGHT:
TargetSet targetSetToChoose = notification.Body as TargetSet;
//通知生物层发生变更重新渲染部分生物
SendNotification(MinionSystemEvent.MINION_VIEW, GetMinionListByTargetSet(targetSetToChoose, gameContainerProxy), MinionSystemEvent.MINION_VIEW_MINIONS_CHANGE);
break;
//根据效果渲染高亮-预定成为目标选择项
case MinionSystemEvent.MINION_SYS_EFFECT_HIGHLIGHT_BECOME_TARGET:
TargetSet targetSetToChooseTarget = notification.Body as TargetSet;
List <CardEntry> mList = GetMinionListByTargetSet(targetSetToChooseTarget, gameContainerProxy);
//通知生物层发生变更重新渲染部分生物
SendNotification(MinionSystemEvent.MINION_VIEW, mList, MinionSystemEvent.MINION_VIEW_MINIONS_CHANGE_TO_CHOOSE_TARGET);
break;
case MinionSystemEvent.MINION_SYS_EFFECT_HIGHLIGHT_CLOSE:
List <CardEntry> mListClose = new List <CardEntry>();
List <GameContainerItem> returnGameContainerItemList = gameContainerProxy.GetGameContainerItemGameContainerType("CardBattlefield");
foreach (GameContainerItem gameContainerItem in returnGameContainerItemList)
{
foreach (CardEntry minionCellItem in gameContainerItem.cardEntryList)
{
if (minionCellItem.IsEffectTarget == true)
{
minionCellItem.IsEffectTarget = false;
}
mListClose.Add(minionCellItem);
}
}
//通知生物层发生变更重新渲染部分生物
SendNotification(MinionSystemEvent.MINION_VIEW, mListClose, MinionSystemEvent.MINION_VIEW_MINIONS_CHANGE);
break;
//生物死亡
case MinionSystemEvent.MINION_SYS_ONE_MINION_IS_DEAD:
CardEntry minionCellItemIsDead = notification.Body as CardEntry;
//放入墓地
minionCellItemIsDead.nextGameContainerType = "CardGraveyard";
minionCellItemIsDead.ttNeedChangeGameContainerType(minionCellItemIsDead);
break;
}
}
public void EffectActionReady(EffectInfo effect)
{
if (effect.operationalTarget != null)
{
effect.operationalTarget.selectTargetList = new List <TargetSet>();
foreach (string targetSetCode in effect.operationalTarget.selectTarget)
{
TargetSet targetSetDto = TransExpV2 <TargetSet, TargetSet> .Trans(targetSetMap[targetSetCode]);
targetSetDto.CleanEffectTargetSetList();
effect.operationalTarget.selectTargetList.Add(targetSetDto);
}
}
}
public void EntitiesAreRemovedFromSet()
{
//Arrange
var set = new TargetSet();
var customer = new Customer();
set.Add(customer);
//Act
set.Remove(customer);
//Assert
set.Contains(customer).Should().BeFalse();
}
public void EntityFieldsAreReturned()
{
//Arrange
var set = new TargetSet();
var customer = new Customer();
set.Add(customer);
var idRef = new EntityReference("Customer", "Id");
//Act
var result = set.GetFields(idRef);
//Assert
result.Any(f => ReferenceEquals(f.Target, customer)).Should().BeTrue();
}
private void SetTargets(int legIndex, TargetSet set, bool reverseHip = false)
{
Quaternion hipQuat = set.hip;
if (reverseHip)
{
hipQuat.x *= -1;
}
Leg leg = legs[legIndex];
leg.hip.targetRotation = hipQuat;
leg.knee.targetRotation = set.knee;
leg.ankle.targetRotation = set.ankle;
leg.constantForce.enabled = set.useConstantForce;
}
public void FieldTypeMismatchExcludesValidation()
{
//Arrange
var set = new TargetSet();
set.Add(new BadCustomer());
var validation = _validations.Validations()
.Single(v => v.ContainingType == typeof(CustomerSimple) && v.Method.Name == nameof(CustomerSimple.SurnameIsMandatory));
var candidates = CandidateSelector.AllPossible(validation, set);
//Act
var error = ValidationRuleChecker.Check(candidates[0]).Single();
//Assert
error.Message.Should().Contain("incorrect type");
}
public List <CardEntry> GetMinionListByTargetSet(TargetSet targetSetToChoose, GameContainerProxy gameContainerProxy)
{
List <CardEntry> mList = new List <CardEntry>();
List <GameContainerItem> returnGameContainerItemList = gameContainerProxy.GetGameContainerItemGameContainerType("CardBattlefield");
foreach (GameContainerItem gameContainerItem in returnGameContainerItemList)
{
foreach (CardEntry minionCellItem in gameContainerItem.cardEntryList)
{
if (targetSetToChoose.checkEffectToTargetMinionCellItem(minionCellItem))
{
UtilityLog.Log(" 检查了生物:" + minionCellItem.cardInfo.code, LogUtType.Special);
minionCellItem.IsEffectTarget = true;
mList.Add(minionCellItem);
}
}
}
return(mList);
}
private void treeViewFavorites_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
TargetSet ts = this.treeViewFavorites.SelectedItem as TargetSet;
if (ts != null)
{
this.ActiveTargetSet = ts;
RaiseEvent(new RoutedEventArgs(Favorites.TargetSetClick, this));
return;
}
FavoriteFile ff = this.treeViewFavorites.SelectedItem as FavoriteFile;
if (ff != null)
{
this.ActiveFavoriteFile = ff;
RaiseEvent(new RoutedEventArgs(Favorites.FavoriteClick, this));
}
}
private void treeViewFavorites_SelectedItemChanged(object sender, System.Windows.RoutedPropertyChangedEventArgs <object> e)
{
TargetSet ts = this.treeViewFavorites.SelectedItem as TargetSet;
if (ts != null)
{
this.ActiveTargetSet = ts;
RaiseEvent(new RoutedEventArgs(Favorites.TargetSetClick, this));
return;
}
FavoriteFile ff = this.treeViewFavorites.SelectedItem as FavoriteFile;
if (ff != null)
{
this.ActiveFavoriteFile = ff;
RaiseEvent(new RoutedEventArgs(Favorites.FavoriteClick, this));
}
}
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;
}
}
private void buttonSave_Click(object sender, RoutedEventArgs e)
{
TargetSet tset = new TargetSet {
file = this.favFileName, Name = this.txtTargetSetName.Text, Parameters = this.favParameters, Strapper = this.favStrapper, Targets = this.favTargets
};
if (this.listBoxExistingFavorites.SelectedIndex >= 0)
{
FavoriteFile f = this.listBoxExistingFavorites.SelectedItem as FavoriteFile;
XmlSerializer deserializer = new XmlSerializer(typeof(FavoriteEntity));
FavoriteEntity foundFavorite;
using (FileStream favStream = new FileStream(f.FullPath, FileMode.Open, FileAccess.Read))
{
foundFavorite = (FavoriteEntity)deserializer.Deserialize(favStream);
}
TargetSet[] temp = new TargetSet[foundFavorite.TargetSet.Length + 1];
int i = 0;
foreach (TargetSet t in foundFavorite.TargetSet)
{
temp[i] = t;
i++;
}
temp[i] = tset;
foundFavorite.TargetSet = temp;
XmlSerializer serializer = new XmlSerializer(typeof(FavoriteEntity));
using (FileStream fs = new FileStream(f.FullPath, FileMode.Create))
{
TextWriter writer = new StreamWriter(fs, new UTF8Encoding());
serializer.Serialize(writer, foundFavorite);
}
this.Close();
return;
}
SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog {
DefaultExt = ".msbef", Filter = "MSBuild Explorer Favorite (.msbef)|*.msbef"
};
if (dlg.ShowDialog() == true)
{
FavoriteEntity fe = new FavoriteEntity();
fe.groupName = this.txtFavoriteGroupName.Text;
TargetSet[] tsetcol = new TargetSet[1];
tsetcol[0] = tset;
fe.TargetSet = tsetcol;
fe.file = this.favFileName;
fe.friendlyName = this.txtFavoriteName.Text;
XmlSerializer serializer = new XmlSerializer(typeof(FavoriteEntity));
using (FileStream fs = new FileStream(dlg.FileName, FileMode.Create))
{
TextWriter writer = new StreamWriter(fs, new UTF8Encoding());
serializer.Serialize(writer, fe);
}
StringCollection favs = new StringCollection();
foreach (string s in from string s in Settings.Default.Favorites where !favs.Contains(s) select s)
{
favs.Add(s);
}
if (!favs.Contains(dlg.FileName))
{
favs.Add(dlg.FileName);
}
Settings.Default.Favorites = favs;
Settings.Default.Save();
this.Close();
}
}
private TargetSet BuildTargetSet(int count)
{
TargetSet ts = new TargetSet(this, count);
foreach (ParamsMethodMaker maker in paramsMakers) {
MethodTarget target = maker.MakeTarget(count);
if (target != null) ts.Add(target);
}
return ts;
}
private void AddTarget(MethodTarget target)
{
int count = target.ParameterCount;
TargetSet set;
if (!targetSets.TryGetValue(count, out set)) {
set = new TargetSet(this, count);
targetSets[count] = set;
}
set.Add(target);
}
internal void LoadTargetSet(TargetSet targetSet)
{
this.TextBoxParameters.Text = targetSet.Parameters;
this.TextBoxPreExecute.Text = targetSet.Strapper;
}
private void treeViewFavorites_SelectedItemChanged(object sender, System.Windows.RoutedPropertyChangedEventArgs<object> e)
{
TargetSet ts = this.treeViewFavorites.SelectedItem as TargetSet;
if (ts != null)
{
this.ActiveTargetSet = ts;
RaiseEvent(new RoutedEventArgs(Favorites.TargetSetClick, this));
return;
}
FavoriteFile ff = this.treeViewFavorites.SelectedItem as FavoriteFile;
if (ff != null)
{
this.ActiveFavoriteFile = ff;
RaiseEvent(new RoutedEventArgs(Favorites.FavoriteClick, this));
}
}
private void buttonSave_Click(object sender, RoutedEventArgs e)
{
TargetSet tset = new TargetSet { file = this.favFileName, Name = this.txtTargetSetName.Text, Parameters = this.favParameters, Strapper = this.favStrapper, Targets = this.favTargets };
if (this.listBoxExistingFavorites.SelectedIndex >= 0)
{
FavoriteFile f = this.listBoxExistingFavorites.SelectedItem as FavoriteFile;
XmlSerializer deserializer = new XmlSerializer(typeof(FavoriteEntity));
FavoriteEntity foundFavorite;
using (FileStream favStream = new FileStream(f.FullPath, FileMode.Open, FileAccess.Read))
{
foundFavorite = (FavoriteEntity)deserializer.Deserialize(favStream);
}
TargetSet[] temp = new TargetSet[foundFavorite.TargetSet.Length + 1];
int i = 0;
foreach (TargetSet t in foundFavorite.TargetSet)
{
temp[i] = t;
i++;
}
temp[i] = tset;
foundFavorite.TargetSet = temp;
XmlSerializer serializer = new XmlSerializer(typeof(FavoriteEntity));
using (FileStream fs = new FileStream(f.FullPath, FileMode.Create))
{
TextWriter writer = new StreamWriter(fs, new UTF8Encoding());
serializer.Serialize(writer, foundFavorite);
}
this.Close();
return;
}
SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog { DefaultExt = ".msbef", Filter = "MSBuild Explorer Favorite (.msbef)|*.msbef" };
if (dlg.ShowDialog() == true)
{
FavoriteEntity fe = new FavoriteEntity();
fe.groupName = this.txtFavoriteGroupName.Text;
TargetSet[] tsetcol = new TargetSet[1];
tsetcol[0] = tset;
fe.TargetSet = tsetcol;
fe.file = this.favFileName;
fe.friendlyName = this.txtFavoriteName.Text;
XmlSerializer serializer = new XmlSerializer(typeof(FavoriteEntity));
using (FileStream fs = new FileStream(dlg.FileName, FileMode.Create))
{
TextWriter writer = new StreamWriter(fs, new UTF8Encoding());
serializer.Serialize(writer, fe);
}
StringCollection favs = new StringCollection();
foreach (string s in from string s in Settings.Default.Favorites where !favs.Contains(s) select s)
{
favs.Add(s);
}
if (!favs.Contains(dlg.FileName))
{
favs.Add(dlg.FileName);
}
Settings.Default.Favorites = favs;
Settings.Default.Save();
this.Close();
}
}
internal void LoadTargetSet(TargetSet targetSet)
{
this.TextBoxParameters.Text = targetSet.Parameters;
this.TextBoxPreExecute.Text = targetSet.Strapper;
}
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 void Add(TargetSet targetSet) {
if (targetSet == null)
throw new ArgumentNullException("targetSet");
this.targetSets.Add(targetSet);
}
/*
* Serialize
* Serialize round and organize components into individual arrays
*/
public RoundData Serialize()
{
RoundData data = new RoundData();
// Save an array of round names
data.roundName = roundName;
data.numPucks = numPucks;
TargetSet[] sets = new TargetSet[targetSets.Count];
for (int i = 0; i < targetSets.Count; i++)
sets [i] = (TargetSet)targetSets [i];
data.targetSets = sets;
return data;
}
public Target(TargetSet targetSet, string url, string text) {
if (targetSet == null)
throw new ArgumentNullException("targetSet");
this.targetSet = targetSet;
this.url = url;
this.text = text;
}
public void InsertNewTarget(TargetSet newTarget)
{
this._repostitoryFactory.GetTargetRepository(this._dbContext).Insert(newTarget);
}
/*
* Add Set
* @param int i, index of set
*/
public void AddSet(int i)
{
TargetSet newSet = new TargetSet ();
newSet.Initialize ();
targetSets.Insert (Mathf.Clamp (i, 0, targetSets.Count), newSet);
BuildSet (i);
}
private void treeViewFavorites_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
TargetSet ts = this.treeViewFavorites.SelectedItem as TargetSet;
if (ts != null)
{
this.ActiveTargetSet = ts;
RaiseEvent(new RoutedEventArgs(Favorites.TargetSetClick, this));
return;
}
FavoriteFile ff = this.treeViewFavorites.SelectedItem as FavoriteFile;
if (ff != null)
{
this.ActiveFavoriteFile = ff;
RaiseEvent(new RoutedEventArgs(Favorites.FavoriteClick, this));
}
}
