mgmg 1.3.2 → 1.4.2

data/lib/mgmg/equip.rb

@@ -9,7 +9,7 @@ module Mgmg
 			@total_cost = Vec[0, 0, 0]
 			@history, @min_levels = [self], Hash.new
 		end
-		attr_accessor :kind, :weight, :star, :main, :sub, :para, :element, :total_cost, :history, :min_levels
+		attr_accessor :kind, :weight, :star, :main, :sub, :para, :element, :total_cost, :history
 		def initialize_copy(other)
 			@kind = other.kind
 			@weight = other.weight
@@ -52,10 +52,19 @@ module Mgmg
 			end
 		end
 		
-		def min_level
+		def min_levels(w=1)
+			if w == 1
+				@min_levels
+			else
+				@min_levels.map do |key, value|
+					[key, key.min_level(w)]
+				end.to_h
+			end
+		end
+		def min_level(w=1)
 			if @kind == 28
 				ret = [0, 0]
-				@min_levels.each do |str, ml|
+				min_levels(w).each do |str, ml|
 					if str.build(-1).kind < 8
 						if ret[0] < ml
 							ret[0] = ml
@@ -68,7 +77,7 @@ module Mgmg
 				end
 				ret
 			else
-				@min_levels.values.append(0).max
+				min_levels(w).values.append(0).max
 			end
 		end
 		
@@ -83,13 +92,16 @@ module Mgmg
 			attack()+str()
 		end
 		def atk_sd
-			attack()*2+str()+dex()
+			attack()+str().quo(2)+dex().quo(2)
 		end
 		def dex_as
-			attack()+str()+dex()*2
+			attack().quo(2)+str().quo(2)+dex()
 		end
 		def mag_das
-			magic()*4+dex_as()
+			magic()+dex_as().quo(2)
+		end
+		def magic2
+			magic()*2
 		end
 		[:fire, :earth, :water].each.with_index do |s, i|
 			define_method(s){ @element[i] }
@@ -98,35 +110,34 @@ module Mgmg
 		def power
 			case @kind
 			when 0, 1
-				atk_sd()*2
+				atk_sd()
 			when 2, 3
-				atkstr()*4
+				atkstr()
 			when 4
-				[dex_as()*2, mag_das()].max
+				[dex_as(), mag_das()].max
 			when 5
-				dex_as()*2
+				dex_as()
 			when 6, 7
-				[magic()*8, atkstr()*4].max
+				[magic()*2, atkstr()].max
 			when 28
-				(@para.sum*4)-((hp()+mp())*3)
+				@para.sum-((hp()+mp())*3.quo(4))
 			else
 				ret = @para.max
 				if ret == magdef()
-					ret*2+magic()
+					ret+magic().quo(2)
 				else
-					ret*2
+					ret
 				end
 			end
 		end
 		def magmag
-			magdef()*2+magic()
+			magdef()+magic().quo(2)
 		end
 		def fpower
-			if @kind < 8 || @kind == 28
-				power().fdiv(4)
-			else
-				power().fdiv(2)
-			end
+			power().to_f
+		end
+		def pmdef
+			[phydef(), magmag()].min
 		end
 		
 		def smith_cost(outsourcing=false)
@@ -146,9 +157,9 @@ module Mgmg
 		end
 		def comp_cost(outsourcing=false)
 			if outsourcing
-				[(@star**2)*5+@para.sum+hp().cdiv(4)-hp()+mp().cdiv(4)-mp(), 0].max
+				[(@star**2)*5+@para.sum+hp().cdiv(4)-hp()+mp().cdiv(4)-mp(), 0].max.div(2)
 			else
-				[((@star**2)*5+@para.sum+hp().cdiv(4)-hp()+mp().cdiv(4)-mp()).div(2), 0].max
+				[((@star**2)*5+@para.sum+hp().cdiv(4)-hp()+mp().cdiv(4)-mp()).div(2), 0].max.div(2)
 			end
 		end
 		alias :cost :comp_cost
@@ -171,8 +182,7 @@ module Mgmg
 				end
 			end
 			@weight += other.weight
-			@main = 12
-			@sub = 12
+			@main, @sub = 12, 12
 			@para.add!(other.para)
 			@element.add!(other.element)
 			@total_cost.add!(other.total_cost)
@@ -257,7 +267,9 @@ module Mgmg
 			
 			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)
-			ret.total_cost[1] += ret.comp_cost(outsourcing)
+			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
@@ -272,8 +284,8 @@ module Mgmg
 			unless kind
 				raise InvalidEquipClassError.new(m[1])
 			end
