private PieceEV?TempImmobileCapture(List <PieceEV> towerPieces, int tierIndex, PlayerColor currentTurnColor, IEntitiesDB entitiesDB)
        {
            bool    isBetrayalPossible = !IsFriendlyBetrayalTopOfTower(towerPieces, currentTurnColor, entitiesDB);
            PieceEV?pieceToCapture     = towerPieces[tierIndex].PlayerOwner.PlayerColor == currentTurnColor ? towerPieces[tierIndex - 1] : towerPieces[tierIndex];

            pieceSetService.SetPieceLocationToHandLocation(pieceToCapture.Value, entitiesDB);
            pieceSetService.SetTopOfTowerToFalse(pieceToCapture, entitiesDB);

            int currentTier = 1;

            foreach (PieceEV towerPiece in towerPieces)
            {
                if (towerPiece.ID.entityID != pieceToCapture.Value.ID.entityID)
                {
                    pieceSetService.SetPieceLocationAndTier(towerPiece, towerPiece.Location.Location, currentTier++, entitiesDB);
                    pieceSetService.SetTopOfTowerToFalse(towerPiece, entitiesDB);
                }
            }

            List <PieceEV> newTowerPieces = new List <PieceEV>(towerPieces);

            newTowerPieces.Sort(delegate(PieceEV p1, PieceEV p2)
                                { return(p1.Tier.Tier.CompareTo(p2.Tier.Tier)); });

            pieceSetService.SetTopOfTower(newTowerPieces.Last(), entitiesDB);

            isBetrayalPossible = isBetrayalPossible && IsFriendlyBetrayalTopOfTower(newTowerPieces, currentTurnColor, entitiesDB);

            if (isBetrayalPossible)
            {
                // If friendly betrayal piece becomes topOfTower, by deduction, it's the pieceToStrike
                BetrayalEffectOnTower(towerPieces, currentTurnColor, entitiesDB);

                if (TwoFileMoveViolated(towerPieces, currentTurnColor))
                {
                    pieceToCapture = null;
                }
            }

            if (pieceToCapture.HasValue && checkService.CannotCaptureCommanderViolated(newTowerPieces, currentTurnColor, entitiesDB))
            {
                pieceToCapture = null;
            }

            return(pieceToCapture);
        }
Пример #2
0
        // Will need to be careful of betrayal effect when doing temp move
        private bool IsMobileMoveValid(PieceEV pieceToCalc, Vector2 destination, bool shouldStackEnemyPiece, IEntitiesDB entitiesDB)
        {
            List <PieceEV> allPieces = pieceFindService.FindAllBoardPieces(entitiesDB).ToList();
            // Make temp move while saving old info
            PreviousMoveState  previousMoveState             = destinationTileService.SaveCurrentMove(pieceToCalc, destination, allPieces);
            PreviousTowerState?previousDestinationTowerState = previousMoveState.pieceCaptured.HasValue &&
                                                               destinationTileService.BetrayalInEffect(previousMoveState.pieceToMove.Piece)
                ? destinationTileService.SaveDestinationTowerState(previousMoveState, allPieces) : null;

            destinationTileService.MakeTemporaryMove(pieceToCalc, destination, allPieces, shouldStackEnemyPiece);

            bool returnValue = !checkService.IsCommanderInCheck(pieceToCalc.PlayerOwner.PlayerColor, entitiesDB);

            if (returnValue)
            {
                returnValue = !checkService.CannotCaptureCommanderViolated(destination, pieceToCalc.PlayerOwner.PlayerColor, entitiesDB);
            }

            destinationTileService.RestorePreviousState(previousMoveState, previousDestinationTowerState);

            return(returnValue);
        }