mgmg 1.5.2 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 708daf16885a7532d26106458fbcabf1e043bfbbc0d6c8607af45a2e5b31ca45
-  data.tar.gz: 765e3c12305233d28ea32c8c13ea819bfe52849a393cc5dc64d3c4e54fbe3b70
+  metadata.gz: dcdae95e0d1ee5dc8d65fe012d739a896b5be27e2a68ff5a2619477461e2e9d7
+  data.tar.gz: 2a2976e6c36a2cd2c3c6bc7c6e829f7e78e2791d18bc087188b369db7ecacb17
 SHA512:
-  metadata.gz: d673f9054fe9a1c9ec2d771a699046eb457ddfbc08306355d2a64b988fd00b841e29edc8da7b9c00305423a255ca322a559eb7e8931463ef4ce6ebec63679ce8
-  data.tar.gz: 1b2374ffa189136a4b4036424a77660eef55401be88e06a00f9f6034354ae7ecfdf24eeb2b889c1f0df3049fb3978e63bb5ddb355acf4d165023feb9186446bb
+  metadata.gz: d40a50cc4cde3a115d7d9f27a93945a27f4b77ece5091917d30cf32675679f6ae52290163168cd5d8c3cf57ded10f29bbb3a6fc803e67d209c35cf8c949f3912
+  data.tar.gz: 27f15eef233a9f19a92bca31d4b4683e78fb1207768fd7b8cbc7cc2aab8d6d79c23ac3db93237a0e8b508dfaa4f50da745f001de50ce74bf5d34824ee3909dc6

data/CHANGELOG.md

@@ -141,3 +141,18 @@
 
 ## 1.5.2 2022/06/28
 - `String#poly`が`:magic2`に対応していなかったバグを修正．
+
+## 1.5.3 2022/06/28
+- `Recipe#option`がキーワード引数を受け取れなかったバグを修正．
+
+## 1.5.4 2022/06/30
+- 既製品の探索を制御する`:include_system_equips`オプションを追加．
+	- 既製品を含まないレシピを計算するとき，これを偽に設定することで，高速化される．
+	- デフォルト値は`true`．ただし，既製品を含まないレシピ文字列を`to_recipe`すると，自動的に`false`に書き換える．
+- 一部のメソッドで計算結果をキャッシュすることで，同じ材料装備を含む大量のレシピを計算する場合に高速化された．
+	- `Mgmg.#clear_cache`ですべてのキャッシュをクリアできる．
+- 一部のオプションのデフォルト値をグローバルに変更するための定数ハッシュ`Mgmg::Option::Defaults`を追加．
+
+## 1.5.5 2022/07/02
+- `Enumerable#to_recipe`が動かなくなったバグを修正．
+- `String#min_level`において，正しい答えを返さなくなったバグを修正．

data/lib/mgmg/cuisine.rb

@@ -22,6 +22,55 @@ module Mgmg
 			"料理[攻撃:#{self.attack}, 物防:#{self.phydef}, 魔防:#{self.magdef}]"
 		end
 		alias :inspect :to_s