-			main_m, main_s, main_mc = parse_material(m[2])
-			sub_m, sub_s, sub_mc = parse_material(m[3])
+			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)
 			
@@ -292,11 +304,7 @@ module Mgmg
 			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)
-			if kind < 8
-				ret.total_cost[0] = ret.smith_cost(outsourcing)
-			else
-				ret.total_cost[2] = ret.smith_cost(outsourcing)
-			end
+			ret.total_cost[kind < 8 ? 0 : 2] += ret.smith_cost(outsourcing)
 			ret.min_levels.store(str, str.min_level)
 			ret
 		end
@@ -307,23 +315,14 @@ module Mgmg
 				raise InvalidSmithError.new(str)
 			end
 			kind = EquipIndex[m[1].to_sym]
-			main_m, main_s, = parse_material(m[2])
-			sub_m, sub_s, = parse_material(m[3])
+			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
 		
-		private def parse_material(str)
-			m = /\A.+?(\d+)\Z/.match(str)
-			mat = MaterialIndex[str.to_sym]
-			if m.nil? || mat.nil?
-				raise InvalidMaterialError.new(str)
-			end
-			[mat, m[1].to_i, mat<90 ? mat.div(10): 9]
-		end
-		
 		def min_comp(str, left_associative: true)
 			str = Mgmg.check_string(str)
 			stack, str = minc_sub0([], str)
@@ -388,8 +387,8 @@ module Mgmg
 			unless kind
 				raise InvalidEquipClassError.new(m[1])
 			end
-			main_m, main_s, main_mc = parse_material(m[2])
-			sub_m, sub_s, sub_mc = parse_material(m[3])
+			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

data/lib/mgmg/ir.rb

