Generate a Magic: The Gathering deck from a Cockatrice card database.

make-mtg-deck

#!/usr/bin/env ruby

require 'optparse'
require 'ostruct'
require 'set'

require 'nokogiri'

CARDS_PATH = '~/Library/Application Support/Cockatrice/Cockatrice/cards.xml'

Database = Struct.new(:sets, :cards) do
  def self.load
    doc = open(File.expand_path(CARDS_PATH)) { |f| Nokogiri::XML(f) }
    sets_doc = doc.at('/cockatrice_carddatabase/sets')
    cards_doc = doc.at('/cockatrice_carddatabase/cards')
    sets = sets_doc.element_children.map { |set_doc| MagicSet.from_doc(set_doc) }
    cards = cards_doc.element_children.flat_map { |card_doc| MagicCard.all_from_doc(card_doc) }
    new(sets, cards)
  end

  def set(id)
    sets.find { |s| s.id == id }
  end

  def pool(set_ids, colors)
    set_ids = set_ids.to_set
    cards.select { |c| !c.basic_land? && set_ids.include?(c.set_id) && (c.colors - colors).empty? }
  end

  def basic_lands(set_ids)
    names_to_colors = {
      'Plains' => 'W',
      'Island' => 'U',
      'Forest' => 'G',
      'Mountain' => 'R',
      'Swamp' => 'B',
    }
    cards.select { |c| c.basic_land? && set_ids.include?(c.set_id) }.group_by { |c| names_to_colors[c.name] }
  end
end

MagicSet = Struct.new(:id, :name, :type, :release_date) do
  def self.from_doc(doc)
    id = doc.at('./name').inner_text
    name = doc.at('./longname').inner_text
    type = doc.at('./settype').inner_text
    release_date = doc.at('./releasedate').inner_text
    new(id, name, type, release_date)
  end
end

MagicCard = Struct.new(:name, :colors, :set_id, :rarity, :type) do
  def self.all_from_doc(doc)
    name = doc.at('./name').inner_text
    colors = doc.search('./color').map(&:inner_text)
    colors = ['X'] if colors.empty?
    type = doc.at('./type').inner_text
    doc.search('./set').map do |set_element|
      set_id = set_element.inner_text
      rarity = set_element['rarity']
      new(name, colors, set_id, rarity, type)
    end
  end

  def basic_land?
    type =~ /\ABasic (?:Snow )?Land — /
  end
end

class App
  def initialize
    @db = Database.load
  end

  attr_reader :db

  def run(args)
    parse_args(args)
    case @command
    when 'list sets'
      list_sets
    when 'debug'
      require 'pry'
      binding.pry
    else
      deck = draw_deck
      deck.group_by(&:name).each do |name, cards|
        puts "#{cards.count} #{name}"
      end
    end
  end

  attr_reader :list_sets, :set_ids, :colors, :num_cards, :land_percent

  def parse_args(args)
    @command = 'draw'
    @set_ids = ['ORI']
    @colors = %w[W G U R B]
    @num_cards = 60
    @land_percent = 40

    OptionParser.new do |parser|
      parser.on '--list-sets', '-L' do
        @command = 'list sets'
      end

      parser.on '--debug', '-D' do
        @command = 'debug'
      end

      parser.on '--sets SETS', '-s' do |value|
        @set_ids = value.split(',')
      end

      parser.on '--colors COLORS', '-c' do |value|
        normalized = value.upcase.scan(/[A-Z]/).join
        bad = normalized.tr('WGURBX', '').empty? or
          abort "invalid colors: #{bad}"
        @colors = normalized.split('')
      end

      parser.on '--num-cards N', '-n' do |value|
        @num_cards = value.to_i
      end

      parser.on '--land-percent PERCENT', '-l' do |value|
        @land_percent = value.to_f
      end
    end.parse!(args)
  end

  def list_sets
    type_symbols = {'Core' => '*', 'Expansion' => ' '}
    db.sets.sort_by(&:release_date).each do |set|
      next if set.id == 'TK'
      next if !type_symbols.key?(set.type)
      puts "#{set.release_date}  #{set.id} #{type_symbols[set.type]} #{set.name}"
    end
  end

  def draw_deck
    cards_by_rarity = db.pool(set_ids, colors).group_by(&:rarity)
    basic_lands = db.basic_lands(set_ids)

    num_lands = (0.01 * land_percent * num_cards).round
    num_nonlands = num_cards - num_lands
    num_rares = (1 * num_nonlands / 12.0).round
    num_uncommons = (3 * num_nonlands / 12.0).round
    num_commons = (8 * num_nonlands / 12.0).round
    num_mythic_rares = num_rares.times.count { cards_by_rarity['Mythic Rare'] && rand < 0.125 }
    num_rares -= num_mythic_rares

    unless @silent
      STDERR.puts '-'*80
      STDERR.puts "Drawing #{num_mythic_rares} mythic rares from pool of #{cards_by_rarity['Mythic Rare'].size}" if cards_by_rarity['Mythic Rare']
      STDERR.puts "Drawing #{num_rares} rares from pool of #{cards_by_rarity['Rare'].size}"
      STDERR.puts "Drawing #{num_uncommons} uncommons from pool of #{cards_by_rarity['Uncommon'].size}"
      STDERR.puts "Drawing #{num_commons} commons from pool of #{cards_by_rarity['Common'].size}"
      STDERR.puts "Drawing #{num_lands} basic lands"
      STDERR.puts '-'*80
    end

    mythic_rares = cards_by_rarity['Mythic Rare'] ? sample(cards_by_rarity['Mythic Rare'], num_mythic_rares) : []
    rares = sample(cards_by_rarity['Rare'], num_rares)
    uncommons = sample(cards_by_rarity['Uncommon'], num_uncommons)
    commons = sample(cards_by_rarity['Common'], num_commons)
    basic_lands = basic_lands_for(mythic_rares + rares + uncommons + commons, num_lands, basic_lands)

    # color_sampler = (mythic_rares + rares + uncommons + commons).reject { |c| c.colors == ['X'] }.map(&:colors)
    # color_sampler = [%W[W G U R B]] if color_sampler.empty?
    # basic_lands = num_lands.times.map { basic_lands[color_sampler.sample.sample].sample }

    mythic_rares + rares + uncommons + commons + basic_lands
  end

  def sample(available, count)
    (count / available.size).times.flat_map { available } +
      available.sample(count)
  end

  def basic_lands_for(cards, num_lands, basic_lands)
    color_weights = Hash.new { |h, k| h[k] = 0 }
    cards.each { |card| card.colors.each { |color| color_weights[color] += 1 } }
    weight_remaining = color_weights.values.inject(0, :+).to_f

    color_weights.flat_map do |color, weight|
      num_lands_for_color = (num_lands * weight / weight_remaining).round
      weight_remaining -= weight
      num_lands -= num_lands_for_color
      num_lands_for_color.times.map { basic_lands[color].sample }
    end
  end
end

App.new.run(ARGV)