moved engine code to own file and added test

Author: RubikNube

cmd/game/engine.go cmd/engine/engine.gocmd/game/engine.go renamed to cmd/engine/engine.go

@@ -1,26 +1,28 @@
-// Package game provides a simple Go engine interface and a random-move engine.
-package game
+// Package engine provides a simple Go engine interface and a random-move engine.
+package engine
 
 import (
 	"math/rand"
 	"time"
+
+	"github.com/RubikNube/GoInGo/cmd/game"
 )
 
 // Engine is an interface for Go engines.
 type Engine interface {
 	// Move returns the next move as a Point, or nil if passing.
-	Move(board Board, player FieldState, ko *Point) *Point
+	Move(board game.Board, player game.FieldState, ko *game.Point) *game.Point
 }
 
 // RandomEngine implements Engine by picking a random legal move.
 type RandomEngine struct{}
 
-func (e *RandomEngine) Move(board Board, player FieldState, ko *Point) *Point {
-	empty := []Point{}
+func (e *RandomEngine) Move(board game.Board, player game.FieldState, ko *game.Point) *game.Point {
+	empty := []game.Point{}
 	for i := 0; i < 9; i++ {
 		for j := 0; j < 9; j++ {
-			if board[i][j] == Empty {
-				empty = append(empty, Point{Row: i, Col: j})
+			if board[i][j] == game.Empty {
+				empty = append(empty, game.Point{Row: i, Col: j})
 			}
 		}
 	}
@@ -32,26 +34,26 @@ func (e *RandomEngine) Move(board Board, player FieldState, ko *Point) *Point {
 		if ko != nil && pt.Row == ko.Row && pt.Col == ko.Col {
 			continue
 		}
-		var nextBoard Board
+		var nextBoard game.Board
 		copy(nextBoard[:], board[:])
 		nextBoard[pt.Row][pt.Col] = player
-		opp := Black
-		if player == Black {
-			opp = White
+		opp := game.Black
+		if player == game.Black {
+			opp = game.White
 		}
-		captured := []Point{}
-		for _, n := range Neighbors(pt) {
+		captured := []game.Point{}
+		for _, n := range game.Neighbors(pt) {
 			if nextBoard[n.Row][n.Col] == opp {
-				group, libs := Group(nextBoard, n)
+				group, libs := game.Group(nextBoard, n)
 				if len(libs) == 0 {
 					for stonePt := range group {
-						nextBoard[stonePt.Row][stonePt.Col] = Empty
+						nextBoard[stonePt.Row][stonePt.Col] = game.Empty
 						captured = append(captured, stonePt)
 					}
 				}
 			}
 		}
-		_, libs := Group(nextBoard, pt)
+		_, libs := game.Group(nextBoard, pt)
 		if len(libs) == 0 {
 			continue
 		}

cmd/engine/engine_test.go

@@ -0,0 +1,40 @@
+package engine
+
+import (
+	"testing"
+
+	"github.com/RubikNube/GoInGo/cmd/game"
+)
+
+func TestRandomEngine_MoveReturnsLegalMove(t *testing.T) {
+	board := game.Board{}
+	engine := &RandomEngine{}
+	player := game.Black
+	var ko *game.Point
+
+	move := engine.Move(board, player, ko)
+	if move == nil {
+		t.Error("Expected a move, got nil")
+	}
+	if move.Row < 0 || move.Row > 8 || move.Col < 0 || move.Col > 8 {
+		t.Errorf("Move out of bounds: %+v", move)
+	}
+}
+
+func TestRandomEngine_MoveReturnsNilWhenNoMoves(t *testing.T) {
+	board := game.Board{}
+	// Fill the board
+	for i := range board {
+		for j := range board[i] {
+			board[i][j] = game.Black
+		}
+	}
+	engine := &RandomEngine{}
+	player := game.White
+	var ko *game.Point
+
+	move := engine.Move(board, player, ko)
+	if move != nil {
+		t.Errorf("Expected nil (pass), got %+v", move)
+	}
+}

main.go

@@ -8,6 +8,7 @@ import (
 	"time"
 	"unicode"
 
+	"github.com/RubikNube/GoInGo/cmd/engine"
 	"github.com/RubikNube/GoInGo/cmd/game"
 	"github.com/jroimartin/gocui"
 )
@@ -20,13 +21,13 @@ var (
 	cursorRow, cursorCol int
 	gui                  game.Gui
 	keybindings          map[string]string
-	prevBoard            *game.Board     // Track previous board for Ko rule
-	currentPlayer        int         = 1 // Track current player (1 or 2), start with Black
-	koPoint              *game.Point     // Track Ko point (nil if no Ko)
-	passCount            int             // Track consecutive passes
-	gameOver             bool            // Track if the game is over
-	engineEnabled        bool            // Play against engine if true
-	engine               game.Engine     // The engine instance
+	prevBoard            *game.Board       // Track previous board for Ko rule
+	currentPlayer        int           = 1 // Track current player (1 or 2), start with Black
+	koPoint              *game.Point       // Track Ko point (nil if no Ko)
+	passCount            int               // Track consecutive passes
+	gameOver             bool              // Track if the game is over
+	engineEnabled        bool              // Play against engine if true
+	selectedEngine       engine.Engine     // The engine instance
 )
 
 func loadConfig(path string) (Config, error) {
@@ -302,10 +303,10 @@ func quit(g *gocui.Gui, v *gocui.View) error {
 
 func engineMove(g *gocui.Gui) {
 	// Use the engine interface to get a move for White
-	if engine == nil {
+	if selectedEngine == nil {
 		return
 	}
-	move := engine.Move(gui.Grid, game.White, koPoint)
+	move := selectedEngine.Move(gui.Grid, game.White, koPoint)
 	if move != nil {
 		// Do not move the cursor for the engine, just place the stone directly
 		row, col := move.Row, move.Col
@@ -361,13 +362,10 @@ func main() {
 	}
 	keybindings = cfg.Keybindings
 
-	engine = &game.RandomEngine{}
+	selectedEngine = &engine.RandomEngine{}
 	engineEnabled = true // Enable engine by default
 
 	defer g.Close()
-	keybindings = cfg.Keybindings
-
-	engine = &game.RandomEngine{}
 
 	if err != nil {
 		log.Panicln(err)