@@ -0,0 +1,407 @@
+module Mgmg
+	using Refiner
+	class IR
+		class Const
+			def initialize(value)
+				@value = value
+			end
+			attr_accessor :value
+			def initialize_copy(other)
+				@value = other.value
+			end
+			def evaluate(s, c)
+				@value
+			end
+			def evaluate3(s, a, c)
+				@value
+			end
+			def to_s
+				@value.to_s
+			end
+		end
+		class Smith
+			def initialize(sub9, coef, den, sa=nil)
+				@sub9, @coef, @den, @sa = sub9, coef, den, sa
+			end
+			attr_accessor :sub9, :coef, :den, :sa
+			def initialize_copy(other)
+				@sub9, @coef, @den, @sa = other.sub9, other.coef, other.den, other.sa
+			end
+			def evaluate(s, c)
+				((s+@sub9)*@coef).div(@den)
+			end
+			def evaluate3(s, a, c)
+				if sa==:a
+					((a+@sub9)*@coef).div(@den)
+				else
+					((s+@sub9)*@coef).div(@den)
+				end
+			end
+			def to_s
+				if sa==:a
+					"[#{@coef}(a+#{@sub9})/#{den}]"
+				else
+					"[#{@coef}(s+#{@sub9})/#{den}]"
+				end
+			end
+		end
+		class Compose
+			def initialize(main, sub, equip9, coef, den)
+				@main, @sub, @equip9, @coef, @den = main, sub, equip9, coef, den
+			end
+			attr_accessor :main, :sub, :equip9, :coef, :den
+			def initialize_copy(other)
+				@main, @sub = other.main.dup, other.sub.dup
+				@equip9, @coef, @den = other.equip9, other.coef, other.den
+			end
+			def evaluate(s, c)
+				@main.evaluate(s, c) + ( ( @sub.evaluate(s, c) * (c+@equip9).div(2) ).cdiv(100) * @coef ).cdiv(@den)
+			end
+			def evaluate3(s, a, c)
+				@main.evaluate3(s, a, c) + ( ( @sub.evaluate3(s, a, c) * (c+@equip9).div(2) ).cdiv(100) * @coef ).cdiv(@den)
+			end
+			def to_s
+				ms, ss = @main.to_s, @sub.to_s
+				if ss == '0'
+					ms
+				else
+					if ms == '0'
+						"[[#{ss}[(c+#{@equip9})/2]/100]/#{@den}]"
+					else
+						"#{ms}+[[#{ss}[(c+#{@equip9})/2]/100]/#{@den}]"
+					end
+				end
+			end
+		end
+		class Multi
+			def initialize(body)
+				@body = body
+			end
+			attr_accessor :body
+			def initialize_copy(other)
+				@body = other.body.dup
+			end
+			def evaluate(s, c)
+				@body.sum do |e|
+					e.evaluate(s, c)
+				end
+			end
+			def evaluate3(s, a, c)
+				@body.sum do |e|
+					e.evaluate3(s, a, c)
+				end
+			end
+			def to_s
+				@body.map(&:to_s).join('+')
+			end
+		end
+		class << Multi
+			def sum(a, b)
+				unconsts, const = [], Const.new(0)
+				case a
+				when Multi
+					if a.body[0].kind_of?(Const)
+						const.value += a.body[0].value
+						unconsts = a.body[1..(-1)]
+					else
+						unconsts = a.body.dup
+					end
+				when Const
+					const.value += a.value
+				else
+					unconsts << a
+				end
+				case b
+				when Multi
+					if b.body[0].kind_of?(Const)
+						const.value += b.body[0].value
+						unconsts.concat(b.body[1..(-1)])
+					else
+						unconsts.concat(b.body)
+					end
+				when Const
+					const.value += b.value
+				else
+					unconsts << b
+				end
+				body = ( const.value == 0 ? unconsts : [const, *unconsts] )
+				case body.size
+				when 0
+					const
+				when 1
+					body[0]
+				else
+					new(body)
+				end
+			end
+		end
+		def initialize(kind, star, main_m, sub_m, para, rein=[])
+			@kind, @star, @main, @sub, @para = kind, star, main_m, sub_m, para
+			add_reinforcement(rein)
+		end
+		def add_reinforcement(rein)
+			@rein = if rein.kind_of?(Array)
+				rein.map do |r|
+					Reinforcement.compile(r)
+				end
+			else
+				[Reinforcement.compile(rein)]
+			end
+			self
+		end
+		attr_accessor :kind, :star, :main, :sub, :para, :rein
+		def initialize_copy(other)
+			@kind = other.kind
+			@star = other.star
+			@main = other.main
+			@sub = other.sub
+			@para = other.para.dup
+			@rein = other.rein.dup
+		end
+		
+		def compose(other)
+			self.class.compose(self, other)
+		end
+		
+		def to_s
+			par = @para.map.with_index{|e, i| e.to_s=='0' ? nil : "#{Mgmg::Equip::ParamList[i]}:#{e.to_s}"}.compact
+			if @kind == 28
+				ep = @star.map.with_index{|e, i| e==0 ? nil : "#{Mgmg::Equip::EqPosList[i]}:#{e}"}.compact
+				"複数装備(#{ep.join(', ')})<#{par.join(', ')}>#{@rein.empty? ? '' : '{'+@rein.join(',')+'}'}"
+			else
+				"#{EquipName[@kind]}☆#{@star}(#{MaterialClass[@main]}#{MaterialClass[@sub]})<#{par.join(', ')}>#{@rein.empty? ? '' : '{'+@rein.join(',')+'}'}"
+			end
+		end
+		
+		def para_call(para, s, ac, x=nil)
+			if x.nil?
+				method(para).call(s, ac)
+			else
+				method(para).call(s, ac, x)
+			end
+		end
+		
+		%i|attack phydef magdef hp mp str dex speed magic|.each.with_index do |sym, i|
+			define_method(sym) do |s=nil, ac=s, x=nil|
+				ret = if s.nil?
+					@para[i]
+				elsif x.nil?
+					@para[i].evaluate(s, ac)
+				else
+					@para[i].evaluate3(s, ac, x)
+				end
+				@rein.each do |r|
+					if r.vec[i] != 0
+						ret *= (100+r.vec[i]).quo(100)
+					end
+				end
+				ret
+			end
+		end
+		def atkstr(s, ac, x=nil)
+			attack(s, ac, x)+str(s, ac, x)
+		end
+		def atk_sd(s, ac, x=nil)
+			attack(s, ac, x)+str(s, ac, x).quo(2)+dex(s, ac, x).quo(2)
+		end
+		def dex_as(s, ac, x=nil)
+			attack(s, ac, x).quo(2)+str(s, ac, x).quo(2)+dex(s, ac, x)
+		end
+		def mag_das(s, ac, x=nil)
+			magic(s, ac, x)+dex_as(s, ac, x).quo(2)
+		end
+		def magic2(s, ac, x=nil)
+			magic(s, ac, x)*2
+		end
+		def magmag(s, ac, x=nil)
+			magdef(s, ac, x)+magic(s, ac, x).quo(2)
+		end
+		def pmdef(s, ac, x=nil)
+			[phydef(s, ac, x), magmag(s, ac, x)].min
+		end
+		
+		def power(s, a=s, c=a.tap{a=s})
+			case @kind
+			when 0, 1
+				atk_sd(s, c)
+			when 2, 3
+				atkstr(s, c)
+			when 4
+				[dex_as(s, c), mag_das(s, c)].max
+			when 5
+				dex_as(s, c)
+			when 6, 7
+				[magic(s, c)*2, atkstr(s, c)].max
+			when 28
+				@para.enum_for(:sum).with_index do |e, i|
+					x = e.evaluate3(s, a, c)
+					@rein.each do |r|
+						if r.vec[i] != 0
+							x *= (100+r.vec[i]).quo(100)
+						end
+					end
+					x
+				end-((hp(s, a, c)+mp(s, a, c))*3.quo(4))
+			else
+				ret = @para.map.with_index do |e, i|
+					x = e.evaluate3(s, a, c)
+					@rein.each do |r|
+						if r.vec[i] != 0
+							x *= (100+r.vec[i]).quo(100)
+						end
+					end
+					x
+				end.max
+				if ret == magdef(s, a, c)
+					ret+magic(s, a, c).quo(2)
+				else
+					ret
+				end
+			end
+		end
+		def fpower(s, a=s, c=a.tap{a=s})
+			power(s, a, c).to_f
+		end
+		
+		def smith_cost(s, c=s, outsourcing=false)
+			if outsourcing
+				if @kind < 8
+					(@star**2)*2+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)
+				else
+					(@star**2)+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)
+				end
+			else
+				if @kind < 8
+					((@star**2)*2+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)).div(2)
+				else
+					((@star**2)+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)).div(2)
+				end
+			end
+		end
+		def comp_cost(s, c=s, outsourcing=false)
+			if outsourcing
+				[(@star**2)*5+@para.sum{|e| e.evaluate(s, c)}+hp().cdiv(4)-hp()+mp().cdiv(4)-mp(), 0].max.div(2)
+			else
+				[((@star**2)*5+@para.sum{|e| e.evaluate(s, c)}+hp().cdiv(4)-hp()+mp().cdiv(4)-mp()).div(2), 0].max.div(2)
+			end
+		end
+		alias :cost :comp_cost
+		
+		def add!(other)
+			if @kind == 28
+				if other.kind == 28
+					@star.add!(other.star)
+				else
+					@star[EquipPosition[other.kind]] += 1
+				end
+			else
+				@star = Vec.new(6, 0)
+				@star[EquipPosition[@kind]] = 1
+				@kind = 28
+				if other.kind == 28
+					@star.add!(other.star)
+				else
+					@star[EquipPosition[other.kind]] += 1
+				end
+			end
+			@main, @sub = 12, 12
+			@para = Array.new(9) do |i|
+				Multi.sum(self.para[i], other.para[i])
+			end
+			self
+		end
+		def +(other)
+			self.dup.add!(other)
+		end
+		def coerce(other)
+			if other == 0
+				zero = self.class.new(28, Vec.new(6, 0), 12, 12, Array.new(9){Const.new(0)})
+				[zero, self]
+			else
+				raise TypeError, "Mgmg::IR can't be coerced into other than 0"
+			end
+		end
+	end
+	class << IR
+		def build(str, left_associative: true, reinforcement: [])
+			str = Mgmg.check_string(str)
+			stack, str = build_sub0([], str)
+			build_sub(stack, str, left_associative).add_reinforcement(reinforcement)
+		end
+		private def build_sub0(stack, str)
+			SystemEquip.each do |k, v|
+				if Regexp.compile(k).match(str)
+					stack << from_equip(v)
+					str = str.gsub(k, "<#{stack.length-1}>")
+				end
+			end
+			[stack, str]
+		end
+		private def build_sub(stack, str, lassoc)
+			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+				stack << build_sub(stack, m[2], lassoc)
+				build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
+			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+				compose(build_sub(stack, m[1], lassoc), build_sub(stack, m[2], lassoc))
+			elsif m = /\A\<(\d+)\>\Z/.match(str)
+				stack[m[1].to_i]
+			else
+				smith(str)
+			end
+		end
+		
+		def compose(main, sub)
+			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
+			
+			coef = Equip9[main_k].dup
+			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])
+			den = ( main_k==sub_k ? 200 : 100 )
+			para = Array.new(9) do |i|
+				if EquipFilter[main_k][i] == 0
+					main.para[i]
+				else
+					Mgmg::IR::Compose.new(main.para[i], sub.para[i], Equip9[main_k][i], coef[i], den)
+				end
+			end
+			
+			new(main_k, main_s+sub_s, main_sub, sub_main, para)
+		end
+		def smith(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])
+			sa = ( Mgmg::EquipPosition[kind] == 0 ? :s : :a )
+			
+			coef = Equip9[kind].dup
+			coef.e_mul!(Main9[main_m]).e_div!(100)
+			den = ( main_mc==sub_mc ? 200 : 100 )
+			para = Array.new(9) do |i|
+				if coef[i] == 0
+					Mgmg::IR::Const.new(0)
+				else
+					Mgmg::IR::Smith.new(Sub9[sub_m][i], coef[i], den, sa)
+				end
+			end
+			
+			new(kind, (main_s+sub_s).div(2), main_mc, sub_mc, para)
+		end
+		def from_equip(equip)
+			para = equip.para.map do |value|
+				Mgmg::IR::Const.new(value)
+			end
+			new(equip.kind, equip.star, equip.main, equip.sub, para)
+		end
+	end
+end

