feat: improve inhouse features

Author: Bulletdev

app/models/inhouse_participation.rb

@@ -14,6 +14,8 @@ class InhouseParticipation < ApplicationRecord
   validates :player_id, uniqueness: { scope: :inhouse_id, message: 'is already in this inhouse' }
   validates :team, inclusion: { in: %w[none blue red] }
 
+  ROLES = %w[top jungle mid adc support fill].freeze
+
   # Scopes
   scope :blue_team, -> { where(team: 'blue') }
   scope :red_team,  -> { where(team: 'red') }

app/models/player_inhouse_rating.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Stores per-player, per-role TrueSkill ratings for the inhouse ladder.
+#
+# One record per (player, role) pair. Created on first game and updated
+# after every record_game call via TrueSkillService.
+#
+# @example Find or initialise a rating
+#   rating = PlayerInhouseRating.for(player, role)
+#   rating.mmr  # => 0 (fresh player)
+#
+class PlayerInhouseRating < ApplicationRecord
+  MU_INITIAL    = 25.0
+  SIGMA_INITIAL = 25.0 / 3.0 # ≈ 8.333
+  ROLES         = %w[top jungle mid adc support fill].freeze
+
+  belongs_to :player
+  belongs_to :organization
+
+  validates :role, inclusion: { in: ROLES }
+  validates :player_id, uniqueness: { scope: :role }
+  validates :mu, :sigma, :games_played, :wins, :losses, presence: true
+
+  # Conservative skill estimate used for ladder ranking.
+  # Returns an integer in roughly 0–3000 range.
+  def mmr
+    [((mu - (3.0 * sigma)) * 100).round, 0].max
+  end
+
+  def win_rate
+    return 0.0 if games_played.zero?
+
+    (wins.to_f / games_played * 100).round(1)
+  end
+
+  # Find an existing rating or build a fresh one (unsaved).
+  def self.for(player, role, organization)
+    find_or_initialize_by(player: player, role: role) do |r|
+      r.organization = organization
+      r.mu           = MU_INITIAL
+      r.sigma        = SIGMA_INITIAL
+    end
+  end
+end

app/modules/inhouses/controllers/inhouse_queues_controller.rb

@@ -200,12 +200,13 @@ def start_session
             formation_mode: formation_mode
           )
 
-          # Join all checked-in players
+          # Join all checked-in players, preserving their queued role
           entries.each do |entry|
             inhouse.inhouse_participations.create!(
               player: entry.player,
               team: 'none',
               tier_snapshot: entry.tier_snapshot,
+              role: entry.role,
               is_captain: false
             )
           end
@@ -409,7 +410,11 @@ def serialize_inhouse(inhouse, detailed: false)
               player_id: p.player_id,
               player_name: p.player&.summoner_name,
               team: p.team,
+              role: p.role,
               tier_snapshot: p.tier_snapshot,
+              mu_snapshot: p.mu_snapshot,
+              sigma_snapshot: p.sigma_snapshot,
+              mmr_delta: p.mmr_delta,
               is_captain: p.is_captain,
               wins: p.wins,
               losses: p.losses

app/modules/inhouses/controllers/inhouses_controller.rb

@@ -22,51 +22,72 @@ class InhousesController < Api::V1::BaseController
       before_action :set_inhouse, only: %i[join balance_teams start_draft captain_pick start_game record_game close]
 
       # GET /api/v1/inhouse/ladder
-      # Returns per-player win/loss/win-rate aggregated across all done sessions.
+      # Returns per-player TrueSkill ratings sorted by MMR descending.
+      # Optional query param: ?role=mid  (filter by role)
       def ladder
         authorize Inhouse
 
