Add parsers for string representations of positions, and add a rudimentary console-based game

Author: thijzert

.resources/doc_domain-model_chesseract-mermaid.svg

@@ -79,6 +79,26 @@ func (Boring2D) AllPositions() []Position {
 	return rv
 }
 
+// ParsePosition converts a string representation into a Position of the correct type
+func (Boring2D) ParsePosition(s string) (Position, error) {
+	if len(s) != 2 {
+		return invalidPosition{}, errInvalidFormat
+	}
+
+	rv := position2D{}
+	for i, r := range s {
+		if i%2 == 0 {
+			rv[i] = int(r - 'a')
+		} else {
+			rv[i] = int(r - '1')
+		}
+		if rv[i] < 0 || rv[i] >= 8 {
+			return invalidPosition{}, errInvalidFormat
+		}
+	}
+	return rv, nil
+}
+
 // CanMove tests whether a piece can move to the specified new position on the board.
 // Note: this only tests movement rules; the check check is performed elsewhere.
 func (Boring2D) CanMove(board Board, piece Piece, pos Position) bool {
@@ -202,6 +222,25 @@ func normalise2d(dx, dy int) (vx, vy, r int) {
 }
 
 // ApplyMove performs a move on the board, and returns the resulting board
-func (Boring2D) ApplyMove(Board, Move) (Board, error) {
-	return Board{}, fmt.Errorf("not implemented")
+func (rs Boring2D) ApplyMove(board Board, move Move) (Board, error) {
+	piece, ok := board.At(move.From)
+	if !ok {
+		return Board{}, errIllegalMove
+	}
+
+	if !rs.CanMove(board, piece, move.To) {
+		return Board{}, errIllegalMove
+	}
+
+	newBoard := board.movePiece(move)
+
+	// TODO: check if this results in the player being in check
+
+	if newBoard.Turn == BLACK {
+		newBoard.Turn = WHITE
+	} else {
+		newBoard.Turn = BLACK
+	}
+
+	return newBoard, nil
 }

chesseract/boring2D.go

@@ -2,7 +2,9 @@ package chesseract
 
 import (
 	"bytes"
+	"math/rand"
 	"testing"
+	"time"
 )
 
 func TestEquality(t *testing.T) {
@@ -43,6 +45,35 @@ func logMatch(t *testing.T, m Match, highlight []Position) {
 	t.Logf("\n%s", &b)
 }
 
+func TestPositionParser(t *testing.T) {
+	rs := Boring2D{}
+	invalidValues := []string{
+		"",
+		"a1a1",
+		"e9",
+		" c",
+	}
+	for _, s := range invalidValues {
+		p, err := rs.ParsePosition(s)
+		if err == nil {
+			t.Logf("String '%s' decodes into '%s' - not good", s, p)
+			t.Fail()
+		}
+	}
+
+	// Test every valid value
+	for _, p := range rs.AllPositions() {
+		q, err := rs.ParsePosition(p.String())
+		if err != nil {
+			t.Logf("Error parsing position '%s': %v", p, err)
+			t.Fail()
+		} else if !p.Equals(q) {
+			t.Logf("Position '%s' turns into '%s'", p, q)
+			t.Fail()
+		}
+	}
+}
+
 func TestBoring2DDefaultBoard(t *testing.T) {
 	rs := Boring2D{}
 	board := rs.DefaultBoard()
@@ -86,7 +117,9 @@ func TestBoring2DDefaultBoard(t *testing.T) {
 
 func TestVeryInvalidMoves(t *testing.T) {
 	rs := Boring2D{}
-	board := Board{Pieces: []Piece{}}
+	board := Board{Pieces: []Piece{
+		{KING, WHITE, invalidPosition{}},
+	}}
 
 	type testCase struct {
 		PieceType PieceType
@@ -100,6 +133,8 @@ func TestVeryInvalidMoves(t *testing.T) {
 		{19, position2D{3, 3}, position2D{5, 3}},
 		{BISHOP, position2D{3, 3}, position4D{3, 3, 3, 3}},
 		{BISHOP, position4D{3, 3, 3, 3}, position2D{3, 3}},
+		{BISHOP, invalidPosition{}, position2D{3, 3}},
+		{BISHOP, position2D{3, 3}, invalidPosition{}},
 	}
 
 	for _, tc := range suite {
@@ -112,7 +147,7 @@ func TestVeryInvalidMoves(t *testing.T) {
 			t.Logf("%s at %s shouldn't move to %s", tc.PieceType, tc.From, tc.To)
 			t.Fail()
 		} else {
-			t.Logf("%s at %s cannot move to %s, which is as it should be", tc.PieceType, tc.From, tc.To)
+			t.Logf("%s at %s (%s) cannot move to %s (%s), which is as it should be", tc.PieceType, tc.From, tc.From.CellColour(), tc.To, tc.To.CellColour())
 		}
 	}
 }
@@ -237,3 +272,67 @@ func TestMovementRules(t *testing.T) {
 		}
 	}
 }
+
+func Test2DMatch(t *testing.T) {
+	type moov struct {
+		From, To string
+	}
+	moves := []moov{
+		{"e2", "e4"}, {"c7", "c5"},
+		{"g1", "f3"}, {"d7", "d6"},
+		{"d2", "d4"}, {"c5", "d4"},
+		{"f3", "d4"}, {"g8", "f6"},
+		{"b1", "c3"}, {"a7", "a6"},
+		{"c1", "e3"}, {"e7", "e6"},
+		{"g2", "g4"}, {"e6", "e5"},
+		{"d4", "f5"}, {"g7", "g6"},
+		{"g4", "g5"}, {"g6", "f5"},
+		{"e4", "f5"}, {"d6", "d5"},
+		{"d1", "f3"}, {"d5", "d4"},
+	}
+
+	rs := Boring2D{}
+	match := Match{
+		RuleSet: rs,
+		Board:   rs.DefaultBoard(),
+	}
+	for _, m := range moves {
+		from, err := rs.ParsePosition(m.From)
+		if err != nil {
+			t.Logf("error parsing '%s': %v", m.From, err)
+			t.Fail()
+			break
+		}
+		piece, _ := match.Board.At(from)
+		to, err := rs.ParsePosition(m.To)
+		if err != nil {
+			t.Logf("error parsing '%s': %v", m.To, err)
+			t.Fail()
+			break
+		}
+
+		move := Move{piece.PieceType, from, to, time.Duration(int64(rand.Intn(90000))) * time.Millisecond}
+		newBoard, err := rs.ApplyMove(match.Board, move)
+		if err != nil {
+			t.Logf("applying move '%s'-'%s': %v", m.From, m.To, err)
+			t.Fail()
+			break
+		}
+
+		match.Moves = append(match.Moves, move)
+		match.Board = newBoard
+	}
+
+	logMatch(t, match, nil)
+
+	_, err := rs.ApplyMove(match.Board, Move{QUEEN, position2D{0, 3}, position2D{3, 3}, 0})
+	if err == nil {
+		t.Logf("This is not the Queen you were looking for")
+		t.Fail()
+	}
+	_, err = rs.ApplyMove(match.Board, Move{QUEEN, position2D{5, 2}, position2D{3, 3}, 0})
+	if err == nil {
+		t.Logf("The Queen does not horse around")
+		t.Fail()
+	}
+}

chesseract/boring2D_test.go

@@ -1,12 +1,17 @@
 package chesseract
 
 import (
+	"errors"
 	"fmt"
 	"time"
 )
 
 var PackageVersion string
 
+var errInvalidFormat = errors.New("error parsing grid position")
+
+var errIllegalMove = errors.New("illegal move")
+
 // A Colour defines a chesspiece's colour
 type Colour int8
 
@@ -24,6 +29,19 @@ type Position interface {
 	CellColour() Colour
 }
 
+// The invalidPosition type can be used in conjunction with throwing a parse error.
+type invalidPosition struct{}
+
+func (invalidPosition) String() string {
+	return "invalid position"
+}
+func (invalidPosition) Equals(Position) bool {
+	return false
+}
+func (invalidPosition) CellColour() Colour {
+	return BLACK
+}
+
 // A Piece represents a chess piece on a board
 type Piece struct {
 	// The PieceType represents the type of a chesspiece
@@ -55,6 +73,27 @@ func (b Board) At(pos Position) (Piece, bool) {
 	return Piece{}, false
 }
 
+// movePiece applies a move to a Board, and returns the resulting board.
+// The last piece to have moved is always at the end of the Pieces list
+func (b Board) movePiece(move Move) Board {
+	rv := Board{
+		Pieces: make([]Piece, 0, len(b.Pieces)),
+		Turn:   b.Turn,
+	}
+	oldPiece, ok := b.At(move.From)
+
+	for _, p := range b.Pieces {
+		if !p.Position.Equals(move.From) && !p.Position.Equals(move.To) {
+			rv.Pieces = append(rv.Pieces, p)
+		}
+	}
+	if ok {
+		oldPiece.Position = move.To
+		rv.Pieces = append(rv.Pieces, oldPiece)
+	}
+	return rv
+}
+
 // A Move wraps a single chess move
 type Move struct {
 	// PieceType contains the chess piece type that's moving
@@ -70,6 +109,19 @@ type Move struct {
 	Time time.Duration
 }
 
+func (m Move) String() string {
+	if m.Time == 0 {
+		return fmt.Sprintf("%s %s %s", m.PieceType, m.From, m.To)
+	}
+
+	t0 := m.Time.Truncate(100 * time.Millisecond)
+	if m.Time.Seconds() > 45 {
+		t0 = m.Time.Truncate(time.Second)
+	}
+
+	return fmt.Sprintf("%s %s %s  +%s", m.PieceType, m.From, m.To, t0)
+}
+
 // The RuleSet captures the details in a chess variant
 type RuleSet interface {
 	// DefaultBoard sets up the initial board configuration
@@ -78,6 +130,9 @@ type RuleSet interface {
 	// AllPositions returns an iterator that allows one to range over all possible positions on the board in this variant
 	AllPositions() []Position
 
+	// ParsePosition converts a string representation into a Position of the correct type
+	ParsePosition(string) (Position, error)
+
 	// CanMove tests whether a piece can move to the specified new position on the board
 	// Note: this only tests movement rules; the check check is performed in ApplyMove.
 	CanMove(Board, Piece, Position) bool

chesseract/chesseract.go

@@ -6,19 +6,19 @@ import (
 )
 
 func (match Match) DebugDump(w io.Writer, highlight []Position) {
-	if _, ok := match.RuleSet.(Boring2D); ok {
-		match.dumpBoring2DBoard(w, highlight)
-	} else {
-		match.dumpUnknownBoard(w, highlight)
-	}
-
 	for i, m := range match.Moves {
 		if i%2 == 0 {
 			fmt.Fprintf(w, " %3d: %s\n", 1+i/2, m)
 		} else {
 			fmt.Fprintf(w, "      %s\n", m)
 		}
 	}
+
+	if _, ok := match.RuleSet.(Boring2D); ok {
+		match.dumpBoring2DBoard(w, highlight)
+	} else {
+		match.dumpUnknownBoard(w, highlight)
+	}
 }
 
 func (match Match) dumpCell(w io.Writer, p Position, highlight []Position) {

chesseract/debug-dump.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/thijzert/chesseract/chesseract"
 )
@@ -20,10 +21,65 @@ func run() error {
 
 	rs := chesseract.Boring2D{}
 	match := chesseract.Match{
-		RuleSet: rs,
-		Board:   rs.DefaultBoard(),
+		RuleSet:   rs,
+		Board:     rs.DefaultBoard(),
+		StartTime: time.Now(),
 	}
-	match.DebugDump(os.Stdout, nil)
 
-	return nil
+	for {
+		match.DebugDump(os.Stdout, nil)
+
+		var move chesseract.Move
+		var newBoard chesseract.Board
+
+		for {
+			fmt.Printf("Enter move for %6s: ", match.Board.Turn)
+
+			var sFrom, sTo string
+			n, _ := fmt.Scanf("%s %s\n", &sFrom, &sTo)
+			if n == 0 {
+				continue
+			}
+			if n == 1 {
+				if sFrom == "forfeit" || sFrom == "quit" {
+					fmt.Printf("%s forfeits", match.Board.Turn)
+					return nil
+				}
+			}
+
+			from, err := rs.ParsePosition(sFrom)
+			if err != nil {
+				fmt.Printf("error parsing '%s': %v\n", sFrom, err)
+				continue
+			}
+			piece, _ := match.Board.At(from)
+			to, err := rs.ParsePosition(sTo)
+			if err != nil {
+				fmt.Printf("error parsing '%s': %v\n", sTo, err)
+				continue
+			}
+
+			moveTime := time.Since(match.StartTime)
+			for _, m := range match.Moves {
+				moveTime -= m.Time
+			}
+
+			move = chesseract.Move{
+				PieceType: piece.PieceType,
+				From:      from,
+				To:        to,
+				Time:      moveTime,
+			}
+			newBoard, err = rs.ApplyMove(match.Board, move)
+			if err != nil {
+				fmt.Printf("applying move '%s'-'%s': %v\n", sFrom, sTo, err)
+				continue
+			}
+
+			break
+		}
+
+		match.Moves = append(match.Moves, move)
+		match.Board = newBoard
+	}
 }