data/lib/mgmg/poly.rb

@@ -276,6 +276,15 @@ module Mgmg
 			end
 			true
 		end
+		def <=>(other)
+			if self == other
+				0
+			elsif self < other
+				-1
+			else
+				1
+			end
+		end
 	end
 	class << TPolynomial
 		ParamIndex = Hash.new
@@ -292,8 +301,8 @@ module Mgmg
 				raise ArgumentError.new("given string `#{str}' is unparsable as a smithing recipe")
 			end
 			kind = EquipIndex[m[1].to_sym]
-			main_m, main_s, main_mc = Equip.__send__(:parse_material, m[2])
-			sub_m, sub_s, sub_mc = Equip.__send__(:parse_material, m[3])
+			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
 			para = ParamIndex[para]
 			
 			c = ( Equip9[kind][para] * Main9[main_m][para] ).cdiv(100).quo( main_mc==sub_mc ? 200 : 100 )

data/lib/mgmg/reinforce.rb

@@ -0,0 +1,70 @@
+module Mgmg
+	class Reinforcement
+		def initialize(vec)
+			@vec = vec
+		end
+		attr_accessor :vec
+		def initialize_copy(other)
+			@vec = other.vec.dup
+		end
+		
+		def to_s
+			'(' + @vec.map.with_index{|e, i| e==0 ? nil : "#{Equip::ParamList[i]}:#{e}"}.compact.join(', ') + ')'
+		end
+		alias :inspect :to_s
+	end
+	
+	#                                               攻  物  防  HP  MP  腕  器  速  魔
+	Skill = {
+		'物防御UP'       => Reinforcement.new( Vec[  0, 10,  0,  0,  0,  0,  0,  0,  0] ),
+		'魔防御UP'       => Reinforcement.new( Vec[  0,  0, 10,  0,  0,  0,  0,  0,  0] ),
+		'腕力UP'         => Reinforcement.new( Vec[  0,  0,  0,  0,  0, 10,  0,  0,  0] ),
+		'メンテナンス'   => Reinforcement.new( Vec[ 50,  0,  0,  0,  0,  0,  0,  0,  0] ),
+		'ガードアップ'   => Reinforcement.new( Vec[  0, 50,  0,  0,  0,  0,  0,  0,  0] ),
+		'パワーアップ'   => Reinforcement.new( Vec[  0,  0,  0,  0,  0, 50,  0,  0,  0] ),
+		'デックスアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0, 50,  0,  0] ),
+		'スピードアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0,  0, 50,  0] ),
+		'マジックアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0,  0,  0, 50] ),
+		'オールアップ'   => Reinforcement.new( Vec[  0, 50,  0,  0,  0, 50, 50, 50, 50] ),
+	}
+	
+	class << Reinforcement
+		def cuisine(c)
+			Reinforcement.new( Vec[*(c.vec), *Array.new(6, 0)] )
+		end
+		def compile(arg)
+			case arg
+			when Reinforcement
+				arg
+			when Cuisine
+				cuisine(arg)
+			when String
+				if Skill.has_key?(arg)
+					Skill[arg]
+				elsif SystemCuisine.has_key?(arg)
+					SystemCuisine[arg]
+				else
+					raise ArgumentError, "Unknown skill or preset cuisine name `#{arg}' is given."
+				end
+			else
+				raise ArgumentError, "The argument should be Mgmg::Cuisine or skill name String. (`#{arg}' is given)"
+			end
+		end
+	end
+	
+	class Equip
+		def reinforce(*arg)
+			arg.each do |r|
+				r = Reinforcement.compile(r)
+				@para.map!.with_index do |pr, i|
+					if r.vec[i] == 0
+						pr
+					else
+						pr * (100+r.vec[i]).quo(100)
+					end
+				end
+			end
+			self
+		end
+	end
+end