cw_card_utils 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 211b10611a7f848b2de2e4500875a0ccdc2eda0f4ece2f1fdd8e69d9b43eae8f
-  data.tar.gz: be91019d5a649e3f78bd973e9247c3a814d2c5a6bdf0362226330a0b311dcc26
+  metadata.gz: a8d8eb329c364d67fedf00a49698b9f145f06b6e08f7effae3eb92fb5c22d244
+  data.tar.gz: 8cc571695d9d0b3b07c2da11abffe0a047d08591c8b490fbaffdf88a21226fe5
 SHA512:
-  metadata.gz: 8d068f85095b12b305e55f75a5192e3eca23b23b6edd17535214d3294c3fdbe8824d31d706b16a7c5aff3aaf49b6177cd1d631fa7f115f5aea01e340b956a6e3
-  data.tar.gz: ad007fc86fbef1a975224268321d918df6dbcedda7fb79f32a0731806a09e68e9dfeaf3ac5bc42f7ae5e51ef54e20985ae79d86f6d0f9a3e4d04be8407fb3cc2
+  metadata.gz: 38000b90cc9c72b84efdf4c8eb892d20748fe4050af8874c99847a9e4b572b4fcbe573cfba49a964fcda60b8d177bbf9195f3f9b89c9f92c4f08d716d18c41ca
+  data.tar.gz: 9f62737b9b7fde768f4f990b0367b94b6e86d8bcab4a4925e1c91a8c6abfaae71a2ac56bd8ecfe5ffb74ec956010ad3c6d8658e102c032eeb3514e8488e0e79f

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 = 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.rb

@@ -25,37 +25,34 @@ module CwCardUtils
     def tags
       t = []
 
-      # Threat: beefy enough to demand an answer
+      # === Threat ===
       t << :threat if creature? && @power >= 3
 
-      # Finishers: expensive and game-ending
+      # === Finisher ===
       t << :finisher if likely_finisher?
 
-      # Ramp
+      # === Ramp ===
       t << :ramp if @text.match?(/add .* mana|search.*basic|put.*land|mana pool/)
 
-      # Draw / value
+      # === Draw ===
       t << :draw if @text.match?(/draw.*card|investigate|learn/)
 
-      # Tutors
+      # === Tutor ===
       t << :tutor if @text.match?(/search.*library/)
 
-      # Interaction
-      if @text.match?(/destroy|exile|counter|fight|return.*to.*hand|sacrifice.*creature|discard/i)
-        t << :interaction
-      end
+      # === Interaction ===
+      t << :interaction if @text.match?(/destroy|exile|counter|fight|return.*to.*hand|sacrifice.*creature|discard/i)
 
-      # Lock / taxes
-      if @text.match?(/players can'?t|opponents can'?t|skip.*step|each player.*sacrifice|tax/i)
-        t << :lock_piece
-      end
+      # === 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)
 
-      # Combo
-      if @text.match?(/infinite|copy.*spell|storm|you win the game/i)
-        t << :combo_piece
-      end
+      # === Tax Effects ===
+      t << :tax if @text.match?(/whenever an opponent|opponents? .* pay|opponents? .* can't|noncreature spells .* cost|can't cast more than/i)
 
-      # ETB
+      # === 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.*\+/)
@@ -63,50 +60,57 @@ module CwCardUtils
         t << :etb_removal if @text.match?(/destroy|exile|tap|fight/)
       end
 
-      # Evasion / scaling
+      # === Evasion / Scaling Threats ===
       if @keywords.any? { |kw| %w[flying trample menace unblockable].include?(kw) } || @text.match?(/flying|trample|menace|unblockable/)
         t << :evasive
       end
 
-      # Synergistic finishers
-      if @text.match?(/gets \+x\/\+x|for each other|creatures you control/i)
+      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 engine
+      # === 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 creature_subtypes.include?("vehicle")
-
+        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
 
