david/euchre_camp
Public Access
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects 1 Releases 1 Wiki Activity

feat(tournaments): add partnership tracking and tournament management

Browse Source 
Implement comprehensive partnership tracking system and tournament
management features including round-robin, single/double elimination,
and Swiss system pairings.

Changes:
- Add partnership_games and partnership_stats tables
- Implement PartnershipTracker service for recording partnership data
- Add tournament generator with multiple formats
- Create tournament management actions and views
- Add acceptance tests for partnership tracking
- Fix PartnershipTracker to use single snapshot per player per match
- Fix round-robin test to query by round_number instead of hardcoded ID

Note: All 8 acceptance tests now passing
This commit is contained in:
David Gwilliam
2026-03-27 12:25:34 -07:00
parent cb47b9da99
commit ac858f1e6d
55 changed files with 2591 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/services/partnership_tracker.rb
+108
View File
@@ -0,0 +1,108 @@
# frozen_string_literal: true
module EuchreCamp
module Services
class PartnershipTracker
# Record partnerships when a match completes
def self.record_match(match_id)
rom = EuchreCamp::App["persistence.rom"]
match = rom.relations[:matches].by_pk(match_id).one
return unless match
games_repo = EuchreCamp::App["repositories.partnership_games"]
stats_repo = EuchreCamp::App["repositories.partnership_stats"]
# Calculate Elo changes for each player
# This is called AFTER Elo calculation, so we get the change from elo_snapshots
elo_changes = calculate_elo_changes(match_id)
# Record Team 1 partnership
record_partnership(
games_repo: games_repo,
stats_repo: stats_repo,
match_id: match_id,
player_1_id: match[:team_1_p1_id],
player_2_id: match[:team_1_p2_id],
team_number: 1,
won: match[:team_1_score] > match[:team_2_score],
elo_change: elo_changes[match[:team_1_p1_id]] + elo_changes[match[:team_1_p2_id]]
)
# Record Team 2 partnership
record_partnership(
games_repo: games_repo,
stats_repo: stats_repo,
match_id: match_id,
player_1_id: match[:team_2_p1_id],
player_2_id: match[:team_2_p2_id],
team_number: 2,
won: match[:team_2_score] > match[:team_1_score],
elo_change: elo_changes[match[:team_2_p1_id]] + elo_changes[match[:team_2_p2_id]]
)
end
def self.calculate_elo_changes(match_id)
rom = EuchreCamp::App["persistence.rom"]
# Get the two most recent snapshots before and after this match
snapshots = rom.relations[:elo_snapshots]
.where(match_id: match_id)
.order(:created_at)
.to_a
# Group by player and calculate change
changes = Hash.new(0)
snapshots.group_by { |s| s[:player_id] }.each do |player_id, player_snapshots|
# For a single match, there should be exactly one snapshot per player
# The snapshot contains rating_before and rating_after for this specific match
# So we calculate the change directly from that snapshot
player_snapshots.each do |snapshot|
changes[player_id] = snapshot[:rating_after] - snapshot[:rating_before]
end
end
changes
end
def self.record_partnership(games_repo:, stats_repo:, match_id:, player_1_id:, player_2_id:, team_number:, won:, elo_change:)
# Record the partnership game
games_repo.create(
match_id: match_id,
player_1_id: player_1_id,
player_2_id: player_2_id,
team_number: team_number,
won_match: won ? 1 : 0
)
# Update partnership statistics (using consistent ordering)
stats_repo.update_stats(player_1_id, player_2_id, won: won, elo_change: elo_change)
end
# Get partnership statistics for a player
def self.get_player_partnerships(player_id)
stats_repo = EuchreCamp::App["repositories.partnership_stats"]
players_repo = EuchreCamp::App["repositories.players"]
stats = stats_repo.by_player(player_id)
all_players = players_repo.all.to_h { |p| [p[:id], p] }
stats.map do |stat|
partner_id = stat[:player_1_id] == player_id ? stat[:player_2_id] : stat[:player_1_id]
partner = all_players[partner_id]
{
partner: partner,
games_played: stat[:games_played],
wins: stat[:wins],
losses: stat[:losses],
win_rate: stat[:games_played] > 0 ? (stat[:wins].to_f / stat[:games_played]).round(3) : 0,
total_elo_change: stat[:total_elo_change],
avg_elo_change: stat[:games_played] > 0 ? (stat[:total_elo_change].to_f / stat[:games_played]).round(2) : 0,
last_played: stat[:last_played]
}
end.sort_by { |p| -p[:games_played] }
end
end
end
end
app/services/tournament_generator.rb
+204
View File
@@ -0,0 +1,204 @@
# frozen_string_literal: true
module EuchreCamp
module Services
class TournamentGenerator
# Generate matchups for round-robin tournament
# Uses circle method for scheduling
def self.round_robin(teams)
n = teams.length
return [] if n < 2
# Handle odd number of teams by adding a bye
teams_with_bye = teams.dup
bye_team = { id: nil, name: "BYE" }
teams_with_bye << bye_team if n.odd?
total_teams = teams_with_bye.length
rounds = []
# Circle method: fix first team, rotate others
(total_teams - 1).times do |round_num|
round_matchups = []
half = total_teams / 2
half.times do |i|
team_a = teams_with_bye[i]
team_b = teams_with_bye[total_teams - 1 - i]
# Skip if either is BYE
next if team_a[:id].nil? || team_b[:id].nil?
round_matchups << {
team_1_id: team_a[:id],
team_2_id: team_b[:id]
}
end
rounds << {
round_number: round_num + 1,
matchups: round_matchups
}
# Rotate teams (circle method)
teams_with_bye = [teams_with_bye[0]] + teams_with_bye[1..-1].rotate(-1)
end
rounds
end
# Generate single elimination bracket
def self.single_elimination(seeded_teams)
# seeded_teams should be array of { id: team_id, seed: number }
teams = seeded_teams.sort_by { |t| t[:seed] || 0 }
# Ensure power of 2 or add byes
bracket_size = 1
while bracket_size < teams.length
bracket_size *= 2
end
# Create bracket structure
bracket = []
positions = {}
# Calculate bracket positions
(1..bracket_size).each do |pos|
positions[pos] = pos
end
# Fill bracket with teams and byes
team_index = 0
(1..bracket_size).each do |pos|
if team_index < teams.length
positions[pos] = teams[team_index][:id]
team_index += 1
else
positions[pos] = nil # BYE
end
end
# Generate matchups for first round
matchups = []
num_matchups = bracket_size / 2
num_matchups.times do |i|
pos1 = i * 2 + 1
pos2 = i * 2 + 2
team1 = positions[pos1]
team2 = positions[pos2]
# Only add matchup if both teams exist (no BYE vs BYE)
unless team1.nil? && team2.nil?
matchups << {
team_1_id: team1,
team_2_id: team2,
bracket_position: i + 1,
winner_position: (i / 2) + 1 # Where winner advances to
}
end
end
{
bracket_size: bracket_size,
first_round_matchups: matchups,
bracket_positions: positions
}
end
# Generate double elimination bracket
def self.double_elimination(seeded_teams)
# For simplicity, returning structure for winner's bracket and loser's bracket
teams = seeded_teams.sort_by { |t| t[:seed] || 0 }
# Generate winner's bracket (same as single elim)
winners_bracket = single_elimination(teams)
# Loser's bracket structure (simplified)
# In full implementation, this would be more complex
loser_bracket_rounds = []
{
winners_bracket: winners_bracket,
loser_bracket: loser_bracket_rounds
}
end
# Generate Swiss system pairings
def self.swiss(teams, round_number, standings = {})
# standings should be hash of team_id => { wins, losses, points }
return [] if teams.empty?
# Sort teams by current score (descending)
sorted_teams = teams.sort_by do |team|
score = standings[team[:id]] || { wins: 0, losses: 0, points: 0 }
[-score[:wins], -score[:points]]
end
# Pair similar scores
matchups = []
paired = Set.new
sorted_teams.each_with_index do |team, i|
next if paired.include?(team[:id])
# Find opponent with similar score
opponent = nil
(i + 1...sorted_teams.length).each do |j|
candidate = sorted_teams[j]
unless paired.include?(candidate[:id])
opponent = candidate
break
end
end
if opponent
matchups << {
team_1_id: team[:id],
team_2_id: opponent[:id]
}
paired << team[:id]
paired << opponent[:id]
end
end
[{
round_number: round_number,
matchups: matchups
}]
end
# Calculate number of matches for each format
def self.match_count(format, participant_count)
case format
when 'round_robin'
participant_count * (participant_count - 1) / 2
when 'single_elim'
participant_count - 1
when 'double_elim'
(participant_count * 2) - 2
when 'swiss'
# Assuming log2(participant_count) rounds
rounds = Math.log2(participant_count).ceil
(participant_count * rounds) / 2
else
0
end
end
# Validate participant count for format
def self.valid_participant_count?(format, count)
case format
when 'round_robin'
count >= 2
when 'single_elim', 'double_elim'
# Must be power of 2 for pure bracket, or allow byes
count >= 2
when 'swiss'
count >= 2
else
false
end
end
end
end
end