Source for file Standard.php

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
// +----------------------------------------------------------------------+
// | PHP version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 2003 The PHP Group                                     |
// +----------------------------------------------------------------------+
// | This source file is subject to version 3.0 of the PHP license,       |
// | that is bundled with this package in the file LICENSE, and is        |
// | available through the world-wide-web at                              |
// | http://www.php.net/license/3_0.txt.                                  |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Gregory Beaver <cellog@php.net>                             |
// +----------------------------------------------------------------------+
//
// $Id: Standard.php,v 1.8 2006/11/18 00:09:20 cellog Exp $
/**
 * A standard chess game representation
 * @package Games_Chess
 * @author Gregory Beaver <cellog@php.net>
 */
/**
 * The parent class
 */
require_once 'Games/Chess.php';
 
/**
 * Standard chess game
 * @package Games_Chess
 * @author Gregory Beaver <cellog@php.net>
 */
class Games_Chess_Standard extends Games_Chess {
    /**
     * The chess pieces
     * @access private
     * @var array 
     */
    var $_pieces;
    
    /**
     * Set up a blank chess board
     */
    function blankBoard()
    {
        parent::blankBoard();
        $this->_pieces =
        array(
            'WR1' => false,
            'WN1' => false,
            'WB1' => false,
            'WQ' => false,
            'WK' => false,
            'WB2' => false,
            'WN2' => false,
            'WR2' => false,
            
            'WP1' => false,
            'WP2' => false,
            'WP3' => false,
            'WP4' => false,
            'WP5' => false,
            'WP6' => false,
            'WP7' => false,
            'WP8' => false,
            
            'BP1' => false,
            'BP2' => false,
            'BP3' => false,
            'BP4' => false,
            'BP5' => false,
            'BP6' => false,
            'BP7' => false,
            'BP8' => false,
            
            'BR1' => false,
            'BN1' => false,
            'BB1' => false,
            'BQ' => false,
            'BK' => false,
            'BB2' => false,
            'BN2' => false,
            'BR2' => false,
        );
    }
 
    /**
     * Set up a starting position for a new chess game
     * @access protected
     */
    function _setupStartingPosition()
    {
        $this->_board = array(
'a8' => 'BR1', 'b8' => 'BN1', 'c8' => 'BB1', 'd8' => 'BQ', 'e8' => 'BK', 'f8' => 'BB2', 'g8' => 'BN2', 'h8' => 'BR2',
'a7' => 'BP1', 'b7' => 'BP2', 'c7' => 'BP3', 'd7' => 'BP4', 'e7' => 'BP5', 'f7' => 'BP6', 'g7' => 'BP7', 'h7' => 'BP8',
'a6' => 'a6', 'b6' => 'b6', 'c6' => 'c6', 'd6' => 'd6', 'e6' => 'e6', 'f6' => 'f6', 'g6' => 'g6', 'h6' => 'h6',
'a5' => 'a5', 'b5' => 'b5', 'c5' => 'c5', 'd5' => 'd5', 'e5' => 'e5', 'f5' => 'f5', 'g5' => 'g5', 'h5' => 'h5',
'a4' => 'a4', 'b4' => 'b4', 'c4' => 'c4', 'd4' => 'd4', 'e4' => 'e4', 'f4' => 'f4', 'g4' => 'g4', 'h4' => 'h4',
'a3' => 'a3', 'b3' => 'b3', 'c3' => 'c3', 'd3' => 'd3', 'e3' => 'e3', 'f3' => 'f3', 'g3' => 'g3', 'h3' => 'h3',
'a2' => 'WP1', 'b2' => 'WP2', 'c2' => 'WP3', 'd2' => 'WP4', 'e2' => 'WP5', 'f2' => 'WP6', 'g2' => 'WP7', 'h2' => 'WP8',
'a1' => 'WR1', 'b1' => 'WN1', 'c1' => 'WB1', 'd1' => 'WQ', 'e1' => 'WK', 'f1' => 'WB2', 'g1' => 'WN2', 'h1' => 'WR2',
        );
        $this->_halfMoves = 0;
        $this->_moveNumber = 1;
        $this->_move = 'W';
        $this->_WCastleQ = true;
        $this->_WCastleK = true;
        $this->_BCastleQ = true;
        $this->_BCastleK = true;
        $this->_enPassantSquare = '-';
        $this->_pieces =
        array(
            'WR1' => 'a1',
            'WN1' => 'b1',
            'WB1' => 'c1',
            'WQ' => 'd1',
            'WK' => 'e1',
            'WB2' => 'f1',
            'WN2' => 'g1',
            'WR2' => 'h1',
            
            'WP1' => array('a2', 'P'),
            'WP2' => array('b2', 'P'),
            'WP3' => array('c2', 'P'),
            'WP4' => array('d2', 'P'),
            'WP5' => array('e2', 'P'),
            'WP6' => array('f2', 'P'),
            'WP7' => array('g2', 'P'),
            'WP8' => array('h2', 'P'),
            
            'BP1' => array('a7', 'P'),
            'BP2' => array('b7', 'P'),
            'BP3' => array('c7', 'P'),
            'BP4' => array('d7', 'P'),
            'BP5' => array('e7', 'P'),
            'BP6' => array('f7', 'P'),
            'BP7' => array('g7', 'P'),
            'BP8' => array('h7', 'P'),
            
            'BR1' => 'a8',
            'BN1' => 'b8',
            'BB1' => 'c8',
            'BQ' => 'd8',
            'BK' => 'e8',
            'BB2' => 'f8',
            'BN2' => 'g8',
            'BR2' => 'h8',
        );
    }
 