-      # Tribal
+      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
-        if creature_subtypes.include?(@tribe)
-          t << :tribal_creature
-        end
+        t << :tribal_creature if creature_subtypes.include?(@tribe)
+        t << :tribal_synergy if @text.include?("#{@tribe}s") || @text.include?("other #{@tribe}")
 
-        # Tribal synergy via text (buffs, token creation, etc.)
-        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
 
-        # Static buffs to tribe = also a threat
-        if @text.match?(/other .*#{@tribe}s? you control.*\+\d\/\+\d|creature you control of the chosen type.*\+\d\/\+\d|/i)
-          t << :tribal_synergy
+        # 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
 
-      t.uniq
+      if t.include?(:scaling_threat) && !t.include?(:threat) # rubocop:disable Style/InverseMethods
+        t << :threat
+      end
+
+      t.uniq.sort
     end
 
     private
@@ -121,7 +125,7 @@ module CwCardUtils
 
     def creature_subtypes
       return [] unless creature?
-      raw = @type_line.split(/[—-]/).last.to_s.strip # handles both em dash and hyphen
+      raw = @type_line.split(/[—-]/).last.to_s.strip
       raw.split.map(&:downcase)
     end
 
@@ -132,6 +136,118 @@ module CwCardUtils
     end
   end
 
+  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
+
   class ColorIdentityResolver
     COLOR_NAMES = {
       %w[W] => "White",
@@ -182,6 +298,10 @@ module CwCardUtils
   class DecklistParser
     attr_reader :deck
 
+    IGNORED_TRIBAL_TYPES = %w[
+      human wizard soldier scout shaman warrior cleric rogue advisor knight druid
+    ].freeze
+
     def initialize(desklist, cmc_data_source = ScryfallCmcData.new)
       @decklist = desklist.is_a?(IO) ? desklist.read : desklist
       @deck = Deck.new(cmc_data_source)
@@ -288,8 +408,6 @@ module CwCardUtils
         @x_to_cast = []
 
         @cmc_data_source = cmc_data_source
-
-        @curve_calculator = CurveCalculator.new(self)
       end
 
       def to_h
@@ -327,24 +445,28 @@ module CwCardUtils
         end
       end
 
+      def archetype
+        @archetype ||= ArchetypeDetector.new(self).detect
+      end
+
       def inspect
         "<Deck: main: #{mainboard_size} sideboard: #{sideboard_size} lands: #{lands_count} x_to_cast: #{x_to_cast_count} cards: #{cards_count}>"
       end
 
       def collapsed_curve
-        @curve_calculator.collapsed_curve
+        @collapsed_curve ||= CurveCalculator.new(self).collapsed_curve
       end
 
       def curve
-        @curve_calculator.curve
+        @curve ||=CurveCalculator.new(self).curve
       end
 
       def normalized_curve
-        @curve_calculator.normalized_curve
+        @normalized_curve ||=CurveCalculator.new(self).normalized_curve
       end
 
       def collapsed_normalized_curve
-        @curve_calculator.collapsed_normalized_curve
+        @collapsed_normalized_curve ||=CurveCalculator.new(self).collapsed_normalized_curve
       end
 
       def empty?
@@ -387,6 +509,20 @@ module CwCardUtils
         @cards_count = nil
       end
 
+      def format
+        @format ||= detect_format_for_deck
+      end
+
+      def detect_format_for_deck
+        if mainboard_size >= 100
+          :commander
+        elsif mainboard_size >= 60
+          :standard
+        else
+          :modern
+        end
+      end
+
       def mainboard_size
         @mainboard_size ||= main.sum { |card| card.count }
       end
@@ -428,21 +564,29 @@ module CwCardUtils
           next unless card.type&.include?("Creature")
 
           total_creatures += 1
-          subtypes = card.type.split("—").last.to_s.strip.split
+          subtypes = card.type.split(/[—-]/).last.to_s.strip.split
           subtypes.each do |type|
-            subtype_counts[type] += 1
+            subtype_counts[type.downcase] += 1
           end
         end
 
-        return nil if total_creatures.zero?
+        return nil if total_creatures < 6 || subtype_counts.empty?
 
         most_common = subtype_counts.max_by { |_, count| count }
-        if most_common && most_common[1] > (total_creatures / 2.0)
-          most_common[0].downcase.to_sym
-        else
-          nil
+        return nil if most_common.nil?
+
+        dominant_type = most_common[0]
+        count = most_common[1]
+
+        # Suppress only if it's a boring type *and* barely dominant
+        if IGNORED_TRIBAL_TYPES.include?(dominant_type) && count.to_f / total_creatures < 0.7
+          return nil
         end
+
+        return dominant_type.to_sym if count.to_f / total_creatures >= 0.4
+        nil
       end
+
     end
   end
 end

data/lib/cw_card_utils/scryfall_cmc_data.rb

@@ -5,9 +5,9 @@ require "json"
 module CwCardUtils
   # Represents a card with Scryfall data
   class ScryfallCard
-    def initialize(name)
+    def initialize(name, data_source = ScryfallCmcData.new)
       @name = name
-      @data = ScryfallCmcData.new.find_card(@name) || {}
+      @data = data_source.find_card(@name) || {}
     end
 
     def cmc
@@ -43,6 +43,7 @@ module CwCardUtils
   class ScryfallCmcData
     def initialize
       @data = JSON.parse(File.read(File.expand_path("../../data/scryfall.cards.cmc.json", __dir__)))
+      @found_cards = {}
     end
 
     def find_card(name)
@@ -52,43 +53,50 @@ module CwCardUtils
     end
 
     def cmc_for_card(name)
-      @data.find { |card| card["name"] == name }["cmc"]
+      @found_cards[name] ||= find_card(name)
+      @found_cards[name]["cmc"]
     rescue StandardError
       nil
     end
 
     def color_identity_for_card(name)
-      @data.find { |card| card["name"] == name }["color_identity"]
+      @found_cards[name] ||= find_card(name)
+      @found_cards[name]["color_identity"]
     rescue StandardError
       nil
     end
 
     def keywords_for_card(name)
-      @data.find { |card| card["name"] == name }["keywords"]
+      @found_cards[name] ||= find_card(name)
+      @found_cards[name]["keywords"]
     rescue StandardError
       nil
     end
 
     def toughness_for_card(name)
-      @data.find { |card| card["name"] == name }["toughness"]
+      @found_cards[name] ||= find_card(name)
+      @found_cards[name]["toughness"]
     rescue StandardError
       nil
     end
 
     def power_for_card(name)
-      @data.find { |card| card["name"] == name }["power"]
+      @found_cards[name] ||= find_card(name)
+      @found_cards[name]["power"]
     rescue StandardError
       nil
     end
 
     def oracle_text_for_card(name)
-      @data.find { |card| card["name"] == name }["oracle_text"]
+      @found_cards[name] ||= find_card(name)
+      @found_cards[name]["oracle_text"]
     rescue StandardError
       nil
     end
 
     def type_for_card(name)
-      type = @data.find { |card| card["name"] == name }["type_line"]
+      @found_cards[name] ||= find_card(name)
+      type = @found_cards[name]["type_line"]
       if type.include?("Land")
         type = nil
       end

data/lib/cw_card_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CwCardUtils
-  VERSION = "0.1.2"
+  VERSION = "0.1.6"
 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/deck_comparator"
 
 module CwCardUtils
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cw_card_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.6
 platform: ruby
 authors:
 - Ryan Stenhouse
@@ -38,6 +38,7 @@ files:
 - data/scryfall.cards.cmc.json
 - lib/cw_card_utils.rb
 - lib/cw_card_utils/curve_calculator.rb
+- lib/cw_card_utils/deck_comparator.rb
 - lib/cw_card_utils/decklist_parser.rb
 - lib/cw_card_utils/scryfall_cmc_data.rb
 - lib/cw_card_utils/version.rb