+		
+		MainFood = {
+			'獣肉'         => Vec[10,  0,  0],
+			'ウッチ'       => Vec[ 0, 10, 10],
+			'ゴッチ'       => Vec[ 0, 12, 12],
+			'ガガッチ'     => Vec[ 0, 14, 14],
+			'ドランギョ'   => Vec[15, 15, 10],
+			'ドラバーン'   => Vec[20, 20, 15],
+			'フレドラン'   => Vec[50,  0,  0],
+			'アースドラン' => Vec[ 0, 50,  0],
+			'アクアドラン' => Vec[ 0,  0, 50],
+			'ダークドン'   => Vec[30, 30, 30],
+		}
+		SubFood = {
+			'氷酒'     => Vec[ 50,  70,  50],
+			'氷水酒'   => Vec[ 50,  90,  50],
+			'氷河酒'   => Vec[ 50, 110,  50],
+			'カエン酒' => Vec[ 70,  50,  70],
+			'爆炎酒'   => Vec[ 90,  50,  90],
+			'煉獄酒'   => Vec[110,  50, 110],
+		}
+		Cookery = {
+			'焼き' => Vec[50, 50, 30],
+			'蒸す' => Vec[30, 75, 75],
+		}
+		Cookery.store('丸焼き', Cookery['焼き'])
+		Cookery.store('すき焼き', Cookery['焼き'])
+		Cookery.store('焼く', Cookery['焼き'])
+		Cookery.store('焼', Cookery['焼き'])
+		Cookery.store('蒸し焼き', Cookery['蒸す'])
+		Cookery.store('ボイル', Cookery['蒸す'])
+		Cookery.store('蒸し', Cookery['蒸す'])
+		Cookery.store('蒸', Cookery['蒸す'])
+		
+		class << self
+			def cook(cookery_s, main_s, sub_s, level)
+				begin
+					c = Cookery[cookery_s]
+					m = MainFood[main_s]
+					s = SubFood[sub_s]
+					v = Vec[1, 1, 1]
+					v.e_mul!(m).e_mul!(c).e_mul!(s.dup.add!(100+level)).e_div!(10000)
+					new(v)
+				rescue
+					arg = [cookery_s, main_s, sub_s, level].inspect
+					raise ArgumentError, "Some of arguments for cooking seems to be wrong. #{arg} is given, but they should be [cookery (String), main food (String), sub food (String), cooking level (Integer)]. Not all of cookeries and foods are supported."
+				end
+			end
+		end
 	end
 	
 	SystemCuisine = {
@@ -72,55 +121,6 @@ module Mgmg
 		end
 	end
 	
-	MainFood = {
-		'獣肉'         => Vec[10,  0,  0],
-		'ウッチ'       => Vec[ 0, 10, 10],
-		'ゴッチ'       => Vec[ 0, 12, 12],
-		'ガガッチ'     => Vec[ 0, 14, 14],
-		'ドランギョ'   => Vec[15, 15, 10],
-		'ドラバーン'   => Vec[20, 20, 15],
-		'フレドラン'   => Vec[50,  0,  0],
-		'アースドラン' => Vec[ 0, 50,  0],
-		'アクアドラン' => Vec[ 0,  0, 50],
-		'ダークドン'   => Vec[30, 30, 30],
-	}
-	SubFood = {
-		'氷酒'     => Vec[ 50,  70,  50],
-		'氷水酒'   => Vec[ 50,  90,  50],
-		'氷河酒'   => Vec[ 50, 110,  50],
-		'カエン酒' => Vec[ 70,  50,  70],
-		'爆炎酒'   => Vec[ 90,  50,  90],
-		'煉獄酒'   => Vec[110,  50, 110],
-	}
-	Cookery = {
-		'焼き' => Vec[50, 50, 30],
-		'蒸す' => Vec[30, 75, 75],
-	}
-	Cookery.store('丸焼き', Cookery['焼き'])
-	Cookery.store('すき焼き', Cookery['焼き'])
-	Cookery.store('焼く', Cookery['焼き'])
-	Cookery.store('焼', Cookery['焼き'])
-	Cookery.store('蒸し焼き', Cookery['蒸す'])
-	Cookery.store('ボイル', Cookery['蒸す'])
-	Cookery.store('蒸し', Cookery['蒸す'])
-	Cookery.store('蒸', Cookery['蒸す'])
-	
-	class << Cuisine
-		def cook(cookery_s, main_s, sub_s, level)
-			begin
-				c = Cookery[cookery_s]
-				m = MainFood[main_s]
-				s = SubFood[sub_s]
-				v = Vec[1, 1, 1]
-				v.e_mul!(m).e_mul!(c).e_mul!(s.dup.add!(100+level)).e_div!(10000)
-				new(v)
-			rescue
-				arg = [cookery_s, main_s, sub_s, level].inspect
-				raise ArgumentError, "Some of arguments for cooking seems to be wrong. #{arg} is given, but they should be [cookery (String), main food (String), sub food (String), cooking level (Integer)]. Not all of cookeries and foods are supported."
-			end
-		end
-	end
-	
 	module_function def cuisine(*arg)
 		case arg.size
 		when 3

data/lib/mgmg/equip.rb

@@ -1,6 +1,8 @@
 module Mgmg
+	CacheMLS = Hash.new
 	using Refiner
 	class Equip
+		Cache, CacheML = Hash.new, Hash.new
 		ParamList = %w|攻撃 物防 魔防 HP MP 腕力 器用 素早 魔力|
 		ElementList = %w|火 地 水|
 		EqPosList = %w|武 頭 胴 腕 足 飾|
@@ -196,195 +198,204 @@ module Mgmg
 		Zero = self.new(28, 0, Vec.new(6, 0).freeze, 12, 12, Vec.new(9, 0).freeze, Vec.new(3, 0).freeze)
 		Zero.total_cost.freeze; Zero.history.clear.freeze
 		Zero.freeze
-	end
-	
-	class << Equip
-		def build(str, s_level, c_level, left_associative: true)
-			str = Mgmg.check_string(str)
-			stack, str = build_sub0([], str)
-			build_sub(stack, str, s_level, c_level, left_associative)
-		end
-		private def build_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << v
-					str = str.gsub(k, "<#{stack.length-1}>")
-				end
+		
+		class << self
+			def build(str, s_level, c_level, left_associative: true, include_system_equips: true)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = build_sub0(stack, str) if include_system_equips
+				build_sub(stack, str, s_level, c_level, left_associative)
 			end
-			[stack, str]
-		end
-		private def build_sub(stack, str, s_level, c_level, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << build_sub(stack, m[2], s_level, c_level, lassoc)
-				build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", s_level, c_level, lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				if c_level < 0
-					compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), 0, true)
-				else
-					compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), c_level, false)
+			private def build_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << v
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
 				end
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				stack[m[1].to_i]
-			else
-				if s_level < 0
-					smith(str, 0, true)
+				[stack, str]
+			end
+			private def build_sub(stack, str, s_level, c_level, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << build_sub(stack, m[2], s_level, c_level, lassoc)
+					build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", s_level, c_level, lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					if c_level < 0
+						compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), 0, true)
+					else
+						compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), c_level, false)
+					end
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					stack[m[1].to_i]
 				else
