206 lines
3.6 KiB
Go
206 lines
3.6 KiB
Go
|
package board
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
"strings"
|
||
|
|
||
|
"code.c-base.org/gochess/libchess/pkg/runes"
|
||
|
)
|
||
|
|
||
|
// PieceType defines the type of a piece
|
||
|
type PieceType uint8
|
||
|
|
||
|
// The following PieceTypes exist
|
||
|
const (
|
||
|
NoPieceType PieceType = iota
|
||
|
King
|
||
|
Queen
|
||
|
Rook
|
||
|
Bishop
|
||
|
Knight
|
||
|
Pawn
|
||
|
)
|
||
|
|
||
|
func (pt PieceType) String() string {
|
||
|
switch pt {
|
||
|
case King:
|
||
|
return "k"
|
||
|
case Queen:
|
||
|
return "q"
|
||
|
case Rook:
|
||
|
return "r"
|
||
|
case Bishop:
|
||
|
return "b"
|
||
|
case Knight:
|
||
|
return "n"
|
||
|
case Pawn:
|
||
|
return "p"
|
||
|
default:
|
||
|
return "-"
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// PromotableTo returns true if a pawn can be promoted to the given PieceType.
|
||
|
func (pt PieceType) PromotableTo() bool {
|
||
|
switch pt {
|
||
|
case Queen, Rook, Bishop, Knight:
|
||
|
return true
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// PieceTypes returns a slice of all piece types.
|
||
|
func PieceTypes() [6]PieceType {
|
||
|
return [6]PieceType{King, Queen, Rook, Bishop, Knight, Pawn}
|
||
|
}
|
||
|
|
||
|
// Piece is defined as
|
||
|
type Piece uint8
|
||
|
|
||
|
// The following Pieces exist:
|
||
|
const (
|
||
|
NoPiece Piece = iota
|
||
|
// White
|
||
|
WhiteKing
|
||
|
WhiteQueen
|
||
|
WhiteRook
|
||
|
WhiteBishop
|
||
|
WhiteKnight
|
||
|
WhitePawn
|
||
|
// Black
|
||
|
BlackKing
|
||
|
BlackQueen
|
||
|
BlackRook
|
||
|
BlackBishop
|
||
|
BlackKnight
|
||
|
BlackPawn
|
||
|
)
|
||
|
|
||
|
// AllPieces returns a []Piece containing with all available Pieces.
|
||
|
func AllPieces() []Piece {
|
||
|
return []Piece{
|
||
|
WhiteKing, WhiteQueen, WhiteRook, WhiteBishop, WhiteKnight, WhitePawn,
|
||
|
BlackKing, BlackQueen, BlackRook, BlackBishop, BlackKnight, BlackPawn,
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// NewPiece returns an initialized Piece based on the given PieceType and Color.
|
||
|
func NewPiece(t PieceType, c Color) Piece {
|
||
|
for _, p := range AllPieces() {
|
||
|
if p.Color() == c && p.Type() == t {
|
||
|
return p
|
||
|
}
|
||
|
}
|
||
|
return NoPiece
|
||
|
}
|
||
|
|
||
|
// NewPieceByFEN returns an initialized piece based on the given FEN letter representation.
|
||
|
func NewPieceByFEN(c rune) Piece {
|
||
|
switch c {
|
||
|
case 'K':
|
||
|
return WhiteKing
|
||
|
case 'Q':
|
||
|
return WhiteQueen
|
||
|
case 'R':
|
||
|
return WhiteRook
|
||
|
case 'B':
|
||
|
return WhiteBishop
|
||
|
case 'N':
|
||
|
return WhiteKnight
|
||
|
case 'P':
|
||
|
return WhitePawn
|
||
|
case 'k':
|
||
|
return BlackKing
|
||
|
case 'q':
|
||
|
return BlackQueen
|
||
|
case 'r':
|
||
|
return BlackRook
|
||
|
case 'b':
|
||
|
return BlackBishop
|
||
|
case 'n':
|
||
|
return BlackKnight
|
||
|
case 'p':
|
||
|
return BlackPawn
|
||
|
case '1':
|
||
|
return NoPiece
|
||
|
default:
|
||
|
panic(fmt.Errorf("unable to parse piece: %s", string(c)))
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func (p Piece) String() string {
|
||
|
s := p.Type().String()
|
||
|
if p.Color() == White {
|
||
|
s = strings.ToUpper(s)
|
||
|
}
|
||
|
return s
|
||
|
}
|
||
|
|
||
|
// Rune returns the UTF-8 char for this piece.
|
||
|
func (p Piece) Rune() string {
|
||
|
var r rune
|
||
|
switch p.Color() {
|
||
|
case White:
|
||
|
switch p.Type() {
|
||
|
case King:
|
||
|
r = runes.WhiteKing
|
||
|
case Queen:
|
||
|
r = runes.WhiteQueen
|
||
|
case Rook:
|
||
|
r = runes.WhiteRook
|
||
|
case Bishop:
|
||
|
r = runes.WhiteBishop
|
||
|
case Knight:
|
||
|
r = runes.WhiteKnight
|
||
|
case Pawn:
|
||
|
r = runes.WhitePawn
|
||
|
}
|
||
|
case Black:
|
||
|
switch p.Type() {
|
||
|
case King:
|
||
|
r = runes.BlackKing
|
||
|
case Queen:
|
||
|
r = runes.BackQueen
|
||
|
case Rook:
|
||
|
r = runes.BlackRook
|
||
|
case Bishop:
|
||
|
r = runes.BlackBishop
|
||
|
case Knight:
|
||
|
r = runes.BlackKnight
|
||
|
case Pawn:
|
||
|
r = runes.BlackPawn
|
||
|
}
|
||
|
}
|
||
|
return string(r)
|
||
|
}
|
||
|
|
||
|
// Type returns the type of the piece.
|
||
|
func (p Piece) Type() PieceType {
|
||
|
switch p {
|
||
|
case WhiteKing, BlackKing:
|
||
|
return King
|
||
|
case WhiteQueen, BlackQueen:
|
||
|
return Queen
|
||
|
case WhiteRook, BlackRook:
|
||
|
return Rook
|
||
|
case WhiteBishop, BlackBishop:
|
||
|
return Bishop
|
||
|
case WhiteKnight, BlackKnight:
|
||
|
return Knight
|
||
|
case WhitePawn, BlackPawn:
|
||
|
return Pawn
|
||
|
}
|
||
|
return NoPieceType
|
||
|
}
|
||
|
|
||
|
// Color returns the color of the piece.
|
||
|
func (p Piece) Color() Color {
|
||
|
switch p {
|
||
|
case WhiteKing, WhiteQueen, WhiteRook, WhiteBishop, WhiteKnight, WhitePawn:
|
||
|
return White
|
||
|
case BlackKing, BlackQueen, BlackRook, BlackBishop, BlackKnight, BlackPawn:
|
||
|
return Black
|
||
|
}
|
||
|
return NoColor
|
||
|
}
|