config for bingo bonus

blake-lowe · blake-lowe · commit 28d094b94980 · 2026-02-26T02:23:27.000-08:00
diff --git a/ai/bot/elite.go b/ai/bot/elite.go
@@ -111,7 +111,7 @@ func endGameBest(ctx context.Context, p *BotTurnPlayer, endgamePlies int) (*move
 	gameCopy := p.Game.Copy()
 	gameCopy.SetBackupMode(game.SimulationMode)
 	gameCopy.SetStateStackLength(endgamePlies + 1)
-	gen1 := movegen.NewGordonGenerator(gd, gameCopy.Board(), p.Game.Rules().LetterDistribution())
+	gen1 := movegen.NewGordonGenerator(gd, gameCopy.Board(), p.Game.Rules().LetterDistribution(), p.Game.Rules().BingoBonus())
 	err = p.endgamer.Init(gen1, gameCopy)
 	if err != nil {
 		return nil, err
diff --git a/ai/turnplayer/static_player.go b/ai/turnplayer/static_player.go
@@ -57,7 +57,7 @@ func AddAIFields(p *turnplayer.BaseTurnPlayer, conf *config.Config, calculators
 	if err != nil {
 		return nil, err
 	}
-	gen := movegen.NewGordonGenerator(gd, p.Board(), p.Bag().LetterDistribution())
+	gen := movegen.NewGordonGenerator(gd, p.Board(), p.Bag().LetterDistribution(), p.Rules().BingoBonus())
 	gen.SetEquityCalculators(calculators)
 	ret := &AIStaticTurnPlayer{*p, calculators, gen, conf}
 	return ret, nil
diff --git a/board/board.go b/board/board.go
@@ -844,16 +844,16 @@ func (g *GameBoard) formedCrossWord(crossVertical bool, letter tilemapping.Machi
 // assume the row stays static as we iterate through the letters of the
 // word.
 func (g *GameBoard) ScoreWord(word tilemapping.MachineWord, row, col, tilesPlayed int,
-	crossDir BoardDirection, ld *tilemapping.LetterDistribution) int {
+	crossDir BoardDirection, ld *tilemapping.LetterDistribution, bingoBonus int) int {
 
 	// letterScore:
 	var ls int
 
 	mainWordScore := 0
 	crossScores := 0
-	bingoBonus := 0
+	bonus := 0
 	if tilesPlayed == 7 {
-		bingoBonus = 50
+		bonus = bingoBonus
 	}
 	wordMultiplier := 1
 
@@ -904,7 +904,7 @@ func (g *GameBoard) ScoreWord(word tilemapping.MachineWord, row, col, tilesPlaye
 			crossScores += ls*letterMultiplier*thisWordMultiplier + cs*thisWordMultiplier
 		}
 	}
-	return mainWordScore*wordMultiplier + crossScores + bingoBonus
+	return mainWordScore*wordMultiplier + crossScores + bonus
 
 }
 
diff --git a/config/config.go b/config/config.go
@@ -40,6 +40,7 @@ const (
 	ConfigOpenaiApiKey                     = "openai-api-key"
 	ConfigDeepseekApiKey                   = "deepseek-api-key"
 	ConfigWooglesApiKey                    = "woogles-api-key"
+	ConfigBingoBonus                       = "bingo-bonus"
 	ConfigAliases                          = "aliases"
 )
 
@@ -113,6 +114,7 @@ func (c *Config) Load(args []string) error {
 	c.BindEnv(ConfigOpenaiApiKey)
 	c.BindEnv(ConfigDeepseekApiKey)
 	c.BindEnv(ConfigWooglesApiKey)
+	c.BindEnv(ConfigBingoBonus)
 
 	cfgdir, err := os.UserConfigDir()
 	if err != nil {
@@ -166,6 +168,7 @@ func (c *Config) Load(args []string) error {
 	c.SetDefault(ConfigOpenaiApiKey, "")
 	c.SetDefault(ConfigDeepseekApiKey, "")
 	c.SetDefault(ConfigWooglesApiKey, "")
+	c.SetDefault(ConfigBingoBonus, 50)
 
 	return nil
 }
diff --git a/endgame/negamax/solver.go b/endgame/negamax/solver.go
@@ -360,7 +360,7 @@ func (s *Solver) makeGameCopies() error {
 	s.movegens = []movegen.MoveGenerator{}
 	gaddag := s.stmMovegen.(*movegen.GordonGenerator).GADDAG()
 	for i := 0; i < s.threads-1; i++ {
-		mg := movegen.NewGordonGenerator(gaddag, s.gameCopies[i].Board(), s.gameCopies[i].Bag().LetterDistribution())
+		mg := movegen.NewGordonGenerator(gaddag, s.gameCopies[i].Board(), s.gameCopies[i].Bag().LetterDistribution(), s.gameCopies[i].Rules().BingoBonus())
 		mg.SetSortingParameter(movegen.SortByNone)
 		mg.SetGenPass(true)
 		mg.SetPlayRecorder(movegen.AllPlaysSmallRecorder)
diff --git a/equity/calculators_test.go b/equity/calculators_test.go
@@ -87,7 +87,7 @@ func TestEndgameTiming(t *testing.T) {
 	bd := board.MakeBoard(board.CrosswordGameBoard)
 	ld, err := tilemapping.EnglishLetterDistribution(DefaultConfig.WGLConfig())
 	assert.Nil(t, err)
-	generator := movegen.NewGordonGenerator(gd, bd, ld)
+	generator := movegen.NewGordonGenerator(gd, bd, ld, 50)
 	tilesInPlay := bd.SetToGame(gd.GetAlphabet(), board.MavenVsMacondo)
 	cross_set.GenAllCrossSets(bd, gd, ld)
 	generator.GenAll(tilemapping.RackFromString("AEEORS?", alph), false)
@@ -131,7 +131,7 @@ func TestPreendgameTiming(t *testing.T) {
 	bd := board.MakeBoard(board.CrosswordGameBoard)
 	ld, err := tilemapping.EnglishLetterDistribution(DefaultConfig.WGLConfig())
 	assert.Nil(t, err)
-	generator := movegen.NewGordonGenerator(gd, bd, ld)
+	generator := movegen.NewGordonGenerator(gd, bd, ld, 50)
 	tilesInPlay := bd.SetToGame(gd.GetAlphabet(), board.VsOxy)
 	cross_set.GenAllCrossSets(bd, gd, ld)
 	generator.GenAll(tilemapping.RackFromString("OXPBAZE", alph), false)
@@ -170,7 +170,7 @@ func TestOpeningPlayHeuristic(t *testing.T) {
 	bd := board.MakeBoard(board.CrosswordGameBoard)
 	ld, err := tilemapping.EnglishLetterDistribution(DefaultConfig.WGLConfig())
 	assert.Nil(t, err)
-	generator := movegen.NewGordonGenerator(gd, bd, ld)
+	generator := movegen.NewGordonGenerator(gd, bd, ld, 50)
 	cross_set.GenAllCrossSets(bd, gd, ld)
 	generator.GenAll(tilemapping.RackFromString("AEFLR", alph), false)
 	els, err := equity.NewCombinedStaticCalculator(
diff --git a/game/backup.go b/game/backup.go
@@ -166,6 +166,7 @@ func (g *Game) Copy() *Game {
 		maxScorelessTurns: g.maxScorelessTurns,
 		exchangeLimit:     g.exchangeLimit,
 		players:           copyPlayers(g.players),
+		rules:             g.rules,
 		// stackPtr only changes during a sim, etc. This Copy should
 		// only be called at the beginning of everything.
 		stackPtr: 0,
diff --git a/game/game.go b/game/game.go
@@ -823,7 +823,7 @@ func (g *Game) CreateAndScorePlacementMove(coords string, tiles string, rack str
 	// ScoreWord assumes the play is always horizontal, so we have to
 	// do the transpositions beforehand.
 	score := g.Board().ScoreWord(mw, row, col, tilesPlayed,
-		crossDir, g.bag.LetterDistribution())
+		crossDir, g.bag.LetterDistribution(), g.rules.BingoBonus())
 	// reset row, col back for the actual creation of the play.
 	if vertical {
 		row, col = col, row
diff --git a/game/rules.go b/game/rules.go
@@ -42,6 +42,7 @@ type GameRules struct {
 	boardname     string
 	distname      string
 	exchangeLimit int
+	bingoBonus    int
 }
 
 func (g GameRules) Config() *config.Config {
@@ -88,6 +89,10 @@ func (g GameRules) ExchangeLimit() int {
 	return g.exchangeLimit
 }
 
+func (g GameRules) BingoBonus() int {
+	return g.bingoBonus
+}
+
 func NewBasicGameRules(cfg *config.Config,
 	lexiconName, boardLayoutName, letterDistributionName, csetGenName string,
 	variant Variant) (*GameRules, error) {
@@ -142,6 +147,12 @@ func NewBasicGameRules(cfg *config.Config,
 		exchLimit = 1
 	}
 
+	// Set bingo bonus based on board layout
+	bingoBonus := cfg.GetInt(config.ConfigBingoBonus)
+	if boardLayoutName == board.CrossplayGameLayout {
+		bingoBonus = 40
+	}
+
 	rules := &GameRules{
 		cfg:           cfg,
 		dist:          dist,
@@ -152,6 +163,7 @@ func NewBasicGameRules(cfg *config.Config,
 		crossSetGen:   csgen,
 		variant:       variant,
 		exchangeLimit: exchLimit,
+		bingoBonus:    bingoBonus,
 	}
 	return rules, nil
 }
diff --git a/game/rules_test.go b/game/rules_test.go
@@ -3,6 +3,8 @@ package game
 import (
 	"testing"
 
+	"github.com/domino14/macondo/board"
+	"github.com/domino14/macondo/config"
 	"github.com/matryer/is"
 )
 
@@ -28,3 +30,50 @@ func TestMaxCanExchange(t *testing.T) {
 		is.Equal(MaxCanExchange(tc.inbag, tc.exchlimit), tc.expected)
 	}
 }
+
+func TestBingoBonus(t *testing.T) {
+	is := is.New(t)
+
+	cfg := config.DefaultConfig()
+	cfg.Set(config.ConfigBingoBonus, 50) // Set default to 50
+
+	// Create rules manually
+	rules := &GameRules{
+		cfg:         cfg,
+		bingoBonus:  0,
+	}
+
+	// Simulate the bingo bonus setting logic from NewBasicGameRules
+	bingoBonus := cfg.GetInt(config.ConfigBingoBonus)
+	if board.CrossplayGameLayout == board.CrossplayGameLayout {
+		bingoBonus = 40
+	}
+	rules.bingoBonus = bingoBonus
+
+	is.Equal(rules.BingoBonus(), 40) // Crossplay overrides to 40
+
+	// Test other layouts use configured value
+	bingoBonus = cfg.GetInt(config.ConfigBingoBonus)
+	if board.CrosswordGameLayout == board.CrossplayGameLayout {
+		bingoBonus = 40
+	}
+	rules.bingoBonus = bingoBonus
+	is.Equal(rules.BingoBonus(), 50) // Should use configured value
+
+	// Test custom bingo bonus
+	cfg.Set(config.ConfigBingoBonus, 35)
+	bingoBonus = cfg.GetInt(config.ConfigBingoBonus)
+	if board.CrosswordGameLayout == board.CrossplayGameLayout {
+		bingoBonus = 40
+	}
+	rules.bingoBonus = bingoBonus
+	is.Equal(rules.BingoBonus(), 35) // Should use configured value
+
+	// Test Crossplay still overrides to 40 even with custom config
+	bingoBonus = cfg.GetInt(config.ConfigBingoBonus)
+	if board.CrossplayGameLayout == board.CrossplayGameLayout {
+		bingoBonus = 40
+	}
+	rules.bingoBonus = bingoBonus
+	is.Equal(rules.BingoBonus(), 40) // Crossplay should still be 40
+}
diff --git a/movegen/movegen.go b/movegen/movegen.go
@@ -111,6 +111,7 @@ type GordonGenerator struct {
 	quitEarly      bool
 	maxTileUsage   int
 	maxCanExchange int
+	bingoBonus      int
 
 	// For top N only:
 	topNPlays       []*move.Move
@@ -119,7 +120,7 @@ type GordonGenerator struct {
 
 // NewGordonGenerator returns a Gordon move generator.
 func NewGordonGenerator(gd gaddag.WordGraph, board *board.GameBoard,
-	ld *tilemapping.LetterDistribution) *GordonGenerator {
+	ld *tilemapping.LetterDistribution, bingoBonus int) *GordonGenerator {
 
 	gen := &GordonGenerator{
 		gaddag:             gd.(*kwg.KWG),
@@ -135,6 +136,7 @@ func NewGordonGenerator(gd gaddag.WordGraph, board *board.GameBoard,
 		placeholder:        new(move.Move),
 		maxTileUsage:       100, // basically unlimited
 		maxCanExchange:     game.DefaultExchangeLimit,
+		bingoBonus:         bingoBonus,
 	}
 	return gen
 }
@@ -394,7 +396,7 @@ func (gen *GordonGenerator) goOn(curCol int, L tilemapping.MachineLetter,
 	leftstrip, rightstrip int, uniquePlay bool, baseScore, crossScores, wordMultiplier int) {
 	var bingoBonus int
 	if gen.tilesPlayed == game.RackTileLimit {
-		bingoBonus = 50
+		bingoBonus = gen.bingoBonus
 	}
 	if curCol <= gen.curAnchorCol {
 		if gen.board.HasLetter(gen.curRowIdx, curCol) {
@@ -482,7 +484,7 @@ func (gen *GordonGenerator) crossDirection() board.BoardDirection {
 
 func (gen *GordonGenerator) scoreMove(word tilemapping.MachineWord, row, col, tilesPlayed int) int {
 
-	return gen.board.ScoreWord(word, row, col, tilesPlayed, gen.crossDirection(), gen.letterDistribution)
+	return gen.board.ScoreWord(word, row, col, tilesPlayed, gen.crossDirection(), gen.letterDistribution, gen.bingoBonus)
 }
 
 // Plays returns the generator's generated plays.
diff --git a/movegen/movegen_test.go b/movegen/movegen_test.go
diff --git a/preendgame/peg.go b/preendgame/peg.go
diff --git a/shell/api.go b/shell/api.go
diff --git a/shell/shell.go b/shell/shell.go
diff --git a/tinymove/conversions/conversions.go b/tinymove/conversions/conversions.go

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ func AddAIFields(p turnplayer.BaseTurnPlayer, conf config.Config, calculators`
`57`	`57`	`if err != nil {`
`58`	`58`	`return nil, err`
`59`	`59`	`}`
`60`		`- gen := movegen.NewGordonGenerator(gd, p.Board(), p.Bag().LetterDistribution())`
	`60`	`+ gen := movegen.NewGordonGenerator(gd, p.Board(), p.Bag().LetterDistribution(), p.Rules().BingoBonus())`
`61`	`61`	`gen.SetEquityCalculators(calculators)`
`62`	`62`	`ret := &AIStaticTurnPlayer{*p, calculators, gen, conf}`
`63`	`63`	`return ret, nil`
Original file line number	Diff line number	Diff line change
`@@ -844,16 +844,16 @@ func (g *GameBoard) formedCrossWord(crossVertical bool, letter tilemapping.Machi`
`844`	`844`	`// assume the row stays static as we iterate through the letters of the`
`845`	`845`	`// word.`
`846`	`846`	`func (g *GameBoard) ScoreWord(word tilemapping.MachineWord, row, col, tilesPlayed int,`
`847`		`- crossDir BoardDirection, ld *tilemapping.LetterDistribution) int {`
	`847`	`+ crossDir BoardDirection, ld *tilemapping.LetterDistribution, bingoBonus int) int {`
`848`	`848`
`849`	`849`	`// letterScore:`
`850`	`850`	`var ls int`
`851`	`851`
`852`	`852`	`mainWordScore := 0`
`853`	`853`	`crossScores := 0`
`854`		`- bingoBonus := 0`
	`854`	`+ bonus := 0`
`855`	`855`	`if tilesPlayed == 7 {`
`856`		`- bingoBonus = 50`
	`856`	`+ bonus = bingoBonus`
`857`	`857`	`}`
`858`	`858`	`wordMultiplier := 1`
`859`	`859`
`@@ -904,7 +904,7 @@ func (g *GameBoard) ScoreWord(word tilemapping.MachineWord, row, col, tilesPlaye`
`904`	`904`	`crossScores += lsletterMultiplierthisWordMultiplier + cs*thisWordMultiplier`
`905`	`905`	`}`
`906`	`906`	`}`
`907`		`- return mainWordScore*wordMultiplier + crossScores + bingoBonus`
	`907`	`+ return mainWordScore*wordMultiplier + crossScores + bonus`
`908`	`908`
`909`	`909`	`}`
`910`	`910`