public EffectHolder(CardGameState GS, bool Shared, int OwnerIndex) { TheCardGameState = GS; this.Shared = Shared; this.OwnerIndex = OwnerIndex; mCardZoneType = new CardZoneType(Shared ? ZoneType.SharedEffect : ZoneType.Effect, Range.NA, OwnerIndex); }
private List <Actions.ActionOrder> GetAvailableActions(TurnInfo turnInfo, CardGameState gameState) { List <Actions.ActionOrder> availableActions = new List <Actions.ActionOrder>(); foreach (Entity E in mHand.Cards) { availableActions.AddRange(E.GetAIActions(gameState, turnInfo)); } foreach (Effects.EffectNode EN in mEffects.Nodes) { availableActions.AddRange(EN.GetEntity().GetAIActions(gameState, turnInfo)); } foreach (Effects.EffectNode EN in gameState.SharedEffects.Nodes) { availableActions.AddRange(EN.GetEntity().GetAIActions(gameState, turnInfo)); } foreach (CardZone CZ in mBoard.RangeZones) { foreach (Entity E in CZ.List.Cards) { availableActions.AddRange(E.GetAIActions(gameState, turnInfo)); } } return(availableActions); }
public ChangeAttackDefenseEffectProcess(CardBase monsterCard, CardGameState cardGameState, Player ownerPlayer) : base(ownerPlayer, "转换攻防") { effectProcessType = EffectProcessType.RemoveAfterFinish; this.monsterCard = monsterCard; launchEffectCard = monsterCard; this.cardGameState = cardGameState; }
public static void CreateActionsAndGameStateSet( CardGameState stateToCopy, List <ActionOrder> actionsToCopy, out ActionsAndGameStateSet setToReturn) { MemoryStream stream = new MemoryStream(); BinaryFormatter formatter = new BinaryFormatter(); // Use a set with only one card game state so that everything gets serialised together. ActionsAndGameStateSet set = new ActionsAndGameStateSet(); set.mAvailableActions = new List <ActionOrder>(actionsToCopy); set.mCardGameStates = new List <CardGameState>(); set.mCardGameStates.Add(stateToCopy); formatter.Serialize(stream, set); ActionsAndGameStateSet returnSet = new ActionsAndGameStateSet(); returnSet.mAvailableActions = new List <ActionOrder>(); returnSet.mCardGameStates = new List <CardGameState>(); for (int i = 0; i < actionsToCopy.Count; i++) { stream.Seek(0, SeekOrigin.Begin); ActionsAndGameStateSet setCopy = (ActionsAndGameStateSet)formatter.Deserialize(stream); returnSet.mAvailableActions.Add(setCopy.mAvailableActions[i]); returnSet.mCardGameStates.Add(setCopy.mCardGameStates[0]); } setToReturn = returnSet; }
private static float EvaluateGameState(int playerIndex, CardGameState gameState, bool passing = false) { // TODO Make this in any way good // TODO Make this handle more cases of players being passed. // ie a player cant do anything when passed so it should be possible // to more properly calculate if they are worth beating. Player player = gameState.Players[playerIndex]; Player opponent = gameState.Players[(playerIndex + 1) % 2]; if (passing && opponent.GetVP() > player.GetVP()) { // We know for sure* we are losing this round. // *Unless they manage to cause themselves to lose VP :P return(0.0f); } float playerScoreTotal = ScorePlayer(player); float opponentScoreTotal = ScorePlayer(opponent); float scoreDifference = opponentScoreTotal - playerScoreTotal; float probabiltyFactor = GetProbFromScoreDifference(scoreDifference); if (scoreDifference > 0) { return(probabiltyFactor); } else { return(1 - probabiltyFactor); } }
/// <summary> /// 判断当前是否在场上 /// </summary> /// <returns></returns> public static bool IsInArea(CardGameState cardGameState) { return(cardGameState == CardGameState.FrontAttack || cardGameState == CardGameState.FrontDefense || cardGameState == CardGameState.Front || cardGameState == CardGameState.Back); }
public override List <ActionOrder> GetAIActions(CardGameState gameState, TurnInfo TI) { List <ActionOrder> results = new List <ActionOrder>(); if (!IsPlaced) { foreach (CardZone CZ in Owner.mBoard.RangeZones) { Actions.Action placeCardAction = new PlaceCard_Action(this, CZ.Type); if (placeCardAction.CheckValidity(null, null, TI)) { results.Add(new ActionOrder(placeCardAction, null, null)); } } } else { if (!TI.IsDeployment()) { foreach (ActionInfo AI in GetActions()) { foreach (ActionOrder AO in AI.GetPossibleActionOrders(gameState, this)) { if (AO.Action.CheckValidity(AO.Performer, AO.Selection, TI)) { results.Add(AO); } } } } } return(results); }
public void NewTurn(CardGameState GS) { if (HasEffect) { TheEffect.NewTurn(GS); } }
public List <ActionOrder> GetPossibleActionOrders(CardGameState gameState, Entities.Entity performer) { List <ActionOrder> possibleActions = new List <ActionOrder>(); if (Min == 0 || SelectType == PlayerType.NA) { possibleActions.Add(new ActionOrder(mAction, performer, null)); } if (Max > 0) { List <List <Entities.Entity> > selections = null; if (SelectType == PlayerType.Ally) { selections = GetPossibleSelections(performer.Owner.mBoard, performer, (uint)Min, (uint)Max); } if (SelectType == PlayerType.Enemy) { selections = GetPossibleSelections(gameState.Players[(performer.Owner.getIndex() + 1) % 2].mBoard, performer, (uint)Min, (uint)Max); } foreach (List <Entities.Entity> selection in selections) { possibleActions.Add(new ActionOrder(mAction, performer, selection)); } } return(possibleActions); }
public void Update(CardGameState GS) { if (HasEffect) { TheEffect.Update(GS); } }
public override List <Actions.ActionOrder> GetAIActions(CardGameState gameState, TurnInfo TI) { List <Actions.ActionOrder> results = new List <Actions.ActionOrder>(); if (!IsPlaced) { CardZoneType effectCardZoneType = mIsShared ? gameState.SharedEffects.mCardZoneType : Owner.mEffects.mCardZoneType; Actions.Action placeCardAction = new Actions.PlaceCard_Action(this, effectCardZoneType); if (placeCardAction.CheckValidity(null, null, TI)) { results.Add(new Actions.ActionOrder(placeCardAction, null, null)); } } else { foreach (Actions.ActionInfo AI in GetActions()) { if (AI.mAction.IsAvailable(this)) { foreach (Actions.ActionOrder AO in AI.GetPossibleActionOrders(gameState, this)) { if (AO.Action.CheckValidity(AO.Performer, AO.Selection, TI)) { results.Add(AO); } } } } } return(results); }
void OnStateChangeHandler(CardGameState state, bool isFirstState) { m_cardsInHandText.text = "Cards In hand count:" + this.myPlayer.cardsInHand.Count; m_cardsInFieldText.text = "Field Card count:" + state.cardsInField.Count; m_cardsInHandMapText.text = "Cards In hand Map count:" + this.myPlayer.cardsInHandMap.Count; m_cardsInFieldMapText.text = "Field Card Map count:" + state.cardsInFieldMap.Count; }
List <CardBase> sacrificeCards = new List <CardBase>(); //祭品列表 public CallMonsterEffectProcess(CardBase calledMonster, CardGameState cardGameState, Player ownerPlayer) : base(ownerPlayer, "召唤怪兽") { canBeChained = true; this.calledMonster = calledMonster; this.cardGameState = cardGameState; finishAction += () => { }; }
/// <summary> /// 召唤怪兽到场上 /// </summary> /// <param name="monsterCard"></param> public void CallMonster(CardBase monsterCard, CardGameState cardGameState = CardGameState.Unknown) { if (IsMyPlayer()) { //检测召唤条件是否满足 CallMonsterEffectProcess callMonsterEffectProcess = new CallMonsterEffectProcess(monsterCard, cardGameState, this); AddEffectProcess(callMonsterEffectProcess); } }
public void UpdatePersistance(CardGameState GS) { if (mPersistanceModules != null) { foreach (PersistanceModule PM in mPersistanceModules) { PM.Run(GS); } } }
public virtual bool NewTurn(CardGameState GS) { NumNewTurns += 1; if (NewTurnLength == NumNewTurns) { End(); return(false); } return(true); }
public override void Process() { int cardID = int.Parse(GetContent("cardID")); CallType callType = (CallType)Enum.Parse(typeof(CallType), GetContent("callType")); CardGameState fromCardGameState = (CardGameState)Enum.Parse(typeof(CardGameState), GetContent("fromCardGameState")); CardGameState toCardGameState = (CardGameState)Enum.Parse(typeof(CardGameState), GetContent("toCardGameState")); int flag = int.Parse(GetContent("flag")); GameManager.GetDuelScene().OpponentCallMonster(cardID, callType, fromCardGameState, toCardGameState, flag); }
public override void CallMonsterNotify(int id, CallType callType, CardGameState fromCardGameState, CardGameState toCardGameState, int flag) { CCallMonster cCallMonster = new CCallMonster(); cCallMonster.AddContent("cardID", id); cCallMonster.AddContent("callType", callType); cCallMonster.AddContent("fromCardGameState", fromCardGameState); cCallMonster.AddContent("toCardGameState", toCardGameState); cCallMonster.AddContent("flag", flag); ClientManager.GetSingleInstance().SendProtocol(cCallMonster); }
public Player(int index, CardGameState GS) { mPlayerIndex = index; mCommandPoints = kMaxCP; mBoard = new PlayerBoard(index); mEffects = new Effects.EffectHolder(GS, false, mPlayerIndex); mMaxMulligans = kMaxMulligans; mMulligansUsed = 0; mUnitCardsPlaced = 0; mOtherCardsPlaced = 0; }
public override void Placed(CardZoneType CZ, CardList CL, CardGameState GS) { IsPlaced = true; Zone = CZ; CL.AddCard(this); AddStatus("Placed this turn"); if (GS.mTurnInfo.IsFirstDeployment()) { AddStatus("Deployed"); } }
public void AllKnownCasesPassWinCheck(int row1, int row2, int row3, CardGameState expect) { var expectation = new ConfigExpectation(row1, row2, row3, expect); var state = expectation.Config.GetState(); Assert.True( state == expect, $"[!] Fail {expectation.Config}. Should be {expect}. Was {state}" ); }
public void Update(CardGameState GS) { mEffects.UpdatePersistance(); for (int i = 0; i < mBoard.RangeZones.Length; i++) { foreach (Entity E in mBoard.RangeZones[i].List.Cards) { E.Update(); } } mEffects.Update(); }
protected override void BeforeProcessFunction() { if (cardGameState == CardGameState.Unknown) { duelScene.ShowAttackOrDefensePanel(calledMonster, (cardGameState) => { this.cardGameState = cardGameState; RealFunction(); }); return; } RealFunction(); }
public void NewTurn(CardGameState GS) { mEffects.NewTurn(); mSpentCP = false; mUnitCardsPlaced = 0; mOtherCardsPlaced = 0; foreach (CardZone CZ in mBoard.RangeZones) { foreach (Entity E in CZ.List.Cards) { E.NewTurn(); } } }
// This assumes the action is valid, it will not check! private static float EvaluateAction(int playerIndex, Actions.ActionOrder action, CardGameState gameState, int roundVictoryLimit) { Actions.ActionOrder actionCopy = action; CardGameState stateCopy = gameState; // We assume this is a valid action otherwise this action should never have been made available. actionCopy.Action.Execute(actionCopy.Performer, actionCopy.Selection, stateCopy); Player thisPlayerCopy = stateCopy.Players[playerIndex]; // Check whether this action (or preceding actions this turn) allows us not to pass this turn. bool stillPassing = !(thisPlayerCopy.HasSpentCP() || thisPlayerCopy.WasCardPlaced()); return(EvaluateMatchWinChance(playerIndex, stateCopy, roundVictoryLimit, stillPassing)); }
public override void Update(CardGameState GS) { foreach (CardZone rangeZone in GS.Players[Node.OwnerIndex].mBoard.RangeZones) { foreach (Entities.Entity E in rangeZone.List.Cards) { Entities.Unit U = ((Entities.Unit)E); if (U.IsClass(AffectedClass)) { U.AttackCostModifier += Amount; } } } }
// Remember that actions that were not made from a certain game state cannot be used in any way with it. public override void TakeTurn(TurnInfo turnInfo, CardGameState gameState, CardGameManager manager) { if (turnInfo.IsMulligan) { // Pass in the mulligan for now manager.Continue(); } else { bool shouldContinue = false; bool hasTakenAction = false; List <Actions.ActionOrder> availableActions = GetAvailableActions(turnInfo, gameState); while (!shouldContinue && availableActions.Count > 0) { ActionsAndGameStateSet actionSet; Utility.Serialiser.CreateActionsAndGameStateSet(gameState, availableActions, out actionSet); float continueScore = EvaluateMatchWinChance(getIndex(), gameState, manager.GetRoundVictoryLimit(), !hasTakenAction); float maxScore = 0; int bestActionIndex = -1; for (int actionIndex = 0; actionIndex < actionSet.mAvailableActions.Count; actionIndex++) { float actionScore = EvaluateAction(getIndex(), actionSet.mAvailableActions[actionIndex], actionSet.mCardGameStates[actionIndex], manager.GetRoundVictoryLimit()); if (actionScore > maxScore) { maxScore = actionScore; bestActionIndex = actionIndex; } } if (maxScore > continueScore) { UnityEngine.Debug.Assert(bestActionIndex > -1); // Update real game state with action. manager.PassAction(availableActions[bestActionIndex]); availableActions = GetAvailableActions(turnInfo, gameState); hasTakenAction = HasSpentCP() || WasCardPlaced(); } else { shouldContinue = true; } } // Continue at the end of the turn manager.Continue(); } }
public override void Run(CardGameState GS) { bool hasRequiredUnit = false; foreach (CardZone CZ in mParentEffectEntity.Owner.mBoard.RangeZones) { foreach (Entities.Unit U in CZ.List.Cards) { if (U.Name == mRequiredUnitName) { hasRequiredUnit = true; } } } if (!hasRequiredUnit) { mParentEffectEntity.GetEffect().End(); } }
private static float EvaluateFutureRounds(int playerIndex, CardGameState gameState, int roundsToWin, int opposingRoundsToWin) { if (roundsToWin == 0) { return(1.0f); } else if (opposingRoundsToWin == 0) { return(0.0f); } int opposingPlayerIndex = (playerIndex + 1) % 2; CardList playerHand = gameState.Players[playerIndex].mHand; CardList opposingPlayerHand = gameState.Players[opposingPlayerIndex].mHand; return(TraverseRoundWinTree(playerIndex, playerHand.Cards.Count, ScoreHand(playerHand) / playerHand.Cards.Count, roundsToWin, opposingPlayerIndex, opposingPlayerHand.Cards.Count, ScoreHand(opposingPlayerHand) / opposingPlayerHand.Cards.Count, opposingRoundsToWin)); }
public override void Update(CardGameState GS) { if (Selection != null) { if (!Done) { if (Selection.Count == 1) { ((Unit)Selection[0]).Heal(OneHeal); } else { ((Unit)Selection[0]).Heal(TwoHeal); ((Unit)Selection[1]).Heal(TwoHeal); } Done = true; } } }