restructuring of project and adding of engine comparision

Author: RubikNube

.gitignore

@@ -1,2 +1,8 @@
 # the compiled main module
 main
+
+# the compiled libraries
+libgoengine.h
+libgoengine.so
+goengine
+ctypes

benchmarks.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -e
+
+# Execute the benchmarks
+go test -bench=. -run=^$ ./...

build.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+# Execute the tests
+go test ./...
+
+# Evaluate the test results
+# If the tests fail, exit with an error code
+if [ $? -ne 0 ]; then
+    echo "Tests failed. Exiting build process."
+    exit 1
+fi
+
+# Build main package (CLI/game)
+go build -o goengine ./cmd/main.go
+
+# Build shared library from export/export.go
+go build -buildmode=c-shared -o libgoengine.so ./export/export.go

cmd/engine/alpha_beta_engine_benchmark_test.go

@@ -8,8 +8,8 @@ import (
 	"time"
 	"unicode"
 
-	"github.com/RubikNube/GoInGo/cmd/engine"
-	"github.com/RubikNube/GoInGo/cmd/game"
+	"github.com/RubikNube/GoInGo/pkg/engine"
+	"github.com/RubikNube/GoInGo/pkg/game"
 	"github.com/jroimartin/gocui"
 )
 

main.go cmd/main.gomain.go renamed to cmd/main.go

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+from ctypes import cdll, c_uint, c_int
+
+lib = cdll.LoadLibrary('./libgoengine.so')
+
+# Create engines and board
+engineA = lib.NewAlphaBetaEngine()
+engineB = lib.NewRandomEngine()
+board = lib.NewBoard(c_int(9))
+
+# Call CompareEngines with valid handles
+result = lib.CompareEngines(
+    c_uint(engineA),
+    c_uint(engineB),
+    c_uint(board),
+    c_int(1),      # firstPlayer
+    c_int(100)     # maxMoves
+)
+
+# Print the result and name the winner
+if result == 1:
+    print("Winner: Engine A (Alpha-Beta)")
+elif result == 2:
+    print("Winner: Engine B (Random)")
+elif result == 0:
+    print("Result: Draw")

compare_engines.py

@@ -0,0 +1,83 @@
+package main
+
+/*
+#include <stdint.h>
+*/
+import "C"
+import (
+	"sync"
+
+	"github.com/RubikNube/GoInGo/pkg/compareengines"
+	"github.com/RubikNube/GoInGo/pkg/engine"
+	"github.com/RubikNube/GoInGo/pkg/game"
+)
+
+var (
+	engineRegistry = struct {
+		sync.Mutex
+		nextID  uint64
+		objects map[uint64]engine.Engine
+	}{objects: make(map[uint64]engine.Engine)}
+	boardRegistry = struct {
+		sync.Mutex
+		nextID  uint64
+		objects map[uint64]*game.Board
+	}{objects: make(map[uint64]*game.Board)}
+)
+
+//export NewAlphaBetaEngine
+func NewAlphaBetaEngine() C.uint64_t {
+	engineRegistry.Lock()
+	defer engineRegistry.Unlock()
+	e := engine.NewAlphaBetaEngine()
+	id := engineRegistry.nextID
+	engineRegistry.nextID++
+	engineRegistry.objects[id] = e
+	return C.uint64_t(id)
+}
+
+//export NewRandomEngine
+func NewRandomEngine() C.uint64_t {
+	engineRegistry.Lock()
+	defer engineRegistry.Unlock()
+	e := engine.NewRandomEngine()
+	id := engineRegistry.nextID
+	engineRegistry.nextID++
+	engineRegistry.objects[id] = e
+	return C.uint64_t(id)
+}
+
+//export NewBoard
+func NewBoard(size C.int) C.uint64_t {
+	boardRegistry.Lock()
+	defer boardRegistry.Unlock()
+	b := game.NewBoard()
+	id := boardRegistry.nextID
+	boardRegistry.nextID++
+	boardRegistry.objects[id] = &b
+	return C.uint64_t(id)
+}
+
+//export CompareEngines
+func CompareEngines(engineAID, engineBID, boardID C.uint64_t, firstPlayer C.int, maxMoves C.int) C.int {
+	engineRegistry.Lock()
+	engineA := engineRegistry.objects[uint64(engineAID)]
+	engineB := engineRegistry.objects[uint64(engineBID)]
+	engineRegistry.Unlock()
+	boardRegistry.Lock()
+	board := boardRegistry.objects[uint64(boardID)]
+	boardRegistry.Unlock()
+	if engineA == nil || engineB == nil || board == nil {
+		return -1 // error code
+	}
+	result := compareengines.CompareEngines(engineA, engineB, *board, game.FieldState(firstPlayer), int(maxMoves))
+	if result == 0 {
+		return 0 // draw
+	} else if result > 0 {
+		return 1 // engineA wins
+	} else {
+		return 2 // engineB wins
+	}
+}
+
+func main() {}