-					smith(str, s_level, false)
+					if s_level < 0
+						smith(str, 0, true)
+					else
+						smith(str, s_level, false)
+					end
 				end
 			end
-		end
-		
-		def compose(main, sub, level, outsourcing)
-			main_k, sub_k = main.kind, sub.kind
-			main_s, sub_s = main.star, sub.star
-			main_main, sub_main = main.main, sub.main
-			main_sub, sub_sub = main.sub, sub.sub
-			para = Vec.new(9, 0)
-			ele = Vec.new(3, 0)
-			
-			# 9パラメータ
-			coef = Equip9[main_k].dup
-			para[] = coef
-			para.add!(level).e_div!(2)
-			para.e_mul!(sub.para).e_div!(100)
-			coef.sub!(Equip9[sub_k])
-			coef.add!( 100 + (main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) )
-			coef.add!(Material9[main_main]).sub!(Material9[sub_main])
-			coef.e_mul!(EquipFilter[main_k])
-			para.e_mul!(coef).e_div!( main_k==sub_k ? 200 : 100 )
-			para.add!(main.para)
 			
-			# エレメント
-			ele[] = sub.element
-			ele.e_mul!([75, level].min).e_div!( main_k==sub_k ? 200 : 100 )
-			ele.add!(main.element)
-			
-			ret = new(main_k, main.weight+sub.weight, main_s+sub_s, main_sub, sub_main, para, ele)
-			ret.total_cost.add!(main.total_cost).add!(sub.total_cost)
-			cc = ret.comp_cost(outsourcing)
-			ret.total_cost[1] += cc
-			ret.total_cost[main_k < 8 ? 0 : 2] += cc
-			ret.min_levels.merge!(main.min_levels, sub.min_levels)
-			ret.history = [*main.history, *sub.history, ret]
-			ret
-		end
-		
-		def smith(str, level, outsourcing)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
-			end
-			kind = EquipIndex[m[1].to_sym]
-			unless kind
-				raise InvalidEquipClassError.new(m[1])
+			def compose(main, sub, level, outsourcing)
+				main_k, sub_k = main.kind, sub.kind
+				main_s, sub_s = main.star, sub.star
+				main_main, sub_main = main.main, sub.main
+				main_sub, sub_sub = main.sub, sub.sub
+				para = Vec.new(9, 0)
+				ele = Vec.new(3, 0)
+				
+				# 9パラメータ
+				coef = Equip9[main_k].dup
+				para[] = coef
+				para.add!(level).e_div!(2)
+				para.e_mul!(sub.para).e_div!(100)
+				coef.sub!(Equip9[sub_k])
+				coef.add!( 100 + (main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) )
+				coef.add!(Material9[main_main]).sub!(Material9[sub_main])
+				coef.e_mul!(EquipFilter[main_k])
+				para.e_mul!(coef).e_div!( main_k==sub_k ? 200 : 100 )
+				para.add!(main.para)
+				
+				# エレメント
+				ele[] = sub.element
+				ele.e_mul!([75, level].min).e_div!( main_k==sub_k ? 200 : 100 )
+				ele.add!(main.element)
+				
+				ret = new(main_k, main.weight+sub.weight, main_s+sub_s, main_sub, sub_main, para, ele)
+				ret.total_cost.add!(main.total_cost).add!(sub.total_cost)
+				cc = ret.comp_cost(outsourcing)
+				ret.total_cost[1] += cc
+				ret.total_cost[main_k < 8 ? 0 : 2] += cc
+				ret.min_levels.merge!(main.min_levels, sub.min_levels)
+				ret.history = [*main.history, *sub.history, ret]
+				ret
 			end
