feat: implement aditional players stats

Author: MichaelPlathanus

app/modules/analytics/controllers/ping_profile_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Analytics
+  module Controllers
+    # Ping Profile Analytics Controller
+    #
+    # Returns a player's communication profile derived from ping usage across matches.
+    # Requires ping data to be present (populated from Riot Match v5 API, patch 12.10+).
+    #
+    # @example
+    #   GET /api/v1/analytics/players/:player_id/ping-profile
+    #   GET /api/v1/analytics/players/:player_id/ping-profile?games=30
+    class PingProfileController < Api::V1::BaseController
+      def show
+        player = organization_scoped(Player).find(params[:player_id])
+        games = [params.fetch(:games, 20).to_i, 50].min
+
+        profile = PingProfileService.new(player, matches_limit: games).calculate
+
+        render_success({
+                         player: PlayerSerializer.render_as_hash(player),
+                         ping_profile: profile
+                       })
+      end
+    end
+  end
+end

app/modules/analytics/services/ping_profile_service.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Calculates a player's ping communication profile from recent match history.
+# Uses ping data stored in player_match_stats.pings (jsonb) to derive
+# behavioral metrics useful for coaching: map awareness, leadership, and communication style.
+class PingProfileService
+  AWARENESS_KEYS  = %w[enemy_missing danger enemy_vision].freeze
+  LEADERSHIP_KEYS = %w[command on_my_way push hold].freeze
+  DEFENSIVE_KEYS  = %w[get_back retreat danger].freeze
+  ALL_PING_KEYS   = %w[
+    all_in assist_me bait basic command danger
+    enemy_missing enemy_vision get_back hold need_vision
+    on_my_way push retreat vision_cleared
+  ].freeze
+
+  def initialize(player, matches_limit: 20)
+    @player = player
+    @matches_limit = matches_limit
+  end
+
+  def calculate
+    stats = fetch_stats_with_pings
+    return empty_profile if stats.empty?
+
+    ping_totals = aggregate_ping_totals(stats)
+    total = ping_totals.values.sum
+
+    {
+      player_id: @player.id,
+      games_analyzed: stats.size,
+      total_pings: total,
+      avg_pings_per_game: total.zero? ? 0 : (total.to_f / stats.size).round(1),
+      breakdown: ping_totals,
+      scores: calculate_scores(ping_totals, total),
+      profile_label: determine_profile_label(ping_totals, total)
+    }
+  end
+
+  private
+
+  def fetch_stats_with_pings
+    PlayerMatchStat
+      .where(player: @player)
+      .where("pings != '{}'::jsonb")
+      .order(created_at: :desc)
+      .limit(@matches_limit)
+  end
+
+  def aggregate_ping_totals(stats)
+    totals = ALL_PING_KEYS.each_with_object({}) { |k, h| h[k] = 0 }
+    stats.each do |stat|
+      next if stat.pings.blank?
+
+      ALL_PING_KEYS.each { |key| totals[key] += stat.pings[key].to_i }
+    end
+    totals
+  end
+
+  def calculate_scores(ping_totals, total)
+    return zeroed_scores if total.zero?
+
+    {
+      awareness: score_for_keys(ping_totals, AWARENESS_KEYS, total),
+      leadership: score_for_keys(ping_totals, LEADERSHIP_KEYS, total),
+      defensive: score_for_keys(ping_totals, DEFENSIVE_KEYS, total)
+    }
+  end
+
+  def score_for_keys(ping_totals, keys, total)
+    category_total = keys.sum { |k| ping_totals[k].to_i }
+    (category_total.to_f / total * 100).round(1)
+  end
+
+  def determine_profile_label(ping_totals, total)
+    return 'unknown' if total.zero?
+
+    scores = calculate_scores(ping_totals, total)
+    max_category = scores.max_by { |_, v| v }
+
+    case max_category[0]
+    when :awareness  then 'map_caller'
+    when :leadership then 'shotcaller'
+    when :defensive  then 'defensive_anchor'
+    else 'balanced'
+    end
+  end
+
+  def empty_profile
+    {
+      player_id: @player&.id,
+      games_analyzed: 0,
+      total_pings: 0,
+      avg_pings_per_game: 0,
+      breakdown: ALL_PING_KEYS.each_with_object({}) { |k, h| h[k] = 0 },
+      scores: zeroed_scores,
+      profile_label: 'unknown'
+    }
+  end
+
+  def zeroed_scores
+    { awareness: 0, leadership: 0, defensive: 0 }
+  end
+end

