manasimu 0.0.7 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa769c22b5954b3410dec04b773abab6ec9130953b07946ec229528cd38dd7a9
-  data.tar.gz: 0c96dcee60c36629f885e3dbcb0c236c4a699c6bab064a323f7b56968041733f
+  metadata.gz: e1c9780641a85a3afd2f3a9e7387681fb2c44535bed300ac32cf3d0afcc0976b
+  data.tar.gz: 72e18bf8bc9780cfcb765cf13dafee515354728f83c43ccc55e227b97604091f
 SHA512:
-  metadata.gz: 00b241f58208db388327de9e23686f41871a3f446dd99d1100589ddc777debc78c9fd551d0edc9ad220c40060fb7f1620e9986445f461a4df50b4afe32f8f171
-  data.tar.gz: e620e1ec3ed3f2b2d5c963aa1a4fd8712c4016ca028e7e0efc13efb1abd4af1de0a88d4300145040a433656cc12e9867b5963fecf54a7008208e88c655f8a25e
+  metadata.gz: e27d758046b0876d82ef849ceb2422ca19e92cbd4b7fc7b30b53d681f2bd1f2f556bea8f5e296500b03e04b71e621511bb3fcf0c4bf9f05b482824824a381c6c
+  data.tar.gz: c3b225079817f3e77c0fe1014d5077373be5265fa4f04fcec189e89b6338a4953615973657d08b928e47309bb3368e8c83e075012a3fa36d74662a01decfd9d1

data/lib/manasimu/card/pathway.rb

@@ -0,0 +1,25 @@
+class PathwayCard  < Card
+
+  def first_produce_symbol=(symbol)
+    if symbol.to_i.to_s == symbol
+      @side = 'a'
+      @symbol = @card_type.color_identity[0]
+    else
+      @card_type.color_identity.each_with_index do |ci, i|
+        if ci == symbol
+          @side = @card_type.contents[i].side
+          @symbol = ci
+          break
+        end
+      end
+    end
+  end
+
+  def color_identity
+    if @side
+      [@symbol]
+    else
+      @card_type.color_identity
+    end
+  end
+end

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, capas)
+    @card_type.edges(lands, capas)
   end
 
-  def edges(lands)
-    @card_type.edges(lands)
+  def mana_produced?
+    @side
+  end
+
+  def first_produce_symbol=(symbol)
   end
 
   def to_s
@@ -148,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
@@ -174,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
@@ -193,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

data/lib/manasimu/data.rb

@@ -70,7 +70,11 @@ class Deck
       card_type = @@card_types.find(deck_item[:set], deck_item[:setnum])
       clone = CardType.create(card_type, deck_item[:name])
       card_types << clone
-      card = Card.new(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.7
+  version: 0.0.10
 platform: ruby
 authors:
 - so1itaryrove
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-08 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
@@ -20,6 +20,7 @@ files:
 - ext/ford_fulkerson.so
 - lib/manasimu.rb
 - lib/manasimu/card.rb
+- lib/manasimu/card/pathway.rb
 - lib/manasimu/data.rb
 - lib/manasimu/game.rb
 - lib/manasimu/hello.rb