sorare-rewards 0.1.0.beta11

data/lib/sorare/rewards/interactors/allocations/compute_for_quality.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Allocations
+      # ComputeForQuality computes the reward allocations for a given quality supply between the divisions of a league
+      class ComputeForQuality
+        include Interactor
+
+        delegate :supply, :config, :randomizer, :allocated, to: :context
+
+        def call
+          check_config!
+
+          context.allocated = Array.new(config.length, 0)
+          allocate!
+          context.quality_allocations = allocations
+        end
+
+        def allocations
+          config.length.times.map do |division|
+            [Sorare::Rewards.configuration.transform_division.call(division + 1), allocated[division]]
+          end.to_h
+        end
+
+        def allocate!
+          allocate_cards
+          allocate_pct if has?('pct')
+          allocate_extra if has?('pct')
+          allocate_loop if has?('loop')
+        end
+
+        def allocate_divisions(&block)
+          config.each_with_index(&block)
+        end
+
+        def allocate_cards
+          allocate_divisions do |division_config, division|
+            count = [remaining_supply, division_config['cards'] || 0].min
+
+            allocated[division] += count
+          end
+        end
+
+        def allocate_pct
+          allocate_divisions do |division_config, division|
+            count = [remaining_supply, (supply * (division_config['pct'] || 0)).floor].min
+
+            allocated[division] += count
+          end
+        end
+
+        def allocate_loop
+          while remaining_supply.positive?
+            allocate_divisions do |division_config, division|
+              allocated[division] += [division_config['loop'] || 0, remaining_supply].min
+            end
+          end
+        end
+
+        def allocate_extra
+          allocate_divisions do |division_config, division|
+            count = pick_extra_supply((supply * (division_config['pct'] || 0)).modulo(1))
+
+            allocated[division] += count
+          end
+        end
+
+        def remaining_supply
+          supply - allocated.sum
+        end
+
+        def pick_extra_supply(probability)
+          reward_probability = randomizer.rand
+          return 0 unless remaining_supply.positive?
+          return 0 unless reward_probability < probability
+
+          1
+        end
+
+        def has?(key)
+          !config.first[key].nil?
+        end
+
+        def check_config!
+          return if config && [0, 1].include?(config.sum { |q| q['pct'] || 0 })
+
+          context.fail!(error: 'Invalid config')
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/allocations/compute_for_rarity.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/enumerable'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Allocations
+      # ComputeForRarity computes the reward allocations for a rarity in a league
+      class ComputeForRarity
+        include Interactor
+
+        delegate :supply, :config, to: :context
+
+        def call
+          context.fail!(error: 'Invalid config') unless config
+
+          context.rarity_allocations = supply.each_with_index.map do |tier_supply, tier|
+            ComputeForQuality.call!(
+              **context.to_h,
+              supply: tier_supply,
+              config: tier_config(tier)
+            ).quality_allocations
+          end
+        end
+
+        def tier_config(tier)
+          config[Sorare::Rewards.configuration.transform_tier.call(tier)]
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/build.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    # Build builds the rewards structure for a given game week
+    class Build
+      include Interactor
+
+      delegate :data, :salt, to: :context
+
+      def call
+        context.game_week_supply = game_week_supply
+        context.allocations = allocate!
+      end
+
+      def allocate!
+        Allocations::ComputeForGameWeek.call!(
+          **data.to_h, supply: game_week_supply, salt: salt
+        ).game_week_allocations
+      end
+
+      def game_week_supply
+        @game_week_supply ||= Supply::ComputeForGameWeek.call!(**data.to_h, salt: salt)
+                                                        .game_week_supply
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/cards/pick_for_division.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/enumerable'
+require 'interactor'
+require 'yaml'
+
+module Sorare
+  module Rewards
+    module Cards
+      # PickForDivision picks the rewards for a given division
+      # Receive a list of eligible qualified cards
+      #   {
+      #     'rare' => {
+      #       0 => ['kylian-mbappe-lottin', 'kylian-mbappe-lottin', 'keylor-navas', ...]
+      #     }
+      #   }
+      # A game week league supply
+      #   {
+      #     'rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...},
+      #     'super_rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      #   }
+      # And a reward allocations
+      #   {
+      #     'rare' => [5, 15, 0, 0],
+      #     'super_rare' => [1, 4, 0, 0],
+      #     'unique' => [0, 0, 1, 0]
+      #   }
+      class PickForDivision
+        include Interactor
+
+        delegate :allocations, :cards, :qualified_players, :supply, to: :context
+
+        def call
+          context.division_picks = allocations.keys.index_with do |rarity|
+            PickForDivisionAndRarity.call!(
+              **context.to_h, cards: cards[rarity], allocations: allocations[rarity], supply: supply[rarity]
+            ).rarity_picks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/cards/pick_for_division_and_rarity.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/enumerable'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Cards
+      # PickForDivisionAndRarity picks the rewards for a given division and rarity
+      # Receive a randomizer, a list of eligible qualified cards of the corresponding rarity
+      #   {
+      #     'tier_0' => ['kylian-mbappe-lottin', 'kylian-mbappe-lottin', 'keylor-navas', ...]
+      #   }
+      # A game week league rarity supply
+      #   { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      # And a reward allocations
+      #   { 'tier_0' => 1, 'tier_1' => 2 }
+      class PickForDivisionAndRarity
+        include Interactor
+
+        delegate :allocations, :cards, to: :context
+
+        def call
+          context.rarity_picks = supply!
+        end
+
+        def supply!
+          allocations.keys.index_with do |tier|
+            PickForDivisionRarityAndQuality.call!(**context.to_h, allocations: allocations[tier],
+                                                                  cards: cards[tier]).picks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/cards/pick_for_division_rarity_and_quality.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Cards
+      # PickForDivisionRarityAndQuality picks the rewards for a given division, rarity, and quality
+      # Receive a list of eligible qualified cards
+      #   ['kylian-mbappe-lottin', 'kylian-mbappe-lottin', 'keylor-navas', ...]
+      # A game week league rarity supply
+      #   { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      # And a reward allocations
+      #   15
+      class PickForDivisionRarityAndQuality
+        include Interactor
+
+        MISSING_CARDS = 'There are not enough cards to fulfill the requirements'
+
+        delegate :cards, :allocations, :supply, :force, :picks, :randomizer, to: :context
+
+        def call
+          context.picks = []
+
+          pick!
+          check_length! unless force
+          reorder!
+        end
+
+        def pick!
+          while picks.length != allocations && cards.length.positive?
+            picks.push(cards.delete_at(randomizer.rand * cards.length))
+          end
+        end
+
+        def reorder!
+          picks.sort! { |a, b| supply[a]['rank'].to_i <=> supply[b]['rank'].to_i }
+        end
+
+        def check_length!
+          return if picks.length == allocations
+
+          context.fail!(error: MISSING_CARDS)
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/cards/pick_for_game_week.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/enumerable'
+require 'interactor'
+require 'yaml'
+
+module Sorare
+  module Rewards
+    module Cards
+      # PickForGameWeek picks the rewards for a given game week
+      # Receive a Game Week reward supply data
+      #   { public_seed: 123, playing_players: [...], supply: {...} }
+      # And a reward allocations
+      #    {
+      #      'global-all_star' => {
+      #        'D1' => {
+      #          'rare' => { 'tier_0': 1, 'tier_1': 1 }
+      #        }
+      #      }
+      #    }
+      class PickForGameWeek
+        include Interactor
+
+        delegate :supply, :allocations, :randomizer, :public_seed, :salt, to: :context
+
+        def call
+          context.randomizer = Sorare::Rewards::Random.new(public_seed, salt)
+          context.picks = picks
+        end
+
+        def picks
+          allocations.keys.index_with do |league|
+            PickForLeague.call!(**context.to_h, supply: supply[league], allocations: allocations[league]).league_picks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/cards/pick_for_league.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/enumerable'
+require 'interactor'
+require 'yaml'
+
+module Sorare
+  module Rewards
+    module Cards
+      # PickForLeague picks the rewards for a given league
+      # Receive a game week league supply
+      #   {
+      #     'rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...},
+      #     'super_rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      #   }
+      # And a reward allocations
+      #   {
+      #     'D1' => {
+      #       'rare' => { 'tier_0' => 1, 'tier_1' => 2 }
+      #     }
+      #   }
+      class PickForLeague
+        include Interactor
+
+        delegate :supply, :allocations, :cards, to: :context
+
+        def call
+          context.cards = {}
+          add_cards!
+
+          context.league_picks = allocations.keys.index_with do |division|
+            PickForDivision.call!(
+              **context.to_h, cards: cards, allocations: allocations[division]
+            ).division_picks
+          end
+        end
+
+        def add_cards!
+          supply.keys.index_with do |rarity|
+            cards[rarity] = {}
+            qualify_and_add!(rarity)
+          end
+        end
+
+        def qualify_and_add!(rarity)
+          qualified_players = Tiers::QualifyPlayers.call!(sorted_supply: supply[rarity]).players
+          qualified_players.each_with_index.map do |players, tier|
+            transformed_tier = Sorare::Rewards.configuration.transform_tier.call(tier)
+            cards[rarity][transformed_tier] = []
+
+            players.each do |player_slug|
+              add(player_slug, rarity, transformed_tier)
+            end
+          end
+        end
+
+        def add(player_slug, rarity, tier)
+          cards[rarity][tier] += Array.new(supply[rarity][player_slug]['supply'], player_slug)
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/pick.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    # Pick the rewards for a given game week
+    # Receive a Game Week reward supply data
+    # And a reward allocations
+    #    {
+    #      'global-all_star' => {
+    #        'rare' => {
+    #          'D1' => { 'tier_0' => 0, 'tier_1' => 1 }
+    #        }
+    #      }
+    #    }
+    class Pick
+      include Interactor
+
+      delegate :allocations, :data, :salt, to: :context
+
+      # Depending on the way the allocations interpreter is implemented it could be done by him or we
+      # update the allocations process to match the structure
+      def call
+        context.picks = Sorare::Rewards::Cards::PickForGameWeek.call!(
+          **data.to_h, salt: salt, allocations: Transposer.transpose_allocations(allocations)
+        ).picks
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/supply/compute_for_game_week.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Supply
+      # ComputeForGameWeek computes the rewardable supply of a game week based on the overall supply
+      class ComputeForGameWeek
+        include Interactor
+
+        delegate :public_seed, :salt, :supply, :playing_players, :game_week_supply, to: :context
+
+        def call
+          context.game_week_supply = supply.keys.index_with do |league|
+            ComputeForLeague.call!(**context.to_h, randomizer: randomizer, supply: supply[league]).league_supply
+          end
+        end
+
+        def randomizer
+          @randomizer ||= Sorare::Rewards::Random.new(public_seed, salt)
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/supply/compute_for_league.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Supply
+      # ComputeForLeague computes the rewardable supply of a league
+      class ComputeForLeague
+        include Interactor
+
+        delegate :randomizer, :supply, :playing_players, to: :context
+
+        def call
+          context.league_supply = supply.keys.index_with do |rarity|
+            ComputeForRarity.call!(**context.to_h, supply: supply[rarity]).rarity_supply
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/supply/compute_for_quality.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Supply
+      # ComputeForQuality computes the rewardable supply for a given quality between the divisions of a league
+      class ComputeForQuality
+        include Interactor
+
+        delegate :randomizer, :total_supply, :tier_supply, :rewarded, :rewardable, to: :context
+
+        def call
+          context.quality_supply = total_supply.zero? ? 0 : quality_supply
+        end
+
+        def quality_supply
+          plain, extra = (tier_supply.to_f * rewardable).divmod(total_supply)
+
+          plain + remaining_supply(plain, extra)
+        end
+
+        def remaining_supply(plain, extra)
+          reward_probability = randomizer.rand
+          return 0 if rewarded.sum + plain >= rewardable
+          return 0 if extra.zero?
+          return 0 if reward_probability > (extra.to_f / total_supply)
+
+          1
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/supply/compute_for_rarity.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Supply
+      # ComputeForRarity computes the rewardable supply for a given rarity
+      class ComputeForRarity
+        include Interactor
+
+        delegate :randomizer, :supply, :playing_players, :rewardable, :rarity_supply,
+                 :minimum_remaining_games, to: :context
+
+        def call
+          context.rarity_supply = []
+
+          context.rewardable = compute_rewardable_supply!
+          distribute_in_tiers!
+        end
+
+        def compute_rewardable_supply!
+          total_supply = playing_players.keys.sum do |player|
+            player_supply(player)
+          end
+
+          rounded_supply(total_supply)
+        end
+
+        def distribute_in_tiers!
+          ctx = Tiers::QualifySupply.call!(sorted_supply: supply)
+          ctx.supply.each do |tier_supply|
+            rarity_supply.push(
+              ComputeForQuality.call!(
+                randomizer: randomizer,
+                total_supply: ctx.count,
+                tier_supply: tier_supply,
+                rewardable: rewardable,
+                rewarded: rarity_supply
+              ).quality_supply
+            )
+          end
+        end
+
+        def player_supply(slug)
+          remaining_games = playing_players[slug] || 0
+          return 0 unless remaining_games.positive?
+          return 0 unless supply[slug]
+
+          supply[slug]['supply'].to_f / corrected_remaining_games(remaining_games)
+        end
+
+        def rounded_supply(float_supply)
+          float_supply.floor + remaining_supply(float_supply.modulo(1))
+        end
+
+        # To be improved to handle properly seasons overlap
+        def corrected_remaining_games(remaining_games)
+          [remaining_games, minimum_remaining_games || 10].max
+        end
+
+        def remaining_supply(reward_probability)
+          probability = randomizer.rand
+          return 0 unless probability < reward_probability
+
+          1
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/tiers/qualify_players.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    module Tiers
+      # QualifyPlayers qualifies a list of sorted supply in tiers based on its rank or a provided tier
+      # Returns an array of tiers (array) containing the list of slugs for that tier
+      class QualifyPlayers
+        include Interactor
+
+        delegate :sorted_supply, to: :context
+
+        def call
+          context.players = by_rank ? qualified_players_by_rank : qualified_players_by_tier
+        end
+
+        # Use the tier specified within the data
+        def qualified_players_by_tier
+          tiers = Sorare::Rewards.configuration.tiers.times.map { |_| [] }
+          sorted_supply.each do |slug, data|
+            tiers[data['tier']] << slug
+          end
+
+          tiers
+        end
+
+        # Use the rank in the array
+        def qualified_players_by_rank
+          nb_of_tiers.times.map do |tier|
+            sorted_supply.keys[tier_index(tier)..tier_index(tier + 1) - 1]
+          end
+        end
+
+        def tier_depth
+          @tier_depth ||= sorted_supply.keys.length / (nb_of_tiers**2 - 1)
+        end
+
+        def nb_of_tiers
+          @nb_of_tiers ||= begin
+            default = Sorare::Rewards.configuration.tiers
+            default -= 1 while (default**2 - 1) > sorted_supply.keys.length
+
+            default
+          end
+        end
+
+        def tier_index(tier)
+          return 0 unless tier.positive?
+          return sorted_supply.keys.length if tier == nb_of_tiers
+
+          tier_index(tier - 1) + tier_depth * tier_size(tier - 1)
+        end
+
+        def tier_size(tier)
+          return 1 unless tier.positive?
+
+          tier_size(tier - 1) * 2
+        end
+
+        def by_rank
+          @by_rank ||= sorted_supply.values.first&.dig('tier').nil?
+        end
+      end
+    end
+  end
+end