示例#1
0
        public override bool Equals(object obj)
        {
            if (this == obj)
            {
                return(true);
            }

            var other = obj as TetriminoWithPosition;

            if (other == null)
            {
                return(false);
            }

            if (LeftCol != other.LeftCol || TopRow != other.TopRow || !Tetrimino.Equals(other.Tetrimino))
            {
                return(false);
            }

            return(true);
        }
示例#2
0
        public TetrisActionWithEvaluation FindBestAction(Board board, Tetrimino tetriminoInStash, bool stashAllowed, Tetrimino fallingTetrimino, List <Tetrimino> nextTetriminoes, int nextPosition, List <int> linesCleared, int depth)
        {
            EvaluationState bestState  = null;
            TetrisAction    bestAction = null;

            Tetrimino originalTetrimino = fallingTetrimino;

            for (int rotateCnt = 0; rotateCnt < 4; rotateCnt++)
            {
                for (int newLeftCol = 0; newLeftCol + fallingTetrimino.Width - 1 < board.Width; newLeftCol++)
                {
                    DropResult dropResult = board.drop(fallingTetrimino, newLeftCol);
                    if (dropResult == null)
                    {
                        continue;
                    }
                    Board newBoard = dropResult.Board;
                    linesCleared.Add(dropResult.LinesCleared);

                    EvaluationState curState;

                    if (nextPosition == nextTetriminoes.Count || depth == depthLimit)
                    {
                        bool lineInStash = tetriminoInStash != null && (tetriminoInStash.Width == 4 || tetriminoInStash.Height == 4);
                        curState = evaluator.GetEvaluation(newBoard, linesCleared, lineInStash);
                    }
                    else
                    {
                        curState = FindBestAction(newBoard, tetriminoInStash, true, nextTetriminoes[nextPosition], nextTetriminoes, nextPosition + 1, linesCleared, depth + 1).EvaluationState;
                    }
                    if (curState != null && curState.better(bestState))
                    {
                        bestState  = curState;
                        bestAction = new TetrisAction(newLeftCol, rotateCnt);
                    }
                    linesCleared.RemoveAt(linesCleared.Count - 1);
                }
                fallingTetrimino = fallingTetrimino.RotateCW();
                if (fallingTetrimino.Equals(originalTetrimino))
                {
                    break;
                }
            }
            if (stashAllowed && (tetriminoInStash != null || nextPosition != nextTetriminoes.Count))
            {
                if (tetriminoInStash == null)
                {
                    tetriminoInStash = fallingTetrimino;
                    fallingTetrimino = nextTetriminoes[nextPosition];
                    nextPosition++;
                }
                else
                {
                    Tetrimino oldTetriminoInStash = tetriminoInStash;
                    tetriminoInStash = fallingTetrimino;
                    fallingTetrimino = oldTetriminoInStash;
                }

                EvaluationState curState = FindBestAction(board, tetriminoInStash, false, fallingTetrimino, nextTetriminoes, nextPosition, linesCleared, depth).EvaluationState;
                if (curState != null && curState.better(bestState))
                {
                    bestState  = curState;
                    bestAction = new TetrisAction(true);
                }
            }
            return(new TetrisActionWithEvaluation(bestAction, bestState));
        }