manasimu 0.0.6 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70c28d1658ed8cd6e6f45a92ea6cd50d9b771c5e3bc56d06103da417347facc9
-  data.tar.gz: 9d1bd594f3e33a517538bdd5fb03b67eb642f0d750d4d47755523edefe159384
+  metadata.gz: 7daccf511ec20b2a789c10abd6907f9e6de2ad8ab205006c40d43d159a340730
+  data.tar.gz: a378ba600c389a14c9f631660aa7000c669f2215966843979d9681be4ce38a46
 SHA512:
-  metadata.gz: '09f8f73fa3be2076e8b43879a84173260d7c37dcef702826632b084c396e1d99ddb06441caf0a03ef65629bc9febe7a5e853f1b3afec815971493633f74beca6'
-  data.tar.gz: e505904201ad78e4611518690b386a70692740bc6934caf0d7beab43bc44dd8020a7207b5950e8e440313da999406db3bf13a410d5bdb970909b1652d9d4f2e6
+  metadata.gz: 2ccab49af9746d58f143401856905f42c79a55e449fbdf3d78a00f39ba022adb622b49b2f0d34a6720df33694653f01b912f2638b1b33db6913a627719afd904
+  data.tar.gz: 5423c8b49381c1546c3395a46ef41096f1a00946cd4baa29063f504d0392580412812cd29ec7da700a4abb98b1d7c43cb2f2a5b311fbd92d7a2bd0e9f1814141

data/lib/manasimu/card.rb

@@ -1,5 +1,5 @@
 class Card
-  attr_accessor :id, :card_type
+  attr_accessor :id, :card_type, :side
 
   def initialize(card_type)
     @card_type = card_type
@@ -13,10 +13,12 @@ class Card
     @card_type.drawed(turn)
   end
 
-  def played(turn)
+  def played(turn, side = "a")
     @played = turn
+    @side = side
     @card_type.played(turn)
   end
+
   def played?
     @played.nil?
   end
@@ -29,8 +31,8 @@ class Card
     @card_type.mana_source?
   end
 
-  def playable?(lands)
-    @card_type.playable?(lands)
+  def playable?(lands, capas)
+    @card_type.playable?(lands, capas)
   end
 
   def types
@@ -61,12 +63,23 @@ class Card
     @card_type.price
   end
 
-  def max_flow(lands)
-    @card_type.max_flow(lands)
+  def reset
+    @side = nil
+  end
+
+  def max_flow(lands, capas)
+    @card_type.max_flow(lands, capas)
   end
 
-  def edges(lands)
-    @card_type.edges(lands)
+  def edges(lands, capas)
+    @card_type.edges(lands, capas)
+  end
+
+  def mana_produced?
+    @side
+  end
+
+  def first_produce_symbol=(symbol)
   end
 
   def to_s
@@ -75,7 +88,16 @@ class Card
 end
 
 class CardType
-  attr_accessor :contents
+  attr_accessor :contents, :played, :drawed, :name
+
+  def self.create(card_type, name)
+    ret = card_type.dup
+    ret.contents = card_type.contents
+    ret.played = nil
+    ret.drawed = nil
+    ret.name = name
+    ret
+  end
 
   def initialize(contents)
     return if not contents
@@ -139,18 +161,42 @@ class CardType
     end
   end
 
+  def symbols
+    return @symbols if @symbols
+    @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
+    @symbols
+  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]]
+  def playable?(lands, capas)
+    return [false, [], []] if lands.empty?
+    return [false, [], []] if converted_mana_cost > lands.length
+    mf, used, land_symbols = max_flow(lands, capas)
+    [mf == converted_mana_cost, used.to_a[1..lands.length], land_symbols]
   end
 
-  def max_flow(lands)
+  def max_flow(lands, capas)
     obj = FordFulkersonSingleton.instance.obj
     # Graph has x+y+2 nodes
     # source       : 0
@@ -165,17 +211,29 @@ class CardType
     #
 
     # create edge
-    x, y, e = edges(lands)
+    x, y, e = edges(lands, capas)
     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]
+
+    land_symbols = Array.new(lands.length)
+    for edges in g.G do
+      for edge in edges do
+        if edge.cap == 0 and edge.from.between?(1, x) and edge.to.between?(x+1, x+y)
+          land_index = edge.from - 1
+          spell_index = edge.to - x - 1
+          land_symbols[land_index] = symbols[spell_index] 
+        end
+      end
+    end
+
+    [ret, obj.used, land_symbols]
   end
 
-  def edges(lands)
+  def edges(lands, capas)
     result = []
     x = lands.length
     i_src = 0
@@ -184,29 +242,9 @@ class CardType
       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|
+      next if capas[i].to_i == 0
       land_colors = land.color_identity
       symbols.each_with_index do |symbol, j|
         if symbol == "1" or land_colors.include? symbol
@@ -290,6 +328,7 @@ class Content
   def to_s
     "[#{@name}] [#{@types}] [#{@color_identity}] [#{@mana_cost}]"
   end
+
 end
 
 class FordFulkersonSingleton

data/lib/manasimu/data.rb

@@ -68,8 +68,13 @@ class Deck
     card_types = []
     deck_items.each do |deck_item|
       card_type = @@card_types.find(deck_item[:set], deck_item[:setnum])
