manasimu 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f5c5bf36d69150a34c30b6d1bd1304499bb5b7ffe36b6ef37640907803e0926
+  data.tar.gz: 24aad739622210bd7b24cf59d1c7db77c98db3da7cfa2c34f219598aaad6d4d6
+SHA512:
+  metadata.gz: e796dbaf5cec8317086d4e72e6ce3b521996f39bdee0ee3261c97f6f2590ada27c6eb211227f54b49eaa1226244d94707e903a85abaa847f8f4253f1764e5812
+  data.tar.gz: 58f72bbf05f2842e2a70a14b21bdddf87a3ddf59da921c0db460fcb5d7c7720bb15f61102c31f72c94066aecdf128197f51d6db48ef5a709850d6fe2610227df

data/lib/manasimu/card.rb

@@ -0,0 +1,297 @@
+class Card
+  attr_accessor :id, :card_type
+
+  def initialize(card_type)
+    @card_type = card_type
+  end
+
+  def step(turn)
+  end
+
+  def drawed(turn)
+    @drawed = turn
+    @card_type.drawed(turn)
+  end
+
+  def played(turn)
+    @played = turn
+    @card_type.played(turn)
+  end
+  def played?
+    @played.nil?
+  end
+
+  def tapped?
+    false
+  end
+
+  def mana_source?
+    @card_type.mana_source?
+  end
+
+  def playable?(lands)
+    @card_type.playable?(lands)
+  end
+
+  def types
+    @card_type.types
+  end
+
+  def mana
+    @card_type.mana
+  end
+
+  def color_identity
+    @card_type.color_identity
+  end
+
+  def converted_mana_cost
+    @card_type.converted_mana_cost
+  end
+
+  def color_identity_size
+    @card_type.color_identity_size
+  end
+
+  def mana_cost
+    @card_type.mana_cost
+  end
+
+  def price
+    @card_type.price
+  end
+
+  def max_flow(lands)
+    @card_type.max_flow(lands)
+  end
+
+  def edges(lands)
+    @card_type.edges(lands)
+  end
+
+  def to_s
+    @card_type.to_s
+  end
+end
+
+class CardType
+  attr_accessor :contents
+
+  def initialize(contents)
+    return if not contents
+    @contents = contents.map {|c| Content.new(c)}
+  end
+
+  def name
+    @name ||= @contents[0].name
+  end
+
+  def played(turn)
+    @played ||= {}
+    @played[turn] ||= 0
+    @played[turn] += 1
+  end
+
+  def drawed(turn)
+    @drawed ||= {}
+    @drawed[turn] ||= 0
+    @drawed[turn] += 1
+  end
+
+  def mana_source?
+    @mana_source ||= @contents.any? {|content| content.mana_source?}
+  end
+
+  def types
+    @types ||= @contents.map {|c| c.types}
+  end
+
+  def mana
+    @mana ||= @contents.map {|content| content.color_identity }.flatten
+  end
+
+  def color_identity
+    return @memo_colors if @memo_colors
+    @memo_colors ||= []
+    @contents.each do |c|
+      c.color_identity.split(",").each do |color|
+        @memo_colors << color if not @memo_colors.include? color
+      end
+    end
+    @memo_colors
+  end
+
+  def converted_mana_cost
+    @converted_mana_cost ||= @contents.map {|c| c.converted_mana_cost}.min
+  end
+
+  def color_identity_size
+    color_identity.length
+  end
+
+  def mana_cost
+    @mana_cost ||= @contents.select {|c| c.types != "Land"}.first.mana_cost
+  end
+
+  def price
+    converted_mana_cost
+  end
+
+  def playable?(lands)
+    return [false, []] if lands.empty?
+    return [false, []] if converted_mana_cost > lands.length
+    mf, used = max_flow(lands)
+    [mf == converted_mana_cost, used.to_a[1..lands.length]]
+  end
+
+  def max_flow(lands)
+    obj = FordFulkersonSingleton.instance.obj
+    # Graph has x+y+2 nodes
+    # source       : 0
+    # lands        : 1 - x 
+    # mana_cost    : x+1 - x+y+1 
+    # destination  : x+y+2
+    #
+    # image
+    #         - land1  - mana4 
+    # source0 - land2  - mana5 - destination6
+    #         - land3 
+    #
+
+    # create edge
+    x, y, e = edges(lands)
+    g = Graph.new(x + y + 2)
+    e.each do |s, d|
+      g.add_edge(s, d, 1)
+    end
+
+    ret = obj.max_flow(g, 0, x + y + 1)
+    [ret, obj.used]
+  end
+
+  def edges(lands)
+    result = []
+    x = lands.length
+    i_src = 0
+    # source connect to lands
+    x.times do |i|
+      result << [i_src, i + 1]
+    end
+
+    # create symbol
+    symbols = []
+    mana_cost[1..-2].split('}{').each_with_index do |mana, j|
+      spell_colors = mana.split('/')
+      if spell_colors.length == 1 
+        spell_color = spell_colors[0]
+        if spell_color.to_i.to_s == spell_color
+          # numeric symbol
+          spell_color.to_i.times do |k|
+            symbols << "1"
+          end
+        else
+          # color symbol
+          symbols << spell_color
+        end
+      else
+        # multi symbol
+        throw Exception.new('unprogramed exception')
+      end
+    end
+
+    # lands and mana_cost connect to each symbols
+    lands.each_with_index do |land, i|
+      land_colors = land.color_identity
+      symbols.each_with_index do |symbol, j|
+        if symbol == "1" or land_colors.include? symbol
+          result << [i + 1, x + 1 + j]
+        end
+      end
+    end
+
+    y = symbols.length 
+    i_dst = x + y + 1
+
+    # mana_cost connect to destination
+    y.times do |i|
+      result << [x + 1 + i, i_dst]
+    end
+
+    [x, y, result]
+  end
+
+  def count(turn = nil)
+    turn ||= converted_mana_cost
+    played = @played ? @played [turn] : 0
+    drawed = 0
+    if (@drawed)
+      (turn+1).times do |i|
+        next if not @drawed[i]
+        drawed += @drawed[i]
+      end
+    end
+    [played, drawed]
+  end
+
+  def to_s
+    @contents.map {|c| c.to_s}.join(",")
+  end
+end
+
+class CardTypeAggregate
+
+  def find(card_type)
+    @memo ||= []
+    return nil if not card_type
+    singleton = @memo.find do |c|
+      a = c.contents[0]
+      b = card_type.contents[0]
+      a and b and a.name == b.name
+    end
+    if singleton
+      singleton
+    else
+      @memo << card_type
+      card_type
+    end
+  end
+
+  def each
+    return if not @memo
+    @memo.each do |item|
+      yield item
+    end
+  end
+
+end
+
+class Content
+  attr_accessor :name, :number, :side, :set_code, :mana_cost, :types, :color_identity, :converted_mana_cost, :text
+
+  def initialize(hash)
+    @name = hash[:name]
+    @number = hash[:number]
+    @side = hash[:side]
+    @set_code = hash[:set_code]
+    @mana_cost = hash[:mana_cost]
+    @types = hash[:types]
+    @text = hash[:text]
+    @color_identity = hash[:color_identity]
+    @converted_mana_cost = hash[:converted_mana_cost].to_i
+  end
+
+  def mana_source?
+    return @types == "Land"
+  end
+
+  def to_s
+    "[#{@name}] [#{@types}] [#{@color_identity}] [#{@mana_cost}]"
+  end
+end
+
+class FordFulkersonSingleton
+  include Singleton
+  def obj
+    @memo_obj ||= FordFulkerson.new
+  end
+end