    /**
     * Add a piece to the chessboard
     * @param W|Bpiece color
     * @param K|Q|R|N|P|BPiece type
     * @param string [a-h][1-8] algebraic location of piece
     * @return true|PEAR_Error
     * @throws GAMES_CHESS_ERROR_INVALIDSQUARE
     * @throws GAMES_CHESS_ERROR_DUPESQUARE
     * @throws GAMES_CHESS_ERROR_MULTIPIECE
     */
    function addPiece($color, $type, $square)
    {
        if (!isset($this->_board[$square])) {
            return $this->raiseError(GAMES_CHESS_ERROR_INVALIDSQUARE,
                array('square' => $square));
        }
        if ($this->_board[$square] != $square) {
            $dpiece = $this->_board[$square];
            if ($dpiece{1} == 'P') {
                $dpiece = $this->_pieces[$dpiece][1];
            } else {
                $dpiece = $dpiece{1};
            }
            return $this->raiseError(GAMES_CHESS_ERROR_DUPESQUARE,
                array('piece' => $type, 'dpiece' => $dpiece, 'square' => $square));
        }
        switch ($type) {
            case 'B' :
            case 'N' :
            case 'R' :
                $piece_name = $color . $type;
                if (!$this->_pieces[$piece_name . '1']) {
                    $this->_board[$square] = $piece_name . '1';
                    $this->_pieces[$piece_name . '1'] = $square;
                } elseif (!$this->_pieces[$piece_name . '2']) {
                    $this->_board[$square] = $piece_name . '2';
                    $this->_pieces[$piece_name . '2'] = $square;
                } else {
                    // handle promoted pawns
                    for ($col = 1; $col <= 8; $col++) {
                        if (!$this->_pieces[$color . 'P' . $col]) {
                            $this->_pieces[$color . 'P' . $col] =
                                array($square, $type);
                            $this->_board[$square] = $color . 'P' . $col;
                            break 2;
                        }
                    }
                    return $this->raiseError(GAMES_CHESS_ERROR_MULTIPIECE,
                        array('color' => $color, 'piece' => $type));
 
                }
            break;
            case 'Q' :
                $piece_name = $color . 'Q';
                if (!$this->_pieces[$piece_name]) {
                    $this->_board[$square] = $piece_name;
                    $this->_pieces[$piece_name] = $square;
                } else {
                    // handle promoted pawns
                    for ($col = 1; $col <= 8; $col++) {
                        if (!$this->_pieces[$color . 'P' . $col]) {
                            $this->_pieces[$color . 'P' . $col] =
                                array($square, 'Q');
                            $this->_board[$square] = $color . 'P' . $col;
                            break 2;
                        }
                    }
                    return $this->raiseError(GAMES_CHESS_ERROR_MULTIPIECE,
                        array('color' => $color, 'piece' => $type));
                }
            break;
            case 'P' :
                // handle regular pawns
                for ($col = 1; $col <= 8; $col++) {
                    if (!$this->_pieces[$color . 'P' . $col]) {
                        $this->_pieces[$color . 'P' . $col] =
                            array($square, 'P');
                        $this->_board[$square] = $color . 'P' . $col;
                        break 2;
                    }
                }
                return $this->raiseError(GAMES_CHESS_ERROR_MULTIPIECE,
                    array('color' => $color, 'piece' => $type));
            break;
            case 'K' :
                if (!$this->_pieces[$color . 'K']) {
                    $this->_pieces[$color . 'K'] = $square;
                    $this->_board[$square] = $color . 'K';
                } else {
                    return $this->raiseError(GAMES_CHESS_ERROR_MULTIPIECE,
                        array('color' => $color, 'piece' => $type));
                }
            break;
        }
        return true;
    }
    
