cw_card_utils 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 542ae86bcb4458bd4fd9a53552089133dad00a4f716e5cf5bc73de11a52da217
-  data.tar.gz: 835722e23e181a4f4eeb945a18ca5ebb523825d097c42aa8533ed86cb278a042
+  metadata.gz: e301d659cb6e96974ef4b5aa075e3951d8b875b645a3518ec8ae7c77211a0d42
+  data.tar.gz: 638f1bb63aabb8db4d648df1070c156c34c6d9b8c5dc7770b0cde08fa4513f9d
 SHA512:
-  metadata.gz: 9ff3819a39ee37ee199013b2cb32c5f08f16e139a2d9138ee39d833123f7b40de7fcd4ab20238cd49ef683faca8319166d96cb10df252e88edae953965ae66d4
-  data.tar.gz: e867a1dbe6cda9971d7d28e976c610a250d0799b730fe1f107330e2fe6f81cad29021716893bd1b51fa6b5f45b900392b39c04236785ba93a66c0821825e1b8c
+  metadata.gz: afd81df332b4f152ab7acd249aeff97d482b2fbc8300eeb6b6f42edec278575b2e33333ad09140d1651f80e2cfd4de7ad3dd18d7fc8c04111d60bb8711c22536
+  data.tar.gz: db60344938a90eebb336e84e944dd6528699e227b2231cac4bca997dbaeddc3f0ad705511a72726c5a87ee7e4557939bf2334b94338729acee5b1360ff6e837f

data/lib/cw_card_utils/deck_comparator.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
 module CwCardUtils
-
   class DeckComparator
     attr_reader :deck_a, :deck_b, :analysis
 
+    WEIGHTS = {
+      archetype: 0.30,
+      curve:     0.25,
+      synergy:   0.25,
+      interaction: 0.20,
+    }.freeze
+
     def initialize(deck_a, deck_b)
       @deck_a = deck_a
       @deck_b = deck_b
@@ -12,31 +18,49 @@ module CwCardUtils
     end
 
     def compare
-      a_info = analyze_deck(deck_a)
-      b_info = analyze_deck(deck_b)
+      results = {
+        on_play: matchup_scenario(on_play: true),
+        on_draw: matchup_scenario(on_play: false),
+      }
+      @analysis = results
+    end
+
+    private
+
+    def matchup_scenario(on_play:)
+      a_info = analyze_deck(deck_a, on_play: on_play)
+      b_info = analyze_deck(deck_b, on_play: !on_play)
+
+      win_rate_a = weighted_score(a_info, b_info)
+      win_rate_b = (1.0 - win_rate_a).round(3)
 
