Esempio n. 1
0
        public bool move( Play _play )
        {
            if (!isPtInTable(_play.oldPosition))
                return false;

            if (!isPtInTable(_play.newPosition))
                return false;

            TableSquare oldSquare = m_table[_play.oldPosition.X, _play.oldPosition.Y];
            TableSquare newSquare = m_table[_play.newPosition.X, _play.newPosition.Y];
            Piece   pieceEaten = null;

            if( oldSquare.Piece == null )
            {
                // There's no piece moving in this play
                return false;
            }

            // Now we double check if this play is possible
            //if( !oldSquare.Piece.vetPossibleMovements.Contains( _play.newPosition ) )
            //{
            //    // Trying to make a move to an invalid position
            //    return false;
            //}

            if( newSquare.Piece != null )
            {
                // Check if a piece is eaten
                pieceEaten = newSquare.Piece;

                if( oldSquare.Piece.isBlack == pieceEaten.isBlack )
                {
                    // Trying to eat a piece of your own team
                    return false;
                }
            }

            // Move the piece.
            newSquare.Piece = oldSquare.Piece;
            oldSquare.Piece = null;

            newSquare.Piece.Position = _play.newPosition;

            // Hold the eaten piece for later count or something.
            if( pieceEaten != null )
            {
                pieceEaten.SetPosition( -1, -1 );

                if( pieceEaten.isBlack )
                {
                    m_vecBlackPieces.Remove( pieceEaten );
                    m_vecDeadBlackPieces.Add( pieceEaten );
                }
                else
                {
                    m_vecWhitePieces.Remove( pieceEaten );
                    m_vecDeadWhitePieces.Add( pieceEaten );
                }

                if( pieceEaten is King )
                    m_bCheckMate = true;
            }

            // Calculate the next possible movements
            if( newSquare.Piece.isBlack )
            {
                //calculateBlackPiecesPosition( false );
                calculateWhitePiecesPosition( m_bVerifyCheck );
            }
            else
            {
                //calculateWhitePiecesPosition( false );
                calculateBlackPiecesPosition( m_bVerifyCheck );
            }

            // Verify if the game is over (checkmate)
            if( m_bVerifyCheck )
            {
                m_bCheckMate = isInCheckMate( !newSquare.Piece.isBlack );
            }

            return true;
        }
Esempio n. 2
0
        public static Play operator -(Table newTable, Table oldTable)
        {
            // return the play that represents the difference between these 2 tables.

            TableSquare tableSquareNew1 = null,
                        tableSquareOld1 = null,
                        tableSquareNew2 = null,
                        tableSquareOld2 = null;

            Point       pos1 = new Point(),
                        pos2 = new Point();

            bool bFinish = false;
            for (int nRow = 0; nRow < TABLE_SIZE; ++nRow)
            {
                for (int nCol = 0; nCol < TABLE_SIZE; ++nCol)
                {
                    TableSquare tableSquareTempNew = newTable.m_table[nRow, nCol],
                                tableSquareTempOld = oldTable.m_table[nRow, nCol];

                    if ((tableSquareTempNew.Piece == null) && (tableSquareTempOld.Piece == null))
                        continue;
                    if ((tableSquareTempNew.Piece != null) && (tableSquareTempOld.Piece != null)
                        && tableSquareTempNew.Piece.Equals(tableSquareTempOld.Piece))
                        continue;

                    // The piece changed between these two tables.
                    //  Save the positions.
                    if ((tableSquareNew1 == null) && (tableSquareOld1 == null))
                    {
                        tableSquareNew1 = tableSquareTempNew;
                        tableSquareOld1 = tableSquareTempOld;
                        pos1.X = nRow;
                        pos1.Y = nCol;
                    }
                    else
                    {
                        tableSquareNew2 = tableSquareTempNew;
                        tableSquareOld2 = tableSquareTempOld;
                        pos2.X = nRow;
                        pos2.Y = nCol;

                        bFinish = true;
                        break;
                    }
                }

                if (bFinish)
                    break;
            }

            if (!bFinish)
                return null;

            Play play = new Play();
            if ((tableSquareOld1.Piece != null) && (tableSquareNew1.Piece == null))
            {
                play.oldPosition = pos1;
                play.newPosition = pos2;
            }
            else if ((tableSquareOld2.Piece != null) && (tableSquareNew2.Piece == null))
            {
                play.oldPosition = pos2;
                play.newPosition = pos1;
            }

            return play;
        }
Esempio n. 3
0
        private List<Table> generateTables(Table table)
        {
            List<Table> lstTables = new List<Table>();

            for (int nRow = 0; nRow < table.TableSize; ++nRow)
            {
                for (int nCol = 0; nCol < table.TableSize; ++nCol)
                {
                    Table.TableSquare tableSquare = table.getTableSquare(nRow, nCol);

                    // Verify if the is a piece in this square.
                    if (tableSquare.Piece == null)
                        continue;

                    // Verify if the piece is mine.
                    if (tableSquare.Piece.isBlack != m_bTeamTemp)
                        continue;

                    List<Point> lstPositions = tableSquare.Piece.vetPossibleMovements;
                    foreach (Point position in lstPositions)
                    {
                        Play play = new Play();
                        play.oldPosition = new Point(nRow, nCol);
                        play.newPosition = position;
                        Table newTable = table + play;
                        lstTables.Add(newTable);
                    }
                }
            }

            return lstTables;
        }
Esempio n. 4
0
        protected bool isValidMove( Point _newPosition )
        {
            Play play = new Play( );
            play.oldPosition = m_position;
            play.newPosition = _newPosition;

            m_parentTable.VerifyCheck = false;
            Table newTable = m_parentTable + play;
            m_parentTable.VerifyCheck = true;

            if( newTable.isInCheck( m_bBlack ) )
            {
                return false;
            }

            return true;
        }
Esempio n. 5
0
        protected bool ClickOnTarget(Rectangle rectMouse)
        {
            if (m_listTargetsMovements == null)
                return false;

            if (m_listTargetsMovements.Count == 0)
                return false;

            for (int index = 0; index < m_listTargetsMovements.Count; index++ )
            {
                Point ptSquare = m_listTargetsMovements[index];
                Rectangle rectTarget = m_gameTable.getTableSquare(ptSquare.X, ptSquare.Y).BoundingBox;

                if(rectTarget.Intersects(rectMouse) )
                {
                    bool bKilled = false;
                    if (m_gameTable.getTableSquare(ptSquare.X, ptSquare.Y).Piece != null)
                    {
                        bKilled = true;
                    }

                    Play play = new Play();
                    play.newPosition = ptSquare;
                    play.oldPosition = m_pointSquareSelection;
                    m_gameTable.move(play);

                    m_soundKlik.Play();

                    if (bKilled)
                        m_soundKill.Play();

                    return true;
                }
            }

            return false;
        }