    /**
     * Generate a representation of the chess board and pieces for use as a
     * direct translation to a visual chess board
     * @return array 
     */
    function toArray()
    {
        $ret = array();
        foreach ($this->_board as $square => $piece) {
            if ($piece == $square) {
                $ret[$square] = false;
                continue;
            }
            $lower = $piece{0};
            if (is_array($this->_pieces[$piece])) {
                $piece = $this->_pieces[$piece][1];
            } else {
                $piece = $piece{1};
            }
            if ($lower == 'B') {
                $piece = strtolower($piece);
            }
            $ret[$square] = $piece;
        }
        uksort($ret, array($this, '_sortToArray'));
        return $ret;
    }
    
    /**
     * Sort two algebraic coordinates for easy display by foreach() iteration
     * @param string 
     * @param string 
     * @access private
     */
    function _sortToArray($a, $b)
    {
        if ($a == $b) {
            return 0;
        }
        if ($a{1} == $b{1}) {
            return strnatcmp($a{0}, $b{0});
        }
        if ($a{0} == $b{0}) {
            return strnatcmp($b{1}, $a{1});
        }
        if ($b{1} > $a{1}) {
            return 1;
        }
        if ($a{1} > $b{1}) {
            return -1;
        }
    }
    
    /**
     * Render the current board position into Forsyth-Edwards Notation
     *
     * This method only renders the board contents, not the castling and other
     * information
     * @return string 
     * @access protected
     */
    function _renderFen()
    {
        $fen = '';
        $ws = 0;
        $saverow = '8';
        foreach ($this->_board as $square => $piece) {
            if ($square{1} != $saverow) {
                // if we have just moved to the next rank,
                // output any whitespace, and a '/'
                if ($ws) {
                    $fen .= $ws;
                }
                $fen .= '/';
                $ws = 0;
                $saverow = $square{1};
            }
            if ($square == $piece) {
                // increment whitespace - no piece on this square
                $ws++;
            } else {
                // add any whitespace and reset
                if ($ws) {
                    $fen .= $ws;
                }
                $ws = 0;
                if (is_array($this->_pieces[$piece])) {
                    // add pawns/promoted pawns
                    $p = ($piece{0} == 'W') ? $this->_pieces[$piece][1] :
                        strtolower($this->_pieces[$piece][1]);
                } else {
                    // add pieces
                    $p = ($piece{0} == 'W') ? $piece{1} : strtolower($piece{1});
                }
                $fen .= $p;
            }
        }
        // add any trailing whitespace
        if ($ws) {
            $fen .= $ws;
        }
        return $fen;
    }
 