-      matchup = {
+      {
         archetype_a: a_info[:archetype],
         archetype_b: b_info[:archetype],
-        likely_winner: predict_matchup(a_info, b_info),
+        win_rate_a: win_rate_a,
+        win_rate_b: win_rate_b,
+        favored: if win_rate_a > win_rate_b
+                   "Deck A"
+                 else
+                   ((win_rate_b > win_rate_a) ? "Deck B" : "Even")
+                 end,
         interaction_overlap: compare_interaction_density(a_info, b_info),
-        notes: generate_notes(a_info, b_info),
+        synergy_a: a_info[:synergy_hit_rate],
+        synergy_b: b_info[:synergy_hit_rate],
+        notes: generate_notes(a_info, b_info, on_play: on_play),
       }
-
-      @analysis = matchup
     end
 
-    private
-
-    def analyze_deck(deck)
+    def analyze_deck(deck, on_play:)
       detector = CwCardUtils::DecklistParser::ArchetypeDetector.new(deck)
       archetype = detector.detect
-
       curve = deck.normalized_curve
 
       early = ((curve[0] || 0) + (curve[1] || 0)).round(2)
-      mid = ((curve[2] || 0) + (curve[3] || 0)).round(2)
-      late = ((curve[4] || 0) + (curve[5] || 0) + (curve[6] || 0) + (curve[7] || 0)).round(2)
+      mid   = ((curve[2] || 0) + (curve[3] || 0)).round(2)
+      late  = ((curve[4] || 0) + (curve[5] || 0) + (curve[6] || 0) + (curve[7] || 0)).round(2)
+
+      synergy_hit_rate = calc_synergy_hit_rate(deck, on_play: on_play)
 
       {
         archetype: archetype,
@@ -46,16 +70,86 @@ module CwCardUtils
         late_curve: late,
         tag_ratios: detector.tag_ratios,
         tag_counts: detector.tag_counts,
+        synergy_hit_rate: synergy_hit_rate,
         tribe: deck.tribe,
         format: deck.format,
       }
     end
 
+    def calc_synergy_hit_rate(deck, on_play:)
+      synergy_pairs = extract_synergy_pairs(deck)
+      return 0 if synergy_pairs.empty?
+
+      synergy_checker = CwCardUtils::SynergyProbability.new(deck, deck_size: deck.main.map(&:count).sum)
+
+      probs = synergy_pairs.map do |pair|
+        synergy_checker.prob_combo(pair, draws_by_turn(5, on_play: on_play))
+      end
+      (probs.sum / probs.size).round(2)
+    end
+
+    def extract_synergy_pairs(deck)
+      synergy_cards = deck.main.select do |card|
+        (card.tags & [:synergistic_finisher, :tribal_synergy, :scaling_threat]).any?
+      end
+      return [] if synergy_cards.size < 2
+      synergy_cards.map(&:name).combination(2).to_a
+    end
+
+    def draws_by_turn(turn, on_play:)
+      on_play ? (7 + (turn - 1)) : (7 + turn)
+    end
+
+    def weighted_score(a, b)
+      # Archetype advantage
+      archetype_score = case predict_matchup(a, b)
+      when "Deck A (Aggro)", "Deck A (Faster curve)", "Deck A (Synergy)" then 1.0
+      when "Deck B (Aggro)", "Deck B (Faster curve)", "Deck B (Synergy)" then 0.0
+      else 0.5
+      end
+
+      # Curve advantage
+      curve_score = if a[:early_curve] > b[:early_curve] + 0.15
+        1.0
+      elsif b[:early_curve] > a[:early_curve] + 0.15
+        0.0
+      else
+        0.5
+      end
+
+      # Synergy advantage
+      synergy_score = if a[:synergy_hit_rate] > b[:synergy_hit_rate] + 0.1
+        1.0
+      elsif b[:synergy_hit_rate] > a[:synergy_hit_rate] + 0.1
+        0.0
+      else
+        0.5
+      end
+
+      # Interaction advantage
+      interaction_score = if a[:tag_ratios][:interaction].to_f > b[:tag_ratios][:interaction].to_f + 0.05
+        1.0
+      elsif b[:tag_ratios][:interaction].to_f > a[:tag_ratios][:interaction].to_f + 0.05
+        0.0
+      else
+        0.5
+      end
+
+      (
+        archetype_score * WEIGHTS[:archetype] +
+        curve_score * WEIGHTS[:curve] +
+        synergy_score * WEIGHTS[:synergy] +
+        interaction_score * WEIGHTS[:interaction]
+      ).round(3)
+    end
+
     def predict_matchup(a, b)
       return "Deck A (Aggro)" if is_aggro?(a) && is_control?(b)
       return "Deck B (Aggro)" if is_aggro?(b) && is_control?(a)
       return "Deck A (Faster curve)" if a[:early_curve] > b[:early_curve] + 0.15
       return "Deck B (Faster curve)" if b[:early_curve] > a[:early_curve] + 0.15
+      return "Deck A (Synergy)" if a[:synergy_hit_rate] > b[:synergy_hit_rate] + 0.1
+      return "Deck B (Synergy)" if b[:synergy_hit_rate] > a[:synergy_hit_rate] + 0.1
       "Even Matchup"
     end
 
@@ -80,8 +174,9 @@ module CwCardUtils
       end
     end
 
-    def generate_notes(a, b)
+    def generate_notes(a, b, on_play:)
       notes = []
+      notes << (on_play ? "Deck A is on the play" : "Deck B is on the play")
 
       if a[:tribe] && b[:tribe]
         notes << "Both decks are tribal: #{a[:tribe].capitalize} vs #{b[:tribe].capitalize}"
@@ -95,14 +190,10 @@ module CwCardUtils
         notes << "Color overlap may result in symmetrical strategies"
       end
 
-      notes << "Deck A has a stronger early game" if a[:early_curve] > b[:early_curve] + 0.2
-      notes << "Deck B has a stronger early game" if b[:early_curve] > a[:early_curve] + 0.2
-
-      notes << "Deck A has more combo elements" if a[:tag_ratios][:combo_piece].to_f > 0.1
-      notes << "Deck B has more combo elements" if b[:tag_ratios][:combo_piece].to_f > 0.1
+      notes << "Deck A synergy hit rate: #{(a[:synergy_hit_rate] * 100).round}%"
+      notes << "Deck B synergy hit rate: #{(b[:synergy_hit_rate] * 100).round}%"
 
       notes
     end
   end
-
 end

data/lib/cw_card_utils/synergy_probability.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  # Calculates probability of drawing specific card combinations for synergy analysis
+  class SynergyProbability
+    def initialize(deck, deck_size: 60)
+      @deck = deck
+      @deck_size = deck_size
+    end
+
+    # Probability of drawing at least one of the target cards
+    def prob_single(target_names, draws)
+      total_copies = count_copies(target_names)
+      1 - hypergeometric(@deck_size - total_copies, draws).to_f / hypergeometric(@deck_size, draws)
+    end
+
+    # Probability of drawing ALL cards in the targets list (synergy pair/trio)
+    def prob_combo(target_names, draws)
+      case target_names.size
+      when 1
+        prob_single(target_names, draws)
+      when 2
+        prob_two_card_combo(target_names, draws)
+      when 3
+        prob_three_card_combo(target_names, draws)
+      else
+        # For >3 cards, fallback to approximation
+        approx_combo(target_names, draws)
+      end
+    end
+
+    private
+
+    # Exact for 2-card combos
+    def prob_two_card_combo(names, draws)
+      copies_a = count_copies([names[0]])
+      copies_b = count_copies([names[1]])
+
+      total = hypergeometric(@deck_size, draws).to_f
+
+      # Probability missing A
+      miss_a = hypergeometric(@deck_size - copies_a, draws) / total
+      # Probability missing B
+      miss_b = hypergeometric(@deck_size - copies_b, draws) / total
+      # Probability missing both
+      miss_both = hypergeometric(@deck_size - (copies_a + copies_b), draws) / total
+
+      # Inclusion–exclusion
+      [1 - (miss_a + miss_b - miss_both), 0].max
+    end
+
+    # Exact for 3-card combos
+    def prob_three_card_combo(names, draws)
+      copies_a = count_copies([names[0]])
+      copies_b = count_copies([names[1]])
+      copies_c = count_copies([names[2]])
+
+      total = hypergeometric(@deck_size, draws).to_f
+
+      miss_a = hypergeometric(@deck_size - copies_a, draws) / total
+      miss_b = hypergeometric(@deck_size - copies_b, draws) / total
+      miss_c = hypergeometric(@deck_size - copies_c, draws) / total
+
+      miss_ab = hypergeometric(@deck_size - (copies_a + copies_b), draws) / total
+      miss_ac = hypergeometric(@deck_size - (copies_a + copies_c), draws) / total
+      miss_bc = hypergeometric(@deck_size - (copies_b + copies_c), draws) / total
+
+      miss_abc = hypergeometric(@deck_size - (copies_a + copies_b + copies_c), draws) / total
+
+      # Inclusion–exclusion for 3 sets
+      [1 - (miss_a + miss_b + miss_c) +
+        (miss_ab + miss_ac + miss_bc) -
+        miss_abc, 0].max
+    end
+
+    # Approximation for >3 cards (same as old method)
+    def approx_combo(target_names, draws)
+      prob_missing = 0.0
+      target_names.each do |name|
+        copies = count_copies([name])
+        miss_prob = hypergeometric(@deck_size - copies, draws).to_f / hypergeometric(@deck_size, draws)
+        prob_missing += miss_prob
+      end
+      [1 - prob_missing, 0].max
+    end
+
+    # Utility: count how many copies of given cards are in the deck
+    def count_copies(names)
+      @deck.main.sum { |card| names.include?(card.name) ? card.count : 0 }
+    end
+
+    # Hypergeometric combination helper
+    def hypergeometric(n, k)
+      return 0 if k > n
+      factorial(n) / (factorial(k) * factorial(n - k))
+    end
+
+    def factorial(n)
+      return 1 if n.zero?
+      (1..n).reduce(1, :*)
+    end
+  end
+end

data/lib/cw_card_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CwCardUtils
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/lib/cw_card_utils.rb

@@ -4,6 +4,7 @@ require_relative "cw_card_utils/version"
 require_relative "cw_card_utils/curve_calculator"
 require_relative "cw_card_utils/decklist_parser"
 require_relative "cw_card_utils/scryfall_cmc_data"
+require_relative "cw_card_utils/synergy_probability"
 require_relative "cw_card_utils/deck_comparator"
 
 module CwCardUtils

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cw_card_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Ryan Stenhouse
@@ -47,6 +47,7 @@ files:
 - lib/cw_card_utils/decklist_parser/deck.rb
 - lib/cw_card_utils/decklist_parser/parser.rb
 - lib/cw_card_utils/scryfall_cmc_data.rb
+- lib/cw_card_utils/synergy_probability.rb
 - lib/cw_card_utils/version.rb
 - sig/cw_card_utils.rbs
 homepage: https://cracklingwit.com