Esempio n. 1
0
        private static bool TryApplyInstruction(ref SimpleBoard board, Piece piece, Instruction inst, out Piece result,
                                                NativeArray <int4x4> pieceShapes)
        {
            switch (inst)
            {
            case Left:
                result = piece.WithOffset(-1, 0);
                return(!board.CollidesFast(result, pieceShapes));

            case Right:
                result = piece.WithOffset(1, 0);
                return(!board.CollidesFast(result, pieceShapes));

            case Cw:
                var t = SRSNoAlloc.TryRotate(piece, ref board, true, pieceShapes, out var r1, out var r1Result);
                result = piece.kind == T?r1Result.WithTSpinStatus(board.CheckTSpin(r1Result, r1)) : r1Result;

                return(t);

            case Ccw:
                var s = SRSNoAlloc.TryRotate(piece, ref board, false, pieceShapes, out var r2, out var r2Result);
                result = piece.kind == T?r2Result.WithTSpinStatus(board.CheckTSpin(r2Result, r2)) : r2Result;

                return(s);

            case SonicDrop:
                var originY = piece.y;
                result = board.SonicDropFast(piece, pieceShapes);
                return(originY != result.y);

            default:
                throw new ArgumentOutOfRangeException(nameof(inst), inst, null);
            }
        }
Esempio n. 2
0
 private static void Confirm(ref SimpleBoard board, ref NativeHashMap <Piece, Move> lookup, Move mv,
                             NativeArray <int4x4> pieceShapes)
 {
     if (!IsAboveStacking(mv.piece, 20) && !board.CollidesFast(mv.piece, pieceShapes))
     {
         lookup.TryAdd(mv.piece, mv);
     }
 }
Esempio n. 3
0
        public static bool TryRotate(Piece piece, ref SimpleBoard board, bool cw, NativeArray <int4x4> pieceShapes,
                                     out int rotation, out Piece rotated)
        {
            if (piece.kind == PieceKind.O)
            {
                rotation = 0;
                rotated  = piece;
                return(true);
            }

            var rotatedDirection = GetRotatedDirection(piece.spin, cw);

            var newPiece = new Piece(piece.kind, piece.x, piece.y, rotatedDirection);

            if (!board.CollidesFast(newPiece, pieceShapes))
            {
                rotation = 0;
                rotated  = newPiece;
                return(true);
            }

            var key         = piece.spin * 10 + rotatedDirection;
            var offsetTable = piece.kind == PieceKind.I
                ? RotationTableI[KeyToIndex(key)]
                : RotationTable[KeyToIndex(key)];

            for (var i = 0; i < 4; i++)
            {
                newPiece = piece.WithOffset(offsetTable[i]).WithSpin(rotatedDirection);
                if (!board.CollidesFast(newPiece, pieceShapes))
                {
                    rotation = i + 1;
                    rotated  = newPiece;
                    return(true);
                }
            }

            rotation = default;
            rotated  = default;
            return(false);
        }