    /**
     * Get the location of every piece on the board of color $color
     * @access protected
     * @param W|Bcolor of pieces to check
     */
    function _getAllPieceLocations($color)
    {
        $ret = array();
        foreach ($this->_pieces as $name => $loc) {
            if ($name{0} == $color) {
                $where =  (is_array($loc) ? $loc[0] : $loc);
                if ($where) {
                    $ret[] = $where;
                }
            }
        }
        return $ret;
    }
    
    /**
     * Used to determine check
     *
     * Retrieve all of the moves of the pieces matching the color passed in.
     * @param W|B
     * @return array 
     * @access protected
     */
    function _getPossibleChecks($color)
    {
        $ret = array();
        foreach ($this->_pieces as $name => $loc) {
            if (!$loc) {
                continue;
            }
            if ($name{0} == $color) {
                if ($name{1} == 'P') {
                    $ret[$name] = $this->getPossibleMoves($loc[1], $loc[0], $color, false);
                } else {
                    $ret[$name] = $this->getPossibleMoves($name{1}, $loc, $color, false);
                }
            }
        }
        return $ret;
    }
    
    /**
     * Determine whether one side's king is in check by the other side's pieces
     * @param W|Bcolor of pieces to determine enemy check
     * @return string|array|falsesquare of checking piece(s) or false
     */
    function inCheck($color)
    {
        $ret = array();
        $king = $this->_pieces[$color . 'K'];
        $possible = $this->_getPossibleChecks($color == 'W' ? 'B' : 'W');
        foreach ($possible as $piece => $squares) {
            if (in_array($king, $squares)) {
                $loc = $this->_pieces[$piece];
                $ret[] = is_array($loc) ? $loc[0] : $loc;
            }
        }
        if (!count($ret)) {
            return false;
        }
        if (count($ret) == 1) {
            return $ret[0];
        }
        return $ret;
    }
    
    /**
     * Mark a piece as having been taken.  No validation is performed
     * @param string [a-h][1-8]
     * @access protected
     */
    function _takePiece($piece)
    {
        if (isset($this->_pieces[$this->_board[$piece]])) {
            $this->_pieces[$this->_board[$piece]] = false;
        }
    }
    
    /**
     * Move a piece from one square to another, disregarding any existing pieces
     *
     * {@link _takePiece()} should always be used prior to this method.  No
     * validation is performed
     * @param string [a-h][1-8] square the piece resides on
     * @param string [a-h][1-8] square the piece moves to
     * @param string Piece to promote to if this is a promotion move
     */
    function _movePiece($from, $to, $promote = '')
    {
        if (isset($this->_pieces[$this->_board[$from]])) {
            $newto = $this->_pieces[$this->_board[$from]];
            if (is_array($newto)) {
                $newto[0] = $to;
                if ($promote && ($to{1} == '8' || $to{1} == '1')) {
                    $newto[1] = $promote;
                }
            } else {
                $newto = $to;
            }
            $this->_pieces[$this->_board[$from]] = $newto;
        }
    }
    
    /**
     * Translate an algebraic coordinate into the color and name of a piece,
     * or false if no piece is on that square
     * @return false|arrayFormat array('color' => B|W, 'piece' => P|R|Q|N|K|B)
     * @param string [a-h][1-8]
     * @access protected
     */
    function _squareToPiece($square)
    {
        if ($this->_board[$square] != $square) {
            $piece = $this->_board[$square];
            if ($piece{1} == 'P') {
                $color = $piece{0};
                $piece = $this->_pieces[$piece][1];
            } else {
                $color = $piece{0};
                $piece = $piece{1};
            }
            return array('color' => $color, 'piece' => $piece);
        } else {
            return false;
        }
    }
    