-			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
-			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
-			para = Vec.new(9, 0)
-			ele = Vec.new(3, 0)
 			
-			# 9パラメータ
-			para[] = Equip9[kind]
-			para.e_mul!(Main9[main_m]).e_div!(100)
-			coef = Sub9[sub_m].dup
-			coef.add!(level)
-			para.e_mul!(coef).e_div!( main_mc==sub_mc ? 200 : 100 )
-			
-			# エレメント
-			ele[] = MainEL[main_m]
-			ele.e_mul!(SubEL[sub_m]).e_div!(6)
-			
-			# 重量
-			weight = ( ( EquipWeight[kind] + SubWeight[sub_m] - level.div(2) ) * ( MainWeight[main_m] ) ).div(10000)
-			
-			ret = new(kind, ( weight<1 ? 1 : weight ), (main_s+sub_s).div(2), main_mc, sub_mc, para, ele)
-			ret.total_cost[kind < 8 ? 0 : 2] += ret.smith_cost(outsourcing)
-			ret.min_levels.store(str, Equip.min_level(str))
-			ret
-		end
-		
-		def min_level(str, weight=1)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
+			def smith(str, level, outsourcing)
+				str = Mgmg.check_string(str)
+				return Cache[str].dup if level==0 && Cache.has_key?(str)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
+				end
+				kind = EquipIndex[m[1].to_sym]
+				unless kind
+					raise InvalidEquipClassError.new(m[1])
+				end
+				main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+				sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
+				para = Vec.new(9, 0)
+				ele = Vec.new(3, 0)
+				
+				# 9パラメータ
+				para[] = Equip9[kind]
+				para.e_mul!(Main9[main_m]).e_div!(100)
+				coef = Sub9[sub_m].dup
+				coef.add!(level)
+				para.e_mul!(coef).e_div!( main_mc==sub_mc ? 200 : 100 )
+				
+				# エレメント
+				ele[] = MainEL[main_m]
+				ele.e_mul!(SubEL[sub_m]).e_div!(6)
+				
+				# 重量
+				weight = ( ( EquipWeight[kind] + SubWeight[sub_m] - level.div(2) ) * ( MainWeight[main_m] ) ).div(10000)
+				
+				ret = new(kind, ( weight<1 ? 1 : weight ), (main_s+sub_s).div(2), main_mc, sub_mc, para, ele)
+				ret.total_cost[kind < 8 ? 0 : 2] += ret.smith_cost(outsourcing)
+				ret.min_levels.store(str, Equip.min_level(str))
+				Cache.store(str, ret.freeze) if level==0
+				ret.dup
 			end
-			kind = EquipIndex[m[1].to_sym]
-			main_m, main_s, = Mgmg.parse_material(m[2])
-			sub_m, sub_s, = Mgmg.parse_material(m[3])
 			