data/lib/manasimu/data.rb

@@ -0,0 +1,117 @@
+class Deck
+
+  def self.create(lines)
+    items = Deck.input_to_card_hash(lines)
+    Deck.get_card_details(items)
+  end
+
+  def self.input_to_card_hash(lines)
+    result = []
+    looking_for_deck_line = false
+    for line in lines do
+      trimmed = line.chomp
+      trimmed_lower = trimmed.downcase
+
+      # Ignore reserved words
+      if trimmed_lower == "deck"
+        looking_for_deck_line = false
+        next
+      end
+
+      if trimmed_lower == "commander" 
+        looking_for_deck_line = true
+        next
+      end
+      if trimmed_lower == "companion" 
+        looking_for_deck_line = true
+        next
+      end
+      #Assumes sideboard comes after deck
+      if trimmed_lower == "sideboard"
+        break
+      end
+      if trimmed_lower == "maybeboard"
+        # Assumes maybeboard comes after deck
+        break
+      end
+      # Ignore line comments
+      if trimmed.start_with? ('#')
+        next
+      end
+      if looking_for_deck_line
+        next
+      end
+      # An empty line divides the main board cards from the side board cards
+      if trimmed.empty?
+        break
+      end
+
+      if !(trimmed =~ /\s*(\d+)\s+([^\(#\n\r]+)(?:\s*\((\w+)\)\s+(\d+))?\s*/)
+        next
+      end
+
+      deck_item = {}
+      deck_item[:amount] = $1.strip
+      deck_item[:name] = $2.strip
+      deck_item[:set] = $3.strip
+      deck_item[:setnum] = $4.strip
+      result << deck_item
+    end
+    result
+  end
+
+  def self.get_card_details(deck_items)
+    path = File.expand_path( '../../../db/AllPrintings.sqlite', __FILE__ )
+    db = SQLite3::Database.new(path)
+    sql = <<DOC
+    select distinct 
+      name
+     ,number
+     ,colorIdentity
+     ,side
+     ,setCode
+     ,manaCost
+     ,types 
+     ,text
+     ,convertedManaCost
+    from cards 
+    where 
+      number = ? and
+      setCode = ?
+DOC
+    cards = []
+    card_id = 0
+    card_types = CardTypeAggregate.new
+    deck_items.each do |deck_item|
+      rows = db.execute(sql, deck_item[:setnum], deck_item[:set])
+      if rows.empty?
+        puts deck_item[:name]
+      end
+
+      card_type = card_types.find(
+        CardType.new(rows.map { |row|
+          {
+            name: row[0],
+            number: row[1],
+            color_identity: row[2],
+            side: row[3],
+            set_code: row[4],
+            mana_cost: row[5],
+            types: row[6],
+            text: row[7],
+            converted_mana_cost: row[8]
+          }
+        })
+      )
+      card = Card.new(card_type)
+
+      deck_item[:amount].to_i.times do 
+        card_clone = card.dup
+        card_clone.id = card_id
+        card_id += 1
+        cards << card_clone
+      end
+    end
+    [cards, card_types]
+  end
+end

data/lib/manasimu/game.rb

@@ -0,0 +1,47 @@
+class Game
+  attr_accessor :hands, :plays, :deck
+
+  def initialize(deck)
+    @deck = deck.shuffle(random: Random.new)
+    @hands = []
+    @plays = []
+    @planner = Planner.new
+    7.times { draw(0) }
+  end
+
+  def step(turn)
+    # puts "turn #{turn}"
+    # puts "played"
+    # @plays.each do |card| puts " #{card}" end
+    # puts "hands"
+    # @hands.each do |card| puts " #{card}" end
+
+    upkeep(turn)
+    draw(turn)
+    plan.each do |card| 
+      play(card, turn)
+    end
+  end
+
+  def upkeep(turn)
+    @plays.each { |card| card.step(turn) }
+  end
+
+  def draw(turn)
+    card = @deck.pop
+    # puts "draw #{card}"
+    card.drawed(turn)
+    @hands << card
+  end
+
+  def plan
+    @planner.plan(@hands, @plays)
+  end
+
+  def play(card, turn)
+    # puts "play #{card}"
+    card.played(turn)
+    @plays << card
+    @hands.delete card
+  end
+end

data/lib/manasimu/hello.rb

@@ -0,0 +1,3 @@
+require './ext/hello.so'
+
+Hello.new.say

data/lib/manasimu/mana_type.rb

@@ -0,0 +1,7 @@
+class ManaType
+  class Red end;
+  class Blue end;
+  class Green end;
+  class White end;
+  class Black end;
+end

data/lib/manasimu/planner.rb

@@ -0,0 +1,162 @@
+class Planner
+
+  def plan(hands, fields)
+    lands_in_hand = lands(hands)
+
+    max_price =  0
+    max_spells = nil
+    max_land = nil
+
+    if not lands_in_hand.empty?
+      lands_in_hand.each do |play_land|
+        # dup
+        current_hands = hands.dup
+        current_fields = fields.dup
+
+        # play the land
+        current_hands.delete play_land
+        current_fields << play_land
+
+        # search_opt_spells
+        price, spells = 
+          search_opt_spells(current_hands, current_fields)
+        if price >= max_price and not spells.empty?
+          max_price = price
+          max_spells = spells
+          max_land = play_land
+        end
+      end
+    else
+      # search_opt_spells
+      max_price, max_spells = search_opt_spells(hands, fields)
+    end
+
+    if not max_spells and not lands_in_hand.empty?
+      max_land = lands_in_hand[0]
+    end
+
+    [max_land, max_spells].select {|a| a}.flatten
+  end
+
+  #
+  # on conditional playing land, search most 
+  # high price spells combinations
+  # return price, spells
+  #
+  def search_opt_spells(hands, fields)
+    spells = spells(hands)
+    lands = lands(fields)
+
+    # sort spells desc converted_mana_cost
+    spells.sort! do |a, b|
+      b.converted_mana_cost <=> a.converted_mana_cost
+    end
+
+    lands.sort! do |a, b|
+      b.color_identity_size <=> a.color_identity_size
+    end
+
+    price = 0
+    bit_lands = 0
+    bit_spells = 0
+    # search playable spell comibantion
+    cost, bit_spells, bit_lands =
+      dfs(1, spells, lands, bit_spells, bit_lands, price)
+    [price, bit_select(spells, bit_spells)]
+  end
+
+  def dfs(n, spells, lands, bit_spells, bit_lands, price)
+    index = n - 1
+
+    # exit
+    return [price, bit_spells, bit_lands] if n > spells.length
+
+    spell = spells[index]
+    # ex) lands [a,b,c,d]
+    #     bit_lands is 3 ( = 0011)
+    #     then left_lands to be [c, d]
+    left_lands = bit_select(lands, reverse_bit(bit_lands, lands.length))
+
+    # cast case
+    is_playable, used_lands = spell.playable?(left_lands)
+    a_price, a_bit_spells, a_bit_lands = 
+      if is_playable
+        bit_spells = bit_spells | 1 << ( n - 1 )
+        # ex) lands [a,b,c,d]
+        #      bit_lands 3 ( = 0011)
+        #     used_lands [d]
+        #     then used_lands to be [0,0,0,d]
+        used_lands = fill_used_lands(used_lands, bit_lands, lands)
+        # ex) used_lands [0,0,0,d]
+        #     bit_lands 3 ( = 0011)
+        #     then bit_lands to be 11 ( = 1011)
+        bit_lands = update_bit(used_lands, bit_lands)
+        # dfs
+        dfs(n + 1 , spells, lands, bit_spells, bit_lands, price + spell.price)
+      else
+        [nil, nil, nil]
+      end
+
+    # not cast case
+    b_price, b_bit_spells, b_bit_lands = 
+      dfs(n + 1 , spells, lands, bit_spells, bit_lands, price)
+
+    if (a_price and a_price >= b_price)
+      [a_price, a_bit_spells, a_bit_lands]
+    else
+      [b_price, b_bit_spells, b_bit_lands]
+    end
+  end
+
+  def reverse_bit(bit, length)
+    s = bit.to_s(2)
+    length.times.to_a.map do |i|
+      if s[i] and s[i] == "1"
+        "0"
+      else
+        "1"
+      end
+    end.join.to_i(2)
+  end
+
+  def bit_select(cards, bit)
+    cards.length.times
+          .map { |i| cards[i] if (bit & (1 << i) > 0) }
+          .select { |o| o }
+  end
+
+  def update_bit(used_lands, bit_lands)
+    used_lands.each_with_index do |flg, i|
+      bit_lands = bit_lands | ( 1 << i ) if flg == 1
+    end
+    bit_lands
+  end
+
+  def fill_used_lands(used_lands, bit_lands, lands)
+    result = []
+    j = 0
+    lands.length.times do |i|
+      if (bit_lands & 1 << i) == 1
+        # used before dfs
+        result << 1
+      else
+        # used after dfs
+        result << used_lands[j]
+        j += 1
+      end
+    end
+    result
+  end
+
+  def lands(list)
+    list.select do |card|
+      card.types.include? "Land"
+    end
+  end
+
+  def spells(list)
+    list.select do |card|
+      not card.types.include? "Land"
+    end
+  end
+end

data/lib/manasimu/simulator.rb

@@ -0,0 +1,20 @@
+class Simulator
+
+  def initialize(config)
+    @config = config
+  end
+
+  def run
+    @config.simulations.times do
+      game = Game.new(@config.deck)
+      @config.turns.times do |i|
+        turn = i + 1
+        game.step turn
+      end
+    end 
+  end
+end
+
+class SimulatorConfig
+  attr_accessor :simulations, :turns, :deck
+end

data/lib/manasimu.rb

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler.require
+
+require_relative './manasimu/card.rb'
+require_relative './manasimu/planner.rb'
+require_relative './manasimu/game.rb'
+require_relative './manasimu/simulator.rb'
+require_relative './manasimu/data.rb'
+require_relative '../ext/ford_fulkerson.so'

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: manasimu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- so1itaryrove
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-05-04 00:00:00.000000000 Z
+dependencies: []
+description: mtg arrena mana curve simulator
+email: so1itaryrove@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- db/AllPrintings.sqlite
+- ext/ford_fulkerson.so
+- lib/manasimu.rb
+- lib/manasimu/card.rb
+- lib/manasimu/data.rb
+- lib/manasimu/game.rb
+- lib/manasimu/hello.rb
+- lib/manasimu/mana_type.rb
+- lib/manasimu/planner.rb
+- lib/manasimu/simulator.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: mtg arrena mana curve simulator
+test_files: []