-      card_types << card_type
-      card = Card.new(card_type)
+      clone = CardType.create(card_type, deck_item[:name])
+      card_types << clone
+      if clone.name =~ /.*Pathway$/ and clone.mana_source?
+        card = PathwayCard.new(clone)
+      else
+        card = Card.new(clone)
+      end
       deck_item[:amount].to_i.times do 
         card_clone = card.dup
         card_clone.id = card_id

data/lib/manasimu/game.rb

@@ -3,6 +3,7 @@ class Game
 
   def initialize(deck)
     @deck = deck.shuffle(random: Random.new)
+    @deck.each { |card| card.reset }
     @hands = []
     @plays = []
     @planner = Planner.new

data/lib/manasimu/planner.rb

@@ -6,6 +6,8 @@ class Planner
     max_price =  0
     max_spells = nil
     max_land = nil
+    max_symbols = nil
+    max_lands = nil
 
     if not lands_in_hand.empty?
       lands_in_hand.each do |play_land|
@@ -18,23 +20,33 @@ class Planner
         current_fields << play_land
 
         # search_opt_spells
-        price, spells = 
+        price, spells, symbols, lands = 
           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
+          max_symbols = symbols
+          max_lands = lands
         end
       end
     else
       # search_opt_spells
-      max_price, max_spells = search_opt_spells(hands, fields)
+      max_price, max_spells, max_symbols, max_lands = search_opt_spells(hands, fields)
     end
 
     if not max_spells and not lands_in_hand.empty?
       max_land = lands_in_hand[0]
     end
 
+    if max_lands
+      max_lands.each_with_index do |land, i|
+        if not land.mana_produced?
+          land.first_produce_symbol = max_symbols[i]
+        end
+      end
+    end
+
     [max_land, max_spells].select {|a| a}.flatten
   end
 
@@ -60,94 +72,88 @@ class Planner
     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)]
+    cost, bit_spells, bit_lands, land_symbols =
+      dfs(1, spells, lands, bit_spells, bit_lands, price, [])
+    [price, bit_select(spells, bit_spells), land_symbols, lands]
   end
 
-  def dfs(n, spells, lands, bit_spells, bit_lands, price)
+  def dfs(n, spells, lands, bit_spells, bit_lands, price, total_land_symbols)
     index = n - 1
 
     # exit
-    return [price, bit_spells, bit_lands] if n > spells.length
+    return [price, bit_spells, bit_lands, total_land_symbols] 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))
+    used_lands = bit_lands.to_s(2).chars
+    capas = lands.length.times.to_a.map do |i|
+      used_lands[i] == "1" ? "0" : "1"
+    end
+
+    # shrink
+    # lands_available = []
+    # lands.length.times do |i|
+    #   next if used_lands[i] == "1"
+    #   lands_available << lands[i]
+    # end
+    # capas = ("1" * lands_available.length).chars
 
     # cast case
-    is_playable, used_lands = spell.playable?(left_lands)
-    a_price, a_bit_spells, a_bit_lands = 
+    is_playable, casted_lands, land_symbols = 
+      spell.playable?(lands, capas)
+
+    # expand
+    # used_lands_ = []
+    # land_symbols_ = []
+    # j = 0
+    # lands.length.times do |i|
+    #   if used_lands[i] == "1" or not casted_lands
+    #     used_lands_ << "1"
+    #     land_symbols_ << total_land_symbols[i]
+    #   else
+    #     used_lands_ << casted_lands[j]
+    #     land_symbols_ << land_symbols[j]
+    #     j += 1
+    #   end
+    # end if lands
+
+    a_price, a_bit_spells, a_bit_lands, a_land_symbols = 
       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)
+        bit_lands_ = casted_lands
+          .reverse
+          .map {|i| i.to_s}
+          .join('')
+          .to_i(2)
+
+        land_symbols_ = lands.length.times.to_a.map do |i|
+          land_symbols[i] ? land_symbols[i] : total_land_symbols[i]
+        end
+
         # dfs
-        dfs(n + 1 , spells, lands, bit_spells, bit_lands, price + spell.price)
+        dfs(n + 1 , spells, lands, bit_spells, bit_lands_, 
+            price + spell.price, land_symbols_)
       else
-        [nil, nil, nil]
+        [nil, 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)
+    b_price, b_bit_spells, b_bit_lands, b_land_symbols = 
+      dfs(n + 1 , spells, lands, bit_spells, bit_lands, price, total_land_symbols)
 
     if (a_price and a_price >= b_price)
-      [a_price, a_bit_spells, a_bit_lands]
+      [a_price, a_bit_spells, a_bit_lands, a_land_symbols]
     else
-      [b_price, b_bit_spells, b_bit_lands]
+      [b_price, b_bit_spells, b_bit_lands, b_land_symbols]
     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"

data/lib/manasimu.rb

@@ -2,6 +2,7 @@ require 'bundler'
 Bundler.require
 
 require_relative './manasimu/card.rb'
+require_relative './manasimu/card/pathway.rb'
 require_relative './manasimu/planner.rb'
 require_relative './manasimu/game.rb'
 require_relative './manasimu/simulator.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: manasimu
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.9
 platform: ruby
 authors:
 - so1itaryrove
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-06 00:00:00.000000000 Z
+date: 2022-05-11 00:00:00.000000000 Z
 dependencies: []
 description: mtg arrena mana curve simulator
 email: so1itaryrove@gmail.com