-        rows = InhouseParticipation
-               .joins(:inhouse, :player)
-               .where(inhouses: { organization_id: current_organization.id, status: 'done' })
-               .where.not(team: 'none')
-               .group(:player_id)
-               .select(
-                 'player_id',
-                 'SUM(wins) AS total_wins',
-                 'SUM(losses) AS total_losses'
-               )
-               .to_a
-
-        player_ids = rows.map(&:player_id)
-        players_by_id = current_organization.players
-                                            .where(id: player_ids)
-                                            .index_by(&:id)
-
-        entries = rows.map do |row|
-          player = players_by_id[row.player_id]
-          next unless player
-
-          total = row.total_wins.to_i + row.total_losses.to_i
-          win_rate = total.zero? ? 0.0 : (row.total_wins.to_f / total * 100).round(1)
+        scope = PlayerInhouseRating
+                .joins(:player)
+                .where(organization_id: current_organization.id)
 
+        scope = scope.where(role: params[:role].downcase) if params[:role].present?
+
+        ratings = scope.includes(:player).to_a
+
+        entries = ratings.map do |r|
           {
-            player_id: row.player_id,
-            player_name: player.summoner_name,
-            role: player.role,
-            wins: row.total_wins.to_i,
-            losses: row.total_losses.to_i,
-            total_games: total,
-            win_rate: win_rate
+            player_id: r.player_id,
+            player_name: r.player&.summoner_name,
+            role: r.role,
+            mu: r.mu.round(3),
+            sigma: r.sigma.round(3),
+            mmr: r.mmr,
+            games_played: r.games_played,
+            wins: r.wins,
+            losses: r.losses,
+            win_rate: r.win_rate
           }
-        end.compact
+        end
 
-        entries.sort_by! { |e| [-e[:wins], e[:losses]] }
+        entries.sort_by! { |e| -e[:mmr] }
         entries.each_with_index { |e, i| e[:rank] = i + 1 }
 
         render_success({ entries: entries, total: entries.size })
       end
 
+      # GET /api/v1/inhouse/ladder/:player_id
+      # Returns all role ratings for a single player.
+      def player_ratings
+        authorize Inhouse
+
+        player = current_organization.players.find_by(id: params[:player_id])
+        return render_not_found unless player
+
+        ratings = PlayerInhouseRating
+                  .where(player: player, organization: current_organization)
+                  .order(:role)
+
+        entries = ratings.map do |r|
+          {
+            role: r.role,
+            mu: r.mu.round(3),
+            sigma: r.sigma.round(3),
+            mmr: r.mmr,
+            games_played: r.games_played,
+            wins: r.wins,
+            losses: r.losses,
+            win_rate: r.win_rate
+          }
+        end
+
+        render_success({
+                         player_id: player.id,
+                         player_name: player.summoner_name,
+                         ratings: entries
+                       })
+      end
+
       # GET /api/v1/inhouse/sessions
       # Returns paginated history of completed inhouse sessions with summary.
       def sessions
@@ -208,10 +229,15 @@ def join
           )
         end
 
+        role = params[:role].to_s.downcase.presence
+        role = nil unless InhouseParticipation::ROLES.include?(role)
+        role ||= player.role.presence
+
         participation = @inhouse.inhouse_participations.new(
           player: player,
           team: 'none',
-          tier_snapshot: player.solo_queue_tier.presence
+          tier_snapshot: player.solo_queue_tier.presence,
+          role: role
         )
 
         if participation.save
@@ -455,7 +481,7 @@ def record_game
           @inhouse.increment!(:red_wins)
         end
 
-        # Update per-player wins/losses
+        # Update per-player wins/losses and TrueSkill ratings
         @inhouse.inhouse_participations.each do |p|
           next if p.team == 'none'
 
@@ -466,6 +492,8 @@ def record_game
           end
         end
 
+        TrueSkillService.update_ratings(@inhouse, winner)
+
         render_success(
           { inhouse: serialize_inhouse(@inhouse.reload) },
           message: "Game recorded — #{winner.capitalize} team wins"
@@ -574,7 +602,11 @@ def serialize_inhouse(inhouse, detailed: false)
               player_id: p.player_id,
               player_name: p.player&.summoner_name,
               team: p.team,
+              role: p.role,
               tier_snapshot: p.tier_snapshot,
+              mu_snapshot: p.mu_snapshot,
+              sigma_snapshot: p.sigma_snapshot,
+              mmr_delta: p.mmr_delta,
               is_captain: p.is_captain,
               wins: p.wins,
               losses: p.losses