    /**
     * Retrieve the locations of all pieces of the same type as $piece
     * @param K|B|N|R|W|P
     * @param W|B
     * @param string [a-h][1-8] optional square of piece to exclude from the listing
     * @access protected
     * @return array 
     */
    function _getAllPieceSquares($piece, $color, $exclude = null)
    {
        $ret = array();
        foreach ($this->_pieces as $name => $loc) {
            if (!$loc) {
                continue;
            }
            if ($name{0} != $color) {
                continue;
            }
            if ($name{1} == 'P') {
                if ($loc[1] != $piece || $loc[0] == $exclude) {
                    continue;
                } else {
                    $ret[] = $loc[0];
                    continue;
                }
            }
            if ($loc == $exclude) {
                continue;
            }
            if ($name{1} != $piece) {
                continue;
            }
            $ret[] = $loc;
        }
        return $ret;
    }
    
    /**
     * @return string|PEAR_Error
     * @param array contents returned from {@link parent::_parseMove()}
     *               in other words, not array(GAMES_CHESS_PIECEMOVE =>
     *               array('piece' => 'K', ...)), but array('piece' => 'K', ...)
     * @param W|Bcurrent side moving
     */
    function _getSquareFromParsedMove($parsedmove, $color = null)
    {
        if (is_null($color)) {
            $color = $this->_move;
        }
        switch ($parsedmove['piece']) {
            case 'K' :
                if (in_array($parsedmove['square'],
                    $this->getPossibleKingMoves($this->_pieces[$color . 'K'], $color))) {
                    return $this->_pieces[$color . 'K'];
                }
            break;
            case 'Q' :
            case 'B' :
            case 'R' :
            case 'N' :
                if ($parsedmove['disambiguate']) {
                    if (strlen($parsedmove['disambiguate']) == 2) {
                        $square = $parsedmove['disambiguate'];
                    } elseif (is_numeric($parsedmove['disambiguate'])) {
                        $row = $parsedmove['disambiguate'];
                    } else {
                        $col = $parsedmove['disambiguate'];
                    }
                } else {
                    $others = array();
                    $others = $this->_getAllPieceSquares($parsedmove['piece'],
                                                         $color);
                    $disambiguate = '';
                    $ambiguous = array();
                    if (count($others)) {
                        foreach ($others as $square) {
                            if (in_array($parsedmove['square'],
                                    $this->getPossibleMoves($parsedmove['piece'],
                                                            $square,
                                                            $color))) {
                                // other pieces can move to this square - need to disambiguate
                                $ambiguous[] = $square;
                            }
                        }
                    }
                    if (count($ambiguous) > 1) {
                        $pieces = implode($ambiguous, ' ');
                        return $this->raiseError(
                            GAMES_CHESS_ERROR_TOO_AMBIGUOUS,
                            array('san' => $parsedmove['piece'] .
                                $parsedmove['disambiguate'] . $parsedmove['takes']
                                . $parsedmove['square'],
                                  'squares' => $pieces,
                                  'piece' => $parsedmove['piece']));
                    }
                    $square = $col = $row = null;
                }
                $potentials = array();
                foreach ($this->_pieces as $name => $value) {
                    if (!$value) {
                        continue;
                    }
                    if ($name{0} != $color) {
                        continue;
                    }
                    if (isset($square)) {
                        if ($name{1} == $parsedmove['piece'] &&
                              $value[0] == $square) {
                            return $square;
                        }
                        if ($name{1} == 'P' && $value[0] == $square &&
                              $value[1] == $parsedmove['piece']) {
                            return $square;
                        }
                    } elseif (isset($col)) {
                        if ($name{1} == $parsedmove['piece'] &&
                              $value{0} == $col) {
                            if (in_array($parsedmove['square'],
                                  $this->getPossibleMoves($parsedmove['piece'],
                                                            $value, $color))) {
                                $potentials[] = $value;
                            }
                        }
                        if ($name{1} == 'P' && $value[0]{0} == $col &&
                              $value[1] == $parsedmove['piece']) {
                            if (in_array($parsedmove['square'],
                                  $this->getPossibleMoves($parsedmove['piece'],
                                                            $value[0], $color))) {
                                $potentials[] = $value[0];
                            }
                        }
                    } elseif (isset($row)) {
                        if ($name{1} == $parsedmove['piece'] &&
                              $value{1} == $row) {
                            if (in_array($parsedmove['square'],
                                  $this->getPossibleMoves($parsedmove['piece'],
                                                            $value, $color))) {
                                $potentials[] = $value;
                            }
                        }
                        if ($name{1} == 'P' && $value[0]{1} == $row &&
                              $value[1] == $parsedmove['piece']) {
                            if (in_array($parsedmove['square'],
                                  $this->getPossibleMoves($parsedmove['piece'],
                                                            $value[0], $color))) {
                                $potentials[] = $value[0];
                            }
                        }
                    } else {
                        if ($name{1} == $parsedmove['piece']) {
                            if (in_array($parsedmove['square'],
                                  $this->getPossibleMoves($parsedmove['piece'],
                                                            $value, $color))) {
                                $potentials[] = $value;
                            }
                        } elseif ($name{1} == 'P' &&
                              $value[1] == $parsedmove['piece']) {
                            if (in_array($parsedmove['square'],
                                  $this->getPossibleMoves($parsedmove['piece'],
                                                            $value[0], $color))) {
                                $potentials[] = $value[0];
                            }
                        }
                    }
                }
                if (count($potentials) == 1) {
                    return $potentials[0];
                }
            break;
            case 'P' :
                if ($parsedmove['disambiguate']) {
                    $square = $parsedmove['disambiguate'] . $parsedmove['takesfrom'];
                } else {
                    $square = null;
                }
                if ($parsedmove['takesfrom']) {
                    $col = $parsedmove['takesfrom'];
                } else {
                    $col = null;
                }
                $potentials = array();
                foreach ($this->_pieces as $name => $value) {
                    if ($name{0} != $color) {
                        continue;
                    }
                    if (isset($square)) {
                        if ($name{1} == 'P' && $value[0] == $square && $value[1] == 'P') {
                            return $square;
                        }
                    } elseif (isset($col)) {
                        if ($name{1} == 'P' && $value[0]{0} == $col && $value[1] == 'P') {
                            if (in_array($parsedmove['square'],
                                  $this->getPossiblePawnMoves($value[0], $color))) {
                                $potentials[] = $value[0];
                            }
                        }
                    } else {
                        if ($name{1} == 'P' && $value[1] == 'P') {
                            if (in_array($parsedmove['square'],
                                  $this->getPossiblePawnMoves($value[0], $color))) {
                                $potentials[] = $value[0];
                            }
                        }
                    }
                }
                if (count($potentials) == 1) {
                    return $potentials[0];
                }
            break;
        }
        if ($parsedmove['piece'] == 'P') {
            $san = $parsedmove['takesfrom'] . $parsedmove['takes'] . $parsedmove['square'];
        } else {
            $san = $parsedmove['piece'] .
                           $parsedmove['disambiguate'] . $parsedmove['takes'] .
                           $parsedmove['square'];
        }
        return $this->raiseError(GAMES_CHESS_ERROR_NOPIECE_CANDOTHAT,
            array('san' => $san,
                  'color' => $color));
    }
 
