cw_card_utils 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6190122b537e6cb162c5a2bc4005b960ce0182955e958817d4c92375b7cceb4
-  data.tar.gz: '08a0e11c0648db7ff053f6941d9bf0001ee6f88657136ada38b013343cd4cf16'
+  metadata.gz: 542ae86bcb4458bd4fd9a53552089133dad00a4f716e5cf5bc73de11a52da217
+  data.tar.gz: 835722e23e181a4f4eeb945a18ca5ebb523825d097c42aa8533ed86cb278a042
 SHA512:
-  metadata.gz: e1fe28a4668d7df9915b717a77ede85cc8d97494640f80b2838ebc42c527c181c365df59f8d65f434a6394e164b95d45c1884eeaba98e28f4fe44fbf8b16e37f
-  data.tar.gz: 62cfd74b58393017358a6d3242c521c38a2d988d1d4c9a7230e9e5e60ef2379f8e9836cc0721deef065339562f3394f0cbc9f23a274c4bb48e39a4d9570c9753
+  metadata.gz: 9ff3819a39ee37ee199013b2cb32c5f08f16e139a2d9138ee39d833123f7b40de7fcd4ab20238cd49ef683faca8319166d96cb10df252e88edae953965ae66d4
+  data.tar.gz: e867a1dbe6cda9971d7d28e976c610a250d0799b730fe1f107330e2fe6f81cad29021716893bd1b51fa6b5f45b900392b39c04236785ba93a66c0821825e1b8c

data/lib/cw_card_utils/deck_comparator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+
+  class DeckComparator
+    attr_reader :deck_a, :deck_b, :analysis
+
+    def initialize(deck_a, deck_b)
+      @deck_a = deck_a
+      @deck_b = deck_b
+      @analysis = {}
+    end
+
+    def compare
+      a_info = analyze_deck(deck_a)
+      b_info = analyze_deck(deck_b)
+
+      matchup = {
+        archetype_a: a_info[:archetype],
+        archetype_b: b_info[:archetype],
+        likely_winner: predict_matchup(a_info, b_info),
+        interaction_overlap: compare_interaction_density(a_info, b_info),
+        notes: generate_notes(a_info, b_info),
+      }
+
+      @analysis = matchup
+    end
+
+    private
+
+    def analyze_deck(deck)
+      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)
+
+      {
+        archetype: archetype,
+        color: detector.colors,
+        early_curve: early,
+        mid_curve: mid,
+        late_curve: late,
+        tag_ratios: detector.tag_ratios,
+        tag_counts: detector.tag_counts,
+        tribe: deck.tribe,
+        format: deck.format,
+      }
+    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
+      "Even Matchup"
+    end
+
+    def is_aggro?(info)
+      info[:archetype].downcase.include?("aggro") || info[:early_curve] > 0.5
+    end
+
+    def is_control?(info)
+      info[:archetype].downcase.include?("control") || info[:late_curve] > 0.4
+    end
+
+    def compare_interaction_density(a, b)
+      a_interact = a[:tag_ratios][:interaction].to_f.round(2)
+      b_interact = b[:tag_ratios][:interaction].to_f.round(2)
+
+      if (a_interact - b_interact).abs < 0.05
+        "Similar density"
+      elsif a_interact > b_interact
+        "Deck A has more removal"
+      else
+        "Deck B has more removal"
+      end
+    end
+
+    def generate_notes(a, b)
+      notes = []
+
+      if a[:tribe] && b[:tribe]
+        notes << "Both decks are tribal: #{a[:tribe].capitalize} vs #{b[:tribe].capitalize}"
+      end
+
+      if a[:format] != b[:format]
+        notes << "Decks are from different formats: #{a[:format]} vs #{b[:format]}"
+      end
+
+      if a[:color] == b[:color]
+        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
+    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