app/modules/matches/controllers/export_controller.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Matches
+  module Controllers
+    # Export Controller
+    #
+    # Exports match player stats as JSON or CSV.
+    # Scoped to the current organization.
+    #
+    # @example
+    #   GET /api/v1/matches/:id/export          -> JSON
+    #   GET /api/v1/matches/:id/export?format=csv -> CSV
+    class ExportController < Api::V1::BaseController
+      EXPORT_FIELDS = %w[
+        player_name champion role kills deaths assists
+        cs neutral_minions_killed cs_at_10
+        gold_earned damage_dealt_total damage_taken
+        damage_to_turrets turret_plates_destroyed
+        objectives_stolen crowd_control_score total_time_dead
+        vision_score wards_placed wards_destroyed
+        damage_shielded_teammates healing_to_teammates
+        spell_q_casts spell_w_casts spell_e_casts spell_r_casts
+        double_kills triple_kills quadra_kills penta_kills
+        performance_score
+      ].freeze
+
+      def show
+        match = organization_scoped(Match).find(params[:id])
+        stats = match.player_match_stats.includes(:player)
+
+        respond_to do |format|
+          format.json { render_json_export(match, stats) }
+          format.csv  { render_csv_export(match, stats) }
+          format.any  { render_json_export(match, stats) }
+        end
+      end
+
+      private
+
+      def render_json_export(match, stats)
+        render_success({
+                         match_id: match.id,
+                         riot_match_id: match.riot_match_id,
+                         game_start: match.game_start,
+                         patch_version: match.patch_version,
+                         players: stats.map { |s| build_row_hash(s) }
+                       })
+      end
+
+      def render_csv_export(match, stats)
+        csv_data = build_csv(stats)
+        filename = "match_#{match.riot_match_id || match.id}_#{Date.current}.csv"
+
+        send_data csv_data,
+                  type: 'text/csv; charset=utf-8',
+                  disposition: "attachment; filename=\"#{filename}\""
+      end
+
+      def build_csv(stats)
+        CSV.generate(headers: true) do |csv|
+          csv << EXPORT_FIELDS
+          stats.each { |s| csv << build_row_array(s) }
+        end
+      end
+
+      def build_row_hash(stat)
+        EXPORT_FIELDS.each_with_object({}) do |field, hash|
+          hash[field] = field == 'player_name' ? stat.player&.summoner_name : stat.public_send(field)
+        end
+      end
+
+      def build_row_array(stat)
+        EXPORT_FIELDS.map do |field|
+          field == 'player_name' ? stat.player&.summoner_name : stat.public_send(field)
+        end
+      end
+    end
+  end
+end

app/modules/matches/jobs/sync_match_job.rb

@@ -155,6 +155,7 @@ def create_stat_for_participant(match, player, participant_data, team_totals)
         damage_dealt_total: participant_data[:total_damage_dealt],
         damage_taken: participant_data[:total_damage_taken],
         cs: cs_total,
+        neutral_minions_killed: participant_data[:neutral_minions_killed],
         vision_score: participant_data[:vision_score],
         wards_placed: participant_data[:wards_placed],
         wards_destroyed: participant_data[:wards_killed],
@@ -169,7 +170,22 @@ def create_stat_for_participant(match, player, participant_data, team_totals)
         summoner_spell_1: participant_data[:summoner_spell_1],
         summoner_spell_2: participant_data[:summoner_spell_2],
         damage_share: damage_share,
-        gold_share: gold_share
+        gold_share: gold_share,
+        objectives_stolen: participant_data[:objectives_stolen],
+        crowd_control_score: participant_data[:crowd_control_score],
+        total_time_dead: participant_data[:total_time_dead],
+        damage_to_turrets: participant_data[:damage_to_turrets],
+        damage_shielded_teammates: participant_data[:damage_shielded_teammates],
+        healing_to_teammates: participant_data[:healing_to_teammates],
+        spell_q_casts: participant_data[:spell_q_casts],
+        spell_w_casts: participant_data[:spell_w_casts],
+        spell_e_casts: participant_data[:spell_e_casts],
+        spell_r_casts: participant_data[:spell_r_casts],
+        summoner_spell_1_casts: participant_data[:summoner_spell_1_casts],
+        summoner_spell_2_casts: participant_data[:summoner_spell_2_casts],
+        cs_at_10: participant_data[:cs_at_10],
+        turret_plates_destroyed: participant_data[:turret_plates_destroyed],
+        pings: participant_data[:pings] || {}
       )
     end
 

