Esempio n. 1
0
    private bool IsPieceCanMove(PieceDirection dir)
    {
        int dy = 0;
        int dx = 0;

        if (dir == PieceDirection.DOWN)
        {
            dy = -1;
        }
        if (dir == PieceDirection.RIGHT)
        {
            dx = 1;
        }
        else if (dir == PieceDirection.LEFT)
        {
            dx = -1;
        }

        bool isCan = true;

        foreach (Point p in Piece.Points)
        {
            if (dir == PieceDirection.DOWN)
            {
                if (p.Y <= 0)
                {
                    return(false);
                }
            }
            else if (dir == PieceDirection.RIGHT)
            {
                if (p.X >= Board.BoardSizeX - 1)
                {
                    return(false);
                }
            }
            else if (dir == PieceDirection.LEFT)
            {
                if (p.X <= 0)
                {
                    return(false);
                }
            }

            Tile tileInDirection = Board.GetTile(p.X + dx, p.Y + dy);

            if (Piece.IsContainsTile(tileInDirection))
            {
                continue;
            }
            if (tileInDirection.IsFull)
            {
                return(false);
            }
        }

        return(isCan);
    }
Esempio n. 2
0
        public static PieceDirection GetNextDirection(this PieceDirection dir)
        {
            PieceDirection nextDir = dir;

            if (nextDir == PieceDirection.Left)
            {
                nextDir = PieceDirection.Up;
            }
            else
            {
                nextDir++;
            }
            return(nextDir);
        }
Esempio n. 3
0
    private void movePiece(PieceDirection dir)
    {
        int dy = 0;
        int dx = 0;

        if (dir == PieceDirection.DOWN)
        {
            dy = -1;
        }
        if (dir == PieceDirection.RIGHT)
        {
            dx = 1;
        }
        else if (dir == PieceDirection.LEFT)
        {
            dx = -1;
        }

        if (!IsPieceCanMove(dir))
        {
            return;
        }

        // delete piece
        foreach (Point p in Piece.Points)
        {
            Board.GetTile(p.X, p.Y).Color = Color.white;
        }

        // move one step down
        foreach (Point p in Piece.Points)
        {
            p.X += dx;
            p.Y += dy;
        }

        // draw piece
        foreach (Point p in Piece.Points)
        {
            Board.GetTile(p.X, p.Y).Color = Piece.Color;
        }
    }
Esempio n. 4
0
        public Piece GetNextPiece(int x, int y, PieceDirection dir)
        {
            switch (dir)
            {
            case PieceDirection.Up:
                y--;
                break;

            case PieceDirection.Down:
                y++;
                break;

            case PieceDirection.Left:
                x--;
                break;

            case PieceDirection.Right:
                x++;
                break;
            }

            return(GetPiece(x, y));
        }
        public void AddPiece(PieceColor color, int x, int y, PieceDirection forward)
        {
            var listToAdd = color == PieceColor.Black ? AlivePlayerOnePieces : AlivePlayerTwoPieces;

            listToAdd.Add(new CheckersPiece(x, y, color, forward));
        }
Esempio n. 6
0
        private void DrawPiece(Context cr, PieceType Piece, PieceDirection Direction, double x, double y)
        {
            int idx = (int)Piece;
            if (idx < (int)PieceType.FUHYOU || idx > (int)PieceType.OUSHOU)
                return;

            cr.Save();
            cr.Translate(x, y);
            if (Direction == PieceDirection.DOWN)
            {
                cr.Rotate(180 * Math.PI / 180);
                cr.Translate(-FIELD_SIZE,-FIELD_SIZE);
            }
            cr.Scale(FIELD_SIZE/PieceGraphics[idx].Dimensions.Width, FIELD_SIZE/PieceGraphics[idx].Dimensions.Width);
            if (idx == (int)PieceType.OUSHOU && Direction == PieceDirection.DOWN)
            {
                GyokushouGraphic.RenderCairo(cr);
            }
            else
            {
                PieceGraphics[idx].RenderCairo(cr);
            }

            cr.Restore();
        }
Esempio n. 7
0
 public void MovePiece(PieceDirection dir)
 {
     movePiece(dir);
 }