export/export.go

@@ -0,0 +1,76 @@
+// Package compareengines provides functionality to compare two Go engines by playing a game.
+package compareengines
+
+import (
+	"github.com/RubikNube/GoInGo/pkg/engine"
+	"github.com/RubikNube/GoInGo/pkg/game"
+)
+
+// CompareEngines lets two engines play against each other and returns the winner.
+// Returns: 1 if engineA wins, -1 if engineB wins, 0 for draw.
+func CompareEngines(engineA, engineB engine.Engine, board game.Board, firstPlayer game.FieldState, maxMoves int) int {
+	player := firstPlayer
+	var ko *game.Point
+	moveCount := 0
+	passCount := 0
+	for moveCount < maxMoves && passCount < 2 {
+		var move *game.Point
+		if player == firstPlayer {
+			move = engineA.Move(board, player, ko)
+		} else {
+			move = engineB.Move(board, player, ko)
+		}
+		if move == nil {
+			passCount++
+		} else {
+			passCount = 0
+			board[move.Row][move.Col] = player
+			ko = nil // Optionally update ko if needed
+		}
+		player = opponent(player)
+		moveCount++
+	}
+	score := evaluate(board, firstPlayer, opponent(firstPlayer))
+	if score > 0 {
+		return 1
+	} else if score < 0 {
+		return -1
+	}
+	return 0
+}
+
+// opponent returns the opposite FieldState (Black <-> White).
+func opponent(player game.FieldState) game.FieldState {
+	if player == game.Black {
+		return game.White
+	}
+	return game.Black
+}
+
+// evaluate returns a score for the board from the perspective of 'player'.
+// Positive means advantage for 'player', negative for opponent.
+func evaluate(board game.Board, player, opp game.FieldState) int {
+	playerStones, oppStones := 0, 0
+	playerLibs, oppLibs := 0, 0
+	visited := make(map[game.Point]bool)
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			pt := game.Point{Row: int8(i), Col: int8(j)}
+			if visited[pt] || board[i][j] == game.Empty {
+				continue
+			}
+			group, libs := game.Group(board, pt)
+			for stone := range group {
+				visited[stone] = true
+			}
+			if board[i][j] == player {
+				playerStones += len(group)
+				playerLibs += len(libs)
+			} else if board[i][j] == opp {
+				oppStones += len(group)
+				oppLibs += len(libs)
+			}
+		}
+	}
+	return (playerStones-oppStones)*10 + (playerLibs-oppLibs)*2
+}

pkg/compareengines/compare_engines.go

@@ -3,7 +3,7 @@ package engine
 import (
 	"sort"
 
-	"github.com/RubikNube/GoInGo/cmd/game"
+	"github.com/RubikNube/GoInGo/pkg/game"
 )
 
 // AlphaBetaEngine implements Engine using alpha-beta pruning with killer move heuristic.

cmd/engine/alpha_beta_engine.go pkg/engine/alpha_beta_engine.gocmd/engine/alpha_beta_engine.go renamed to pkg/engine/alpha_beta_engine.go

@@ -0,0 +1,23 @@
+package engine
+
+import (
+	"testing"
+
+	"github.com/RubikNube/GoInGo/pkg/game"
+)
+
+func BenchmarkAlphaBetaEngine_EmptyBoard(b *testing.B) {
+	engine := NewAlphaBetaEngine()
+	board := emptyBoard()
+	for i := 0; i < b.N; i++ {
+		engine.Move(board, game.Black, nil)
+	}
+}
+
+func BenchmarkAlphaBetaEngine_MidGame(b *testing.B) {
+	engine := NewAlphaBetaEngine()
+	board := midGameBoard()
+	for i := 0; i < b.N; i++ {
+		engine.Move(board, game.White, nil)
+	}
+}