libchess/pkg/board/pieces.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
}