-			q, r = ((weight+1)*10000).divmod(MainWeight[main_m])
-			l = ( EquipWeight[kind] + SubWeight[sub_m] - q + ( r==0 ? 1 : 0 ) )*2
-			[(main_s-1)*3, (sub_s-1)*3, l].max
-		end
-		
-		def min_comp(str, opt: Option.new)
-			str = Mgmg.check_string(str)
-			stack, str = minc_sub0([], str)
-			(minc_sub(stack, str, opt.left_associative)[1]-1)*3
-		end
-		private def minc_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << v.star
-					str = str.gsub(k, "<#{stack.length-1}>")
+			def min_level(str, weight=1)
+				str = Mgmg.check_string(str)
+				key = [str.dup.freeze, weight].freeze
+				return CacheML[key] if CacheML.has_key?(key)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
 				end
+				kind = EquipIndex[m[1].to_sym]
+				main_m, main_s, = Mgmg.parse_material(m[2])
+				sub_m, sub_s, = Mgmg.parse_material(m[3])
+				
+				q, r = ((weight+1)*10000).divmod(MainWeight[main_m])
+				l = ( EquipWeight[kind] + SubWeight[sub_m] - q + ( r==0 ? 1 : 0 ) )*2
+				ret = [(main_s-1)*3, (sub_s-1)*3, l].max
+				CacheML.store(key, ret)
+				ret
 			end
-			[stack, str]
-		end
-		private def minc_sub(stack, str, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << minc_sub(stack, m[2], lassoc)[0]
-				minc_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				a, _ = minc_sub(stack, m[1], lassoc)
-				b, _ = minc_sub(stack, m[2], lassoc)
-				[a+b, [a, b].max]
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				[stack[m[1].to_i], 1]
-			else
-				[smith(str, 0, true).star, 1]
+			
+			def min_comp(str, opt: Option.new)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = minc_sub0(stack, str) if opt.include_system_equips
+				(minc_sub(stack, str, opt.left_associative)[1]-1)*3
 			end
-		end
-		
-		def min_smith(str, opt: Option.new)
-			str = Mgmg.check_string(str)
-			stack, str = mins_sub0([], str)
-			ret = (([mins_sub(stack, str, opt.left_associative)]+stack).max-1)*3
-			ret < 0 ? -1 : ret
-		end
-		private def mins_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << 0
-					str = str.gsub(k, "<#{stack.length-1}>")
+			private def minc_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << v.star
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
 				end
+				[stack, str]
 			end
-			[stack, str]
-		end
-		private def mins_sub(stack, str, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << mins_sub(stack, m[2], lassoc)
-				mins_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				[mins_sub(stack, m[1], lassoc), mins_sub(stack, m[2], lassoc)].max
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				0
-			else
-				mins_sub2(str)
+			private def minc_sub(stack, str, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << minc_sub(stack, m[2], lassoc)[0]
+					minc_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					a, _ = minc_sub(stack, m[1], lassoc)
+					b, _ = minc_sub(stack, m[2], lassoc)
+					[a+b, [a, b].max]
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					[stack[m[1].to_i], 1]
+				else
+					[smith(str, 0, true).star, 1]
+				end
 			end
-		end
-		private def mins_sub2(str)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
+			
+			def min_smith(str, opt: Option.new)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = mins_sub0(stack, str) if opt.include_system_equips
+				ret = (([mins_sub(stack, str, opt.left_associative)]+stack).max-1)*3
+				ret < 0 ? -1 : ret
 			end
-			kind = EquipIndex[m[1].to_sym]
-			unless kind
-				raise InvalidEquipClassError.new(m[1])
+			private def mins_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << 0
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
+				end
+				[stack, str]
+			end
+			private def mins_sub(stack, str, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << mins_sub(stack, m[2], lassoc)
+					mins_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					[mins_sub(stack, m[1], lassoc), mins_sub(stack, m[2], lassoc)].max
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					0
+				else
+					mins_sub2(str)
+				end
+			end
+			private def mins_sub2(str)
+				str = Mgmg.check_string(str)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
+				end
+				kind = EquipIndex[m[1].to_sym]
+				unless kind
+					raise InvalidEquipClassError.new(m[1])
+				end
+				main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+				sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
+				[main_s, sub_s].max
 			end
-			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
-			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
-			[main_s, sub_s].max
 		end
 	end
 end