app/modules/players/controllers/stats_export_controller.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Players
+  module Controllers
+    # Stats Export Controller
+    #
+    # Exports a player's match stats history as JSON or CSV.
+    # Supports date range filtering.
+    #
+    # @example
+    #   GET /api/v1/players/:id/stats/export
+    #   GET /api/v1/players/:id/stats/export?format=csv&from=2026-01-01&to=2026-03-06
+    class StatsExportController < Api::V1::BaseController
+      EXPORT_FIELDS = %w[
+        match_date patch_version opponent champion role
+        kills deaths assists kda_display cs cs_at_10 cs_per_min
+        neutral_minions_killed gold_earned gold_per_min
+        damage_dealt_total damage_to_turrets turret_plates_destroyed
+        objectives_stolen crowd_control_score total_time_dead
+        vision_score wards_placed wards_destroyed
+        damage_shielded_teammates healing_to_teammates
+        spell_q_casts spell_w_casts spell_e_casts spell_r_casts
+        double_kills triple_kills quadra_kills penta_kills
+        performance_score result
+      ].freeze
+
+      def show
+        player = organization_scoped(Player).find(params[:player_id])
+        stats  = filtered_stats(player)
+
+        respond_to do |format|
+          format.json { render_json_export(player, stats) }
+          format.csv  { render_csv_export(player, stats) }
+          format.any  { render_json_export(player, stats) }
+        end
+      end
+
+      private
+
+      def filtered_stats(player)
+        scope = PlayerMatchStat.where(player: player)
+                               .joins(:match)
+                               .includes(:match)
+                               .order('matches.game_start DESC')
+        scope = scope.where('matches.game_start >= ?', Date.parse(params[:from])) if params[:from].present?
+        scope = scope.where('matches.game_start <= ?', Date.parse(params[:to]).end_of_day) if params[:to].present?
+        scope
+      end
+
+      def render_json_export(player, stats)
+        render_success({
+                         player: PlayerSerializer.render_as_hash(player),
+                         total_games: stats.count,
+                         stats: stats.map { |s| build_row_hash(s) }
+                       })
+      end
+
+      def render_csv_export(player, stats)
+        csv_data = build_csv(stats)
+        filename = "#{player.summoner_name}_stats_#{Date.current}.csv"
+
+        send_data csv_data,
+                  type: 'text/csv; charset=utf-8',
+                  disposition: "attachment; filename=\"#{filename}\""
+      end
+
+      def build_csv(stats)
+        CSV.generate(headers: true) do |csv|
+          csv << EXPORT_FIELDS
+          stats.each { |s| csv << build_row_array(s) }
+        end
+      end
+
+      def build_row_hash(stat)
+        EXPORT_FIELDS.each_with_object({}) do |field, hash|
+          hash[field] = export_field_value(stat, field)
+        end
+      end
+
+      def build_row_array(stat)
+        EXPORT_FIELDS.map { |field| export_field_value(stat, field) }
+      end
+
+      def export_field_value(stat, field)
+        case field
+        when 'match_date'   then stat.match&.game_start&.strftime('%Y-%m-%d')
+        when 'patch_version' then stat.match&.patch_version
+        when 'opponent'     then stat.match&.opponent_name
+        when 'result'       then stat.match&.victory? ? 'W' : 'L'
+        when 'kda_display'  then stat.kda_display
+        when 'cs_per_min'   then stat.cs_per_min&.round(2)
+        when 'gold_per_min' then stat.gold_per_min&.round(0)
+        else stat.public_send(field)
+        end
+      end
+    end
+  end
+end

app/modules/players/models/player_match_stat.rb

@@ -141,28 +141,33 @@ def calculate_performance_score
 
     score = 0
 
-    # KDA component (40 points max)
-    kda = kda_ratio
-    score += [kda * 10, 40].min
+    # KDA component (35 points max)
+    score += [kda_ratio * 8.75, 35].min
 
     # CS component (20 points max)
-    cs_score = (cs_per_min || 0) * 2.5
-    score += [cs_score, 20].min
+    score += [(cs_per_min || 0) * 2.5, 20].min
 
-    # Damage component (20 points max)
-    damage_score = (damage_share || 0) * 100 * 0.8
-    score += [damage_score, 20].min
+    # Damage component (15 points max)
+    score += [(damage_share || 0) * 100 * 0.6, 15].min
 
     # Vision component (10 points max)
-    vision_score_normalized = vision_score.to_f / 100
-    score += [vision_score_normalized * 10, 10].min
+    score += [vision_score.to_f / 100 * 10, 10].min
+
+    # CC + objectives bonus (10 points max)
+    score += cc_and_objectives_bonus
 
     # Victory bonus (10 points max)
     score += 10 if match.victory?
 
     [score, 100].min.round(2)
   end
 
+  def cc_and_objectives_bonus
+    cc_bonus = crowd_control_score.present? ? [crowd_control_score.to_f / 100, 5].min : 0
+    obj_bonus = objectives_stolen.to_i > 0 ? 5 : 0
+    cc_bonus + obj_bonus
+  end
+
   def update_champion_pool
     pool = player.champion_pools.find_or_initialize_by(champion: champion)