commit 318520e36e38d3af5304871723fa90e604e52312 · dunkirk.sh/battleship-arena

+12

AGENTS.md

···

       12
       12
        
       - **scp.go** - SCP upload middleware for file submissions

     

       13
       13
        
       - **worker.go** - Background processor (runs every 30s)

     

       14
       14
        
       

     

       15
       15
       +
       ## Glicko-2 Rating System

     

       16
       16
       +
       

     

       17
       17
       +
       **Important**: The system uses Glicko-2 ratings with **proper rating periods** to avoid last-submitter bias:

     

       18
       18
       +
       

     

       19
       19
       +
       - All matches in a round-robin are stored first

     

       20
       20
       +
       - Ratings update **once at the end** using all match results together (proper rating period)

     

       21
       21
       +
       - This eliminates path-dependency where identical algorithms get different ratings based on submission order

     

       22
       22
       +
       - Each player's rating considers ALL their opponents' ratings at the start of the rating period

     

       23
       23
       +
       - Glicko-2 expects 10-15+ games per rating period - our round-robin satisfies this

     

       24
       24
       +
       

     

       25
       25
       +
       **Manual recalculation**: Run `./battleship-arena recalculate-ratings` or `make recalculate-ratings` to recompute all ratings from scratch.

     

       26
       26
       +
       

     

       15
       27
        
       ## File Upload

     

       16
       28
        
       

     

       17
       29
        
       Students upload via SCP:

+16 -10

Makefile

···

       48
       48
        
       	@echo "Building for production..."

     

       49
       49
        
       	@CGO_ENABLED=1 go build -ldflags="-s -w" -o bin/battleship-arena ./cmd/battleship-arena

     

       50
       50
        
       

     

       51
       51
       +
       # Recalculate all Glicko-2 ratings from scratch

     

       52
       52
       +
       recalculate-ratings: build

     

       53
       53
       +
       	@echo "Recalculating all Glicko-2 ratings..."

     

       54
       54
       +
       	@./bin/battleship-arena recalculate-ratings

     

       55
       55
       +
       

     

       51
       56
        
       # Show help

     

       52
       57
        
       help:

     

       53
       58
        
       	@echo "Available targets:"

     

       54
       54
       -
       	@echo "  build       - Build the server"

     

       55
       55
       -
       	@echo "  run         - Build and run the server"

     

       56
       56
       -
       	@echo "  clean       - Clean build artifacts"

     

       57
       57
       -
       	@echo "  test        - Run tests"

     

       58
       58
       -
       	@echo "  gen-key     - Generate SSH host key"

     

       59
       59
       -
       	@echo "  fmt         - Format code"

     

       60
       60
       -
       	@echo "  lint        - Lint code"

     

       61
       61
       -
       	@echo "  deps        - Update dependencies"

     

       62
       62
       -
       	@echo "  build-prod  - Build optimized production binary"

     

       63
       63
       -
       	@echo "  help        - Show this help"

     

       59
       59
       +
       	@echo "  build              - Build the server"

     

       60
       60
       +
       	@echo "  run                - Build and run the server"

     

       61
       61
       +
       	@echo "  clean              - Clean build artifacts"

     

       62
       62
       +
       	@echo "  test               - Run tests"

     

       63
       63
       +
       	@echo "  gen-key            - Generate SSH host key"

     

       64
       64
       +
       	@echo "  fmt                - Format code"

     

       65
       65
       +
       	@echo "  lint               - Lint code"

     

       66
       66
       +
       	@echo "  deps               - Update dependencies"

     

       67
       67
       +
       	@echo "  build-prod         - Build optimized production binary"

     

       68
       68
       +
       	@echo "  recalculate-ratings - Recalculate all Glicko-2 ratings from scratch"

     

       69
       69
       +
       	@echo "  help               - Show this help"

battleship-arena

This is a binary file and will not be displayed.

+13

cmd/battleship-arena/main.go

