cw_card_utils 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8d8eb329c364d67fedf00a49698b9f145f06b6e08f7effae3eb92fb5c22d244
-  data.tar.gz: 8cc571695d9d0b3b07c2da11abffe0a047d08591c8b490fbaffdf88a21226fe5
+  metadata.gz: e301d659cb6e96974ef4b5aa075e3951d8b875b645a3518ec8ae7c77211a0d42
+  data.tar.gz: 638f1bb63aabb8db4d648df1070c156c34c6d9b8c5dc7770b0cde08fa4513f9d
 SHA512:
-  metadata.gz: 38000b90cc9c72b84efdf4c8eb892d20748fe4050af8874c99847a9e4b572b4fcbe573cfba49a964fcda60b8d177bbf9195f3f9b89c9f92c4f08d716d18c41ca
-  data.tar.gz: 9f62737b9b7fde768f4f990b0367b94b6e86d8bcab4a4925e1c91a8c6abfaae71a2ac56bd8ecfe5ffb74ec956010ad3c6d8658e102c032eeb3514e8488e0e79f
+  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)
-      detector = ArchetypeDetector.new(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/decklist_parser/archetype_detector.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    class ArchetypeDetector
+      attr_reader :deck, :format, :tribe, :colors, :tag_counts, :tag_ratios
+
+      def initialize(deck)
+        @deck = deck
+        @format = deck.format.to_s.downcase # :standard, :edh, etc.
+        @tribe = deck.tribe&.capitalize # e.g., "Cat"
+        @colors = resolve_color_identity(deck)
+        @tag_counts = Hash.new(0)
+        @tag_ratios = {}
+        count_tags
+        calculate_ratios
+      end
+
+      def detect
+        archetype = detect_archetype
+        color_label = resolve_color_label(colors)
+        tribe_label = tribe ? " #{tribe} Tribal" : ""
+        archetype_label = " #{archetype.to_s.capitalize}"
+
+
+        [color_label, tribe_label, archetype_label].join.strip.squeeze(" ")
+      end
+
+      private
+
+      # === TAG COUNTING ===
+
+      def count_tags
+        total_tags = 0
+
+        deck.each do |card|
+          next unless card.respond_to?(:tags)
+
+          card.tags.each do |tag|
+            @tag_counts[tag] += card.count
+            total_tags += card.count
+          end
+        end
+
+        @tag_counts[:_total] = total_tags
+      end
+
+      def calculate_ratios
+        total = @tag_counts[:_total].to_f
+        return if total.zero?
+
+        @tag_counts.each do |tag, count|
+          next if tag == :_total
+          @tag_ratios[tag] = count / total
+        end
+      end
+
+      # === CMC UTILITY ===
+
+      def average_cmc
+        @average_cmc ||= begin
+          cmcs = deck.main.map { |card| card.respond_to?(:cmc) ? card.cmc.to_f : nil }.compact
+          return 0 if cmcs.empty? # rubocop:disable Lint/NoReturnInBeginEndBlocks
+          cmcs.sum / cmcs.size
+        end
+      end
+
+      # === FORMAT-AWARE DETECTION ===
+      def detect_archetype
+        if format == "edh"
+          return :combo if tag_ratios[:combo_piece].to_f > 0.10 && tag_ratios[:draw].to_f > 0.08
+
+          control_indicators = tag_counts[:interaction].to_i +
+            tag_counts[:draw].to_i +
+            tag_counts[:tax].to_i +
+            tag_counts[:lock_piece].to_i
+
+          return :control if control_indicators >= 14 && tag_counts[:threat].to_i <= 6
+
+          return :ramp if tag_counts[:ramp] >= 10 && average_cmc >= 4.0
+          return :midrange if tag_counts[:threat] >= 15 && tag_counts[:interaction] >= 6
+
+          return :aggro if tag_ratios[:threat].to_f >= 0.2 ||
+            tag_counts[:synergistic_finisher].to_i >= 3 ||
+            (tag_counts[:scaling_threat].to_i >= 6 && average_cmc <= 3.5) ||
+            (tag_counts[:synergy].to_i >= 6 && average_cmc <= 3.0)
+        else
+          return :combo if tag_ratios[:combo_piece].to_f >= 0.12
+          return :control if tag_ratios[:interaction].to_f >= 0.25 &&
+            tag_ratios[:threat].to_f < 0.2 &&
+            (tag_ratios[:draw].to_f + tag_ratios[:tax].to_f + tag_ratios[:lock_piece].to_f) >= 0.15
+
+          return :aggro if tag_ratios[:threat].to_f >= 0.2 ||
+            tag_counts[:synergistic_finisher].to_i >= 3 ||
+            (tag_counts[:scaling_threat].to_i >= 6 && average_cmc <= 3.5) ||
+            (tag_counts[:synergy].to_i >= 6 && average_cmc <= 3.0)
+
+          return :ramp if tag_ratios[:ramp].to_f >= 0.12 && tag_counts[:finisher] >= 3 && average_cmc >= 4.0
+          return :tempo if tag_ratios[:interaction].to_f >= 0.2 && tag_ratios[:threat].to_f >= 0.2 && average_cmc <= 3.5
+          return :midrange if tag_ratios[:threat].to_f >= 0.2 && tag_ratios[:interaction].to_f >= 0.1
+        end
+
+        :unknown
+      end
+
+      # === COLOR IDENTITY ===
+
+      def resolve_color_identity(deck)
+        deck.main.flat_map { |c| c.respond_to?(:color_identity) ? c.color_identity : [] }.uniq.sort
+      end
+
+      def resolve_color_label(identity)
+        ColorIdentityResolver.resolve(identity)
+      end
+    end
+  end
+end

data/lib/cw_card_utils/decklist_parser/card.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    # A Card is a single card in a deck.
+    class Card
+      def initialize(name, count, cmc_data_source = CwCardUtils::ScryfallCmcData.instance)
+        @name = name
+        @count = count
+        @tags = []
+        @cmc_data_source = cmc_data_source
+      end
+
+      attr_reader :name, :count, :cmc_data_source
+      attr_accessor :tags
+
+      def cmc
+        @cmc ||= @cmc_data_source&.cmc_for_card(@name)
+      end
+
+      def type
+        @type ||= @cmc_data_source&.type_for_card(@name) || "Land"
+      end
+
+      def keywords
+        @keywords ||= @cmc_data_source&.keywords_for_card(@name) || []
+      end
+
+      def oracle_text
+        @oracle_text ||= @cmc_data_source&.oracle_text_for_card(@name)
+      end
+
+      def power
+        @power ||= @cmc_data_source&.power_for_card(@name)
+      end
+
+      def toughness
+        @toughness ||= @cmc_data_source&.toughness_for_card(@name)
+      end
+
+      def color_identity
+        @color_identity ||= @cmc_data_source&.color_identity_for_card(@name) || []
+      end
+
+      def inspect
+        "<Card: #{@name} (#{@count}) #{cmc}>"
+      end
+
+      def to_h
+        { name: @name, count: @count, cmc: cmc, type: type, keywords: keywords, power: power, toughness: toughness, oracle_text: oracle_text }
+      end
+
+      def to_json(*_args)
+        to_h.to_json
+      end
+    end
+
+
+  end
+end

data/lib/cw_card_utils/decklist_parser/card_tagger.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+
+    class CardTagger
+      def initialize(card, deck)
+        @card = card
+        @text = card.oracle_text.to_s.downcase
+        @type_line = card.type.to_s.downcase
+        @cmc = card.cmc || 0
+        @power = begin
+          card.power.to_i
+        rescue StandardError
+          0
+        end
+        @toughness = begin
+          card.toughness.to_i
+        rescue StandardError
+          0
+        end
+        @keywords = card.keywords.map(&:downcase)
+        @deck = deck
+        @tribe = deck.tribe&.to_s&.downcase
+      end
+
+      def tags
+        t = []
+
+        # === Threat ===
+        t << :threat if creature? && @power >= 3
+
+        # === Finisher ===
+        t << :finisher if likely_finisher?
+
+        # === Ramp ===
+        t << :ramp if @text.match?(/add .* mana|search.*basic|put.*land|mana pool/)
+
+        # === Draw ===
+        t << :draw if @text.match?(/draw.*card|investigate|learn/)
+
+        # === Tutor ===
+        t << :tutor if @text.match?(/search.*library/)
+
+        # === Interaction ===
+        t << :interaction if @text.match?(/destroy|exile|counter|fight|return.*to.*hand|sacrifice.*creature|discard/i)
+
+        # === Lock Pieces ===
+        t << :lock_piece if @text.match?(/players can't|creatures can't|skip.*step|can't untap|prevent all combat damage|each player.*sacrifice/i)
+
+        # === Tax Effects ===
+        t << :tax if @text.match?(/whenever an opponent|opponents? .* pay|opponents? .* can't|noncreature spells .* cost|can't cast more than/i)
+
+        # === Combo ===
+        t << :combo_piece if @text.match?(/infinite|copy.*spell|storm|you win the game/i)
+
+        # === ETB Effects ===
+        if @text.match?(/when.*enters.*the battlefield/)
+          t << :etb
+          t << :etb_buff if @text.match?(/creatures.*get.*\+/)
+          t << :etb_token if @text.match?(/create.*token/)
+          t << :etb_removal if @text.match?(/destroy|exile|tap|fight/)
+        end
+
+        # === Evasion / Scaling Threats ===
+        if @keywords.any? { |kw| %w[flying trample menace unblockable].include?(kw) } || @text.match?(/flying|trample|menace|unblockable/)
+          t << :evasive
+        end
+
+        if @text.match?(/gets \+x\/\+x|for each other|creatures you control|other .*#{@tribe}s? you control/i)
+          t << :scaling_threat
+          t << :synergistic_finisher if @cmc <= 4 && t.include?(:evasive)
+        end
+
+        # === Go-Wide Synergy ===
+        if @text.match?(/whenever.*creature.*enters|token.*you control/i)
+          t << :synergy
+        end
+
+        # === Choose-a-type tribal enablers ===
+        if @text.include?("choose a creature type")
+          t << :tribal_synergy
+          t << :tribal_creature
+          if @text.match?(/creatures.*chosen type.*get.*\+.*\+|whenever.*creature.*of the chosen type/i)
+            t << :threat unless t.include?(:threat)
+          end
+        end
+
+        if creature? && @power <= 2 && @tribe &&
+            (@text.include?("whenever") || @text.include?("enters") || @text.include?("lifelink") || @text.include?("vigilance") || @text.include?("+1/+1"))
+          t << :threat
+        end
+
+        # === Static tribal buffs ===
+        if @tribe
+          t << :tribal_creature if creature_subtypes.include?(@tribe)
+          t << :tribal_synergy if @text.include?("#{@tribe}s") || @text.include?("other #{@tribe}")
+
+          if @text.match?(/other .*#{@tribe}s? you control.*\+\d\/\+\d|creature you control of the chosen type.*\+\d\/\+\d/i)
+            t << :tribal_synergy
+            t << :threat unless t.include?(:threat)
+          end
+
+          # Threat based on synergy
+          if @tribe && @text.match?(/creatures.*you control.*#{@tribe}|gets \+1\/\+1 for each.*#{@tribe}/)
+            t << :scaling_threat
+            t << :threat unless t.include?(:threat)
+          end
+        end
+        if t.include?(:scaling_threat) && !t.include?(:threat) # rubocop:disable Style/InverseMethods
+          t << :threat
+        end
+
+        t.uniq.sort
+      end
+
+      private
+
+      def creature?
+        @type_line.include?("creature")
+      end
+
+      def planeswalker?
+        @type_line.include?("planeswalker")
+      end
+
+      def creature_subtypes
+        return [] unless creature?
+        raw = @type_line.split(/[—-]/).last.to_s.strip
+        raw.split.map(&:downcase)
+      end
+
+      def likely_finisher?
+        return true if @cmc >= 6 && @text.match?(/flying|trample|indestructible|each opponent|you win|extra turn|double/i)
+        return true if planeswalker? && @text.match?(/creatures.*get.*flying|you get an emblem|each opponent/i)
+        false
+      end
+    end
+
+  end
+end

data/lib/cw_card_utils/decklist_parser/color_identity_resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    class ColorIdentityResolver
+      COLOR_NAMES = {
+        %w[W] => "White",
+        %w[U] => "Blue",
+        %w[B] => "Black",
+        %w[R] => "Red",
+        %w[G] => "Green",
+
+        %w[U W] => "Azorius",
+        %w[B U] => "Dimir",
+        %w[B R] => "Rakdos",
+        %w[G R] => "Gruul",
+        %w[G W] => "Selesnya",
+        %w[B W] => "Orzhov",
+        %w[R U] => "Izzet",
+        %w[B G] => "Golgari",
+        %w[R W] => "Boros",
+        %w[G U] => "Simic",
+
+        %w[B U W] => "Esper",
+        %w[B R U] => "Grixis",
+        %w[B G R] => "Jund",
+        %w[G R W] => "Naya",
+        %w[G U W] => "Bant",
+        %w[B R W] => "Mardu",
+        %w[G R U] => "Temur",
+        %w[B G W] => "Abzan",
+        %w[R U W] => "Jeskai",
+        %w[B G U] => "Sultai",
+
+        %w[B R U W] => "Glint",
+        %w[B G R U] => "Dune",
+        %w[B G R W] => "Ink",
+        %w[G R U W] => "Witch",
+        %w[B G U W] => "Yore",
+
+        %w[B G R U W] => "Five-Color",
+        [] => "Colorless",
+      }.freeze
+
+      def self.resolve(identity)
+        key = identity.sort
+        COLOR_NAMES[key] || key.join("/")
+      end
+    end
+  end
+end