    /**
     * Get the location of the king
     *
     * assumes valid color input
     * @return false|string
     * @access protected
     */
    function _getKing($color = null)
    {
        if (!is_null($color)) {
            return $this->_pieces[$color . 'K'];
        } else {
            return $this->_pieces[$this->_move . 'K'];
        }
    }
    
    /**
     * Get the location of a piece
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return string|array
     * @access protected
     */
    function _getPiece($piecename)
    {
        return is_array($this->_pieces[$piecename]) ?
            $this->_pieces[$piecename][0] :
            $this->_pieces[$piecename];
    }
    
    /**
     * Determine whether a piece name is a knight
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return boolean 
     * @access protected
     */
    function _isKnight($piecename)
    {
        return $piecename{1} == 'N' ||
            ($piecename{1} == 'P' &&
                $this->_pieces[$piecename][1] == 'N');
    }
    
    /**
     * Determine whether a piece name is a queen
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return boolean 
     * @access protected
     */
    function _isQueen($piecename)
    {
        return $piecename{1} == 'Q' ||
            ($piecename{1} == 'P' &&
                $this->_pieces[$piecename][1] == 'Q');
    }
    
    /**
     * Determine whether a piece name is a bishop
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return boolean 
     * @access protected
     */
    function isBishop($piecename)
    {
        return $piecename{1} == 'B' ||
            ($piecename{1} == 'P' &&
                $this->_pieces[$piecename][1] == 'B');
    }
    
    /**
     * Determine whether a piece name is a rook
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return boolean 
     * @access protected
     */
    function isRook($piecename)
    {
        return $piecename{1} == 'R' ||
            ($piecename{1} == 'P' &&
                $this->_pieces[$piecename][1] == 'R');
    }
    
    /**
     * Determine whether a piece name is a pawn
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return boolean 
     * @access protected
     */
    function isPawn($piecename)
    {
        return $piecename{1} == 'P' &&
                $this->_pieces[$piecename][1] == 'P';
    }
    
    /**
     * Determine whether a piece name is a king
     *
     * This does NOT take an algebraic square as the argument, but the contents
     * of _board[algebraic square]
     * @param string 
     * @return boolean 
     * @access protected
     */
    function isKing($piecename)
    {
        return $piecename{1} == 'K';
    }
    
    /**
     * Determine whether it is possible to capture the piece delivering check,
     * or to interpose a piece in between the checking piece and the king
     * @param array squares that will block a checkmate
     * @param W|Bcolor of the side attempting to prevent checkmate
     * @return boolean true if it is possible to remove check
     */
    function _interposeOrCapture($squares, $color)
    {
        foreach ($this->_pieces as $name => $value) {
            if (!$value) {
                continue;
            }
            if ($name{0} != $color) {
                continue;
            }
            if ($name{1} == 'K') {
                continue;
            }
            if (is_array($value)) {
                $name = $value[1];
                $value = $value[0];
            } else {
                $name = $name{1};
            }
            $allmoves = $this->getPossibleMoves($name, $value, $color);
            foreach($squares as $square) {
                if (in_array($square, $allmoves)) {
                    // try the move, see if we're still in check
                    // if so, then the piece is pinned and cannot move
                    $this->startTransaction();
                    $this->_move = $color;
                    if (!class_exists('PEAR')) {
                        require_once 'PEAR.php';
                    }
                    PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
                    $ret = $this->moveSquare($value, $square);
                    PEAR::popErrorHandling(PEAR_ERROR_RETURN);
                    $this->_move = $color;
                    $stillchecked = $this->inCheck($color);
                    $this->rollbackTransaction();
                    if (!$stillchecked) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    /**
     * Retrieve the color of a piece from its name
     *
     * Game-specific method of retrieving the color of a piece
     * @access protected
     */
    function _getColor($name)
    {
        return $name{0};
    }
    
    /**
     * Get a list of all pieces on the board organized by the type of piece,
     * and the color of the square the piece is on.
     *
     * Used to determine basic draw conditions
     * @return array Format:
     *
     *  <pre>
     *  array(
     *    // white pieces
     *    'W' => array('B' => array('W', 'B'), // all bishops
     *                 'K' => array('W'),...
     *                ),
     *    // black pieces
     *    'B' => array('Q' => array('B'), // all queens
     *                 'K' => array('W'),... // king is on white square
     *  </pre>
     * @access protected
     */
    function _getPieceTypes()
    {
        $ret = array('W' => array(), 'B' => array());
        foreach($this->_pieces as $name => $loc) {
            if (!$loc) {
                continue;
            }
            $type = $name{1};
            if (is_array($loc)) {
                $type = $loc[1];
                $loc = $loc[0];
            }
            $ret[$name{0}][$type][] = $this->_getDiagonalColor($loc);
        }
        return $ret;
    }
}
?>