···

       61
       61
        
       	if err := initStorage(cfg); err != nil {

     

       62
       62
        
       		log.Fatal(err)

     

       63
       63
        
       	}

     

       64
       64
       +
       	

     

       65
       65
       +
       	// Check for special commands

     

       66
       66
       +
       	if len(os.Args) > 1 {

     

       67
       67
       +
       		switch os.Args[1] {

     

       68
       68
       +
       		case "recalculate-ratings":

     

       69
       69
       +
       			log.Println("Recalculating all Glicko-2 ratings from scratch...")

     

       70
       70
       +
       			if err := storage.RecalculateAllGlicko2Ratings(); err != nil {

     

       71
       71
       +
       				log.Fatalf("Failed to recalculate ratings: %v", err)

     

       72
       72
       +
       			}

     

       73
       73
       +
       			log.Println("✓ Ratings recalculated successfully")

     

       74
       74
       +
       			return

     

       75
       75
       +
       		}

     

       76
       76
       +
       	}

     

       64
       77
        
       

     

       65
       78
        
       	server.InitSSE()

     

       66
       79
        
       	server.SetConfig(cfg.AdminPasscode, cfg.ExternalURL)

+9 -8

internal/runner/runner.go

···

       329
       329
        
       				map[int]string{newSub.ID: newSub.Username, opponent.ID: opponent.Username}[winnerID])

     

       330
       330
        
       		}

     

       331
       331
        
       		

     

       332
       332
       -
       		matchID, err := storage.AddMatch(newSub.ID, opponent.ID, winnerID, player1Wins, player2Wins, avgMoves, avgMoves)

     

       332
       332
       +
       		_, err := storage.AddMatch(newSub.ID, opponent.ID, winnerID, player1Wins, player2Wins, avgMoves, avgMoves)

     

       333
       333
        
       		if err != nil {

     

       334
       334
        
       			log.Printf("Failed to store match result: %v", err)

     

       335
       335
       -
       		} else {

     

       336
       336
       -
       			if err := storage.UpdateGlicko2Ratings(newSub.ID, opponent.ID, player1Wins, player2Wins); err != nil {

     

       337
       337
       -
       				log.Printf("Glicko-2 update failed: %v", err)

     

       338
       338
       -
       			} else {

     

       339
       339
       -
       				recordRatingSnapshot(newSub.ID, int(matchID))

     

       340
       340
       -
       				recordRatingSnapshot(opponent.ID, int(matchID))

     

       341
       341
       -
       			}

     

       342
       335
        
       		}

     

       343
       336
        
       	}

     

       344
       337
        
       	

     

       345
       338
        
       	log.Printf("✓ Round-robin complete for %s (%d matches)", newSub.Username, totalMatches)

     

       339
       339
       +
       	

     

       340
       340
       +
       	// Update Glicko-2 ratings using proper rating periods (batch all matches together)

     

       341
       341
       +
       	log.Printf("Updating Glicko-2 ratings (proper rating period)...")

     

       342
       342
       +
       	if err := storage.RecalculateAllGlicko2Ratings(); err != nil {

     

       343
       343
       +
       		log.Printf("Failed to update Glicko-2 ratings: %v", err)

     

       344
       344
       +
       	} else {

     

       345
       345
       +
       		log.Printf("✓ Glicko-2 ratings updated")

     

       346
       346
       +
       	}

     

       346
       347
        
       }

     

       347
       348
        
       

     

       348
       349
        
       func recordRatingSnapshot(submissionID, matchID int) {

+105 -3

internal/storage/database.go

···

       191
       191
        
       

     

       192
       192
        
       func GetLeaderboard(limit int) ([]LeaderboardEntry, error) {

     

       193
       193
        
       	// Get submissions with matches

     

       194
       194
       +
       	// Rankings use Glicko-2 with proper rating periods:

     

       195
       195
       +
       	// - All round-robin matches are batched together before rating updates

     

       196
       196
       +
       	// - This prevents last-submitter bias from path-dependent rating changes

     

       194
       197
        
       	query := `

     

       195
       198
        
       	SELECT 

     

       196
       199
        
       		s.username,

     
···

       216
       219
        
       		350.0 as rd,

     

       217
       220
        
       		0 as total_wins,

     

       218
       221
        
       		0 as total_losses,

     

       219
       219
       -
       		0.0 as avg_moves,

     

       222
       222
       +
       		999.0 as avg_moves,

     

       220
       223
        
       		s.upload_time as last_played,

     

       221
       224
        
       		1 as is_pending,

     

       222
       225
        
       		0 as is_broken

     
···

       234
       237
        
       		0 as rd,

     

       235
       238
        
       		0 as total_wins,

     

       236
       239
        
       		0 as total_losses,

     

       237
       237
       -
       		0.0 as avg_moves,

     

       240
       240
       +
       		999.0 as avg_moves,

     

       238
       241
        
       		s.upload_time as last_played,

     

       239
       242
        
       		0 as is_pending,

     

       240
       243
        
       		1 as is_broken

     

       241
       244
        
       	FROM submissions s

     

       242
       245
        
       	WHERE s.is_active = 1 AND s.status = 'compilation_failed'

     

       243
       246
        
       	

     

       244
       244
       -
       	ORDER BY is_broken ASC, is_pending ASC, rating DESC, total_wins DESC

     

       247
       247
       +
       	ORDER BY is_broken ASC, is_pending ASC, rating DESC, total_wins DESC, avg_moves ASC

     

       245
       248
        
       	LIMIT ?

     

       246
       249
        
       	`

     

       247
       250
        
       

     
···

       732
       735
        
       	)

     

       733
       736
        
       	return err

     

       734
       737
        
       }

     

       738
       738
       +
       

     

       739
       739
       +
       // RecalculateAllGlicko2Ratings recalculates all Glicko-2 ratings from scratch

     

       740
       740
       +
       // using proper rating periods where all matches for a player are batched together

     

       741
       741
       +
       func RecalculateAllGlicko2Ratings() error {

     

       742
       742
       +
       	// Reset all active submissions to initial ratings

     

       743
       743
       +
       	_, err := DB.Exec(`

     

       744
       744
       +
       		UPDATE submissions 

     

       745
       745
       +
       		SET glicko_rating = 1500.0, glicko_rd = 350.0, glicko_volatility = 0.06

     

       746
       746
       +
       		WHERE is_active = 1 AND status = 'completed'

     

       747
       747
       +
       	`)

     

       748
       748
       +
       	if err != nil {

     

       749
       749
       +
       		return err

     

       750
       750
       +
       	}

     

       751
       751
       +
       	

     

       752
       752
       +
       	// Get all active player IDs

     

       753
       753
       +
       	var playerIDs []int

     

       754
       754
       +
       	rows, err := DB.Query("SELECT id FROM submissions WHERE is_active = 1 AND status = 'completed'")

     

       755
       755
       +
       	if err != nil {

     

       756
       756
       +
       		return err

     

       757
       757
       +
       	}

     

       758
       758
       +
       	for rows.Next() {

     

       759
       759
       +
       		var id int

     

       760
       760
       +
       		if err := rows.Scan(&id); err != nil {

     

       761
       761
       +
       			return err

     

       762
       762
       +
       		}

     

       763
       763
       +
       		playerIDs = append(playerIDs, id)

     

       764
       764
       +
       	}

     

       765
       765
       +
       	rows.Close()

     

       766
       766
       +
       	

     

       767
       767
       +
       	// For each player, collect ALL their match results and update once (proper rating period)

     

       768
       768
       +
       	for _, playerID := range playerIDs {

     

       769
       769
       +
       		// Get player's current rating

     

       770
       770
       +
       		var rating, rd, volatility float64

     

       771
       771
       +
       		err := DB.QueryRow(

     

       772
       772
       +
       			"SELECT glicko_rating, glicko_rd, glicko_volatility FROM submissions WHERE id = ?",

     

       773
       773
       +
       			playerID,

     

       774
       774
       +
       		).Scan(&rating, &rd, &volatility)

     

       775
       775
       +
       		if err != nil {

     

       776
       776
       +
       			continue

     

       777
       777
       +
       		}

     

       778
       778
       +
       		

     

       779
       779
       +
       		// Collect ALL match results for this player in this rating period

     

       780
       780
       +
       		var results []Glicko2Result

     

       781
       781
       +
       		

     

       782
       782
       +
       		rows, err := DB.Query(`

     

       783
       783
       +
       			SELECT 

     

       784
       784
       +
       				CASE WHEN player1_id = ? THEN player2_id ELSE player1_id END as opponent_id,

     

       785
       785
       +
       				CASE WHEN player1_id = ? THEN player1_wins ELSE player2_wins END as my_wins,

     

       786
       786
       +
       				CASE WHEN player1_id = ? THEN player2_wins ELSE player1_wins END as opponent_wins

     

       787
       787
       +
       			FROM matches

     

       788
       788
       +
       			WHERE (player1_id = ? OR player2_id = ?) AND is_valid = 1

     

       789
       789
       +
       			ORDER BY timestamp ASC

     

       790
       790
       +
       		`, playerID, playerID, playerID, playerID, playerID)

     

       791
       791
       +
       		

     

       792
       792
       +
       		if err != nil {

     

       793
       793
       +
       			continue

     

       794
       794
       +
       		}

     

       795
       795
       +
       		

     

       796
       796
       +
       		for rows.Next() {

     

       797
       797
       +
       			var opponentID, myWins, opponentWins int

     

       798
       798
       +
       			if err := rows.Scan(&opponentID, &myWins, &opponentWins); err != nil {

     

       799
       799
       +
       				continue

     

       800
       800
       +
       			}

     

       801
       801
       +
       			

     

       802
       802
       +
       			// Get opponent's rating at the START of this rating period (not current)

     

       803
       803
       +
       			var oppRating, oppRD float64

     

       804
       804
       +
       			err := DB.QueryRow(

     

       805
       805
       +
       				"SELECT glicko_rating, glicko_rd FROM submissions WHERE id = ?",

     

       806
       806
       +
       				opponentID,

     

       807
       807
       +
       			).Scan(&oppRating, &oppRD)

     

       808
       808
       +
       			if err != nil {

     

       809
       809
       +
       				continue

     

       810
       810
       +
       			}

     

       811
       811
       +
       			

     

       812
       812
       +
       			totalGames := myWins + opponentWins

     

       813
       813
       +
       			score := float64(myWins) / float64(totalGames)

     

       814
       814
       +
       			

     

       815
       815
       +
       			results = append(results, Glicko2Result{

     

       816
       816
       +
       				OpponentRating: oppRating,

     

       817
       817
       +
       				OpponentRD:     oppRD,

     

       818
       818
       +
       				Score:          score,

     

       819
       819
       +
       			})

     

       820
       820
       +
       		}

     

       821
       821
       +
       		rows.Close()

     

       822
       822
       +
       		

     

       823
       823
       +
       		// Update this player's rating based on ALL results at once (proper rating period)

     

       824
       824
       +
       		if len(results) > 0 {

     

       825
       825
       +
       			player := Glicko2Player{Rating: rating, RD: rd, Volatility: volatility}

     

       826
       826
       +
       			newPlayer := updateGlicko2(player, results)

     

       827
       827
       +
       			

     

       828
       828
       +
       			DB.Exec(

     

       829
       829
       +
       				"UPDATE submissions SET glicko_rating = ?, glicko_rd = ?, glicko_volatility = ? WHERE id = ?",

     

       830
       830
       +
       				newPlayer.Rating, newPlayer.RD, newPlayer.Volatility, playerID,

     

       831
       831
       +
       			)

     

       832
       832
       +
       		}

     

       833
       833
       +
       	}

     

       834
       834
       +
       	

     

       835
       835
       +
       	return nil

     

       836
       836
       +
       }