mgmg 1.3.0 → 1.4.1

data/lib/mgmg/ir.rb

@@ -0,0 +1,373 @@
+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)
+			@kind, @star, @main, @sub, @para = kind, star, main_m, sub_m, para
+		end
+		attr_accessor :kind, :star, :main, :sub, :para
+		def initialize_copy(other)
+			@kind = other.kind
+			@star = other.star
+			@main = other.main
+			@sub = other.sub
+			@para = other.para.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(', ')}>"
+			else
+				"#{EquipName[@kind]}☆#{@star}(#{MaterialClass[@main]}#{MaterialClass[@sub]})<#{par.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|
+				if s.nil?
+					@para[i]
+				elsif x.nil?
+					@para[i].evaluate(s, ac)
+				else
+					@para[i].evaluate3(s, ac, x)
+				end
+			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.sum{|e| e.evaluate3(s, a, c)}-((hp(s, a, c)+mp(s, a, c))*3.quo(4))
+			else
+				ret = @para.map{|e| e.evaluate3(s, a, c)}.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)
+			str = Mgmg.check_string(str)
+			stack, str = build_sub0([], str)
+			build_sub(stack, str, left_associative)
+		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/optimize.rb

@@ -0,0 +1,213 @@
+module Mgmg
+	module Optimize; end
+	class << Optimize
+		InvList = [%w|帽子 フード サンダル|.freeze, %w|宝1 骨1 木1 木2 骨2|.freeze, %w|宝1 骨1 木1|.freeze].freeze
+		def phydef_optimize(str, smith, comp=smith, left_associative: true, magdef_maximize: true)
+			best = ( smith.nil? ? [str, str.poly(:phydef), str.poly(:magdef), str.poly(:cost)] : [str, str.build(smith, comp)] )
+			str = Mgmg.check_string(str)
+			ai = 0
+			while str.sub!(/(帽子|フード|サンダル)\([宝木骨][12][宝木骨]1\)/){
+				ai += 1
+				"<A#{ai}>"
+			}; end
+			bi = 0
+			while str.sub!(/[宝木骨]1\)/){
+				bi += 1
+				"<B#{bi}>)"
+			}; end
+			skin = false
+			m = /([^\+]*\([^\(]+[綿皮]1\))\]*\Z/.match(str)
+			if m
+				if smith
+					if m[1].sub(/綿1\)/, '皮1)').build(smith).weight == m[1].sub(/皮1\)/, '綿1)').build(smith).weight
+						skin = true
+					end
+				else
+					skin = true
+				end
+				str = str.sub(/皮(1\)\]*)\Z/) do
+					"綿#{$1}"
+				end
+			end
+			a = Array.new(ai){ [0, 0, 0] }
+			b0 = Array.new(bi){ 0 }
+			while a
+				b = b0
+				while b
+					r = pd_apply_idx(str, a, b)
+					best = pd_better(best, ( smith.nil? ? [r, r.poly(:phydef), r.poly(:magdef), r.poly(:cost)] : [r, r.build(smith, comp)] ), magdef_maximize)
+					b = pd_next_b(b)
+				end
+				a = pd_next_a(a)
+			end
+			if skin
+				str = str.sub(/綿(1\)\]*)\Z/) do
+					"皮#{$1}"
+				end
+				a = Array.new(ai){ [0, 0, 0] }
+				while a
+					b = b0
+					while b
+						r = pd_apply_idx(str, a, b)
+						best = pd_better(best, ( smith.nil? ? [r, r.poly(:phydef), r.poly(:magdef), r.poly(:cost)] : [r, r.build(smith, comp)] ), magdef_maximize)
+						b = pd_next_b(b)
+					end
+					a = pd_next_a(a)
+				end
+			end
+			best[0]
+		end
+		private def pd_better(pre, cur, mag)
+			case pre.size
+			when 2
+				if pre[1].phydef < cur[1].phydef
+					return cur
+				elsif pre[1].phydef == cur[1].phydef
+					if mag
+						if pre[1].magdef < cur[1].magdef
+							return cur
+						elsif pre[1].magdef == cur[1].magdef
+							if cur[1].total_cost.sum < pre[1].total_cost.sum
+								return cur
+							end
+						end
+					else
+						if cur[1].comp_cost < pre[1].comp_cost
+							return cur
+						elsif cur[1].comp_cost == pre[1].comp_cost
+							if cur[1].total_cost.sum < pre[1].total_cost.sum
+								return cur
+							end
+						end
+					end
+				end
+				return pre
+			when 4
+				if pre[1] < cur[1]
+					return cur
+				elsif pre[1] == cur[1]
+					if mag
+						if pre[2] < cur[2]
+							return cur
+						elsif pre[2] == cur[2]
+							if cur[3] < pre[3]
+								return cur
+							end
+						end
+					else
+						if cur[3] < pre[3]
+							return cur
+						end
+					end
+				end
+				return pre
+			else
+				raise "Unexpected Error"
+			end
+		end
+		private def pd_apply_idx(str, a, b)
+			a.each.with_index do |aa, i|
+				str = str.sub("<A#{i+1}>", "#{InvList[0][aa[0]]}(#{InvList[1][aa[1]]}#{InvList[2][aa[2]]})")
+			end
+			b.each.with_index do |bb, i|
+				str = str.sub("<B#{i+1}>", InvList[2][bb])
+			end
+			str
+		end
+		private def pd_next_b_full(b)
+			0.upto(b.length-1) do |i|
+				b[i] += 1
+				if b[i] == InvList[2].size
+					b[i] = 0
+				else
+					return b
+				end
+			end
+			nil
+		end
+		private def pd_next_b(b)
+			if b[0] == 0
+				return Array.new(b.length, 1)
+			end
+			nil
+		end
+		private def pd_next_a(a)
+			0.upto(a.length-1) do |i|
+				0.upto(2) do |j|
+					a[i][j] += 1
+					if a[i][j] == InvList[j].size
+						a[i][j] = 0
+					else
+						return a
+					end
+				end
+			end
+			nil
+		end
+		
+		MwList = %w|綿 皮 骨 木 水|.freeze
+		def buster_optimize(str, smith, comp=smith, left_associative: true)
+			best = ( smith.nil? ? [str, str.poly(:mag_das)] : [str, str.build(smith, comp)] )
+			str = Mgmg.check_string(str)
+			ai = -1
+			org = nil
+			while str.sub!(/弓\(([骨水綿皮木][12][骨水綿皮木]1)\)/){
+				ai += 1
+				if ai == 0
+					org = $1.dup
+				end
+				"弓(<A#{ai}>)"
+			}; end
+			str = str.sub(/<A0>/, org)
+			a = Array.new(ai){ [0, 0, 0] }
+			while a
+				r = bus_apply_idx(str, a)
+				best = bus_better(best, ( smith.nil? ? [r, r.poly(:mag_das)] : [r, r.build(smith, comp)] ))
+				a = bus_next_a(a)
+			end
+			best[0]
+		end
+		private def bus_apply_idx(str, a)
+			a.each.with_index do |aa, i|
+				str = str.sub("<A#{i+1}>", "#{MwList[aa[0]]}#{aa[1]+1}#{MwList[aa[2]]}1")
+			end
+			str
+		end
+		private def bus_better(pre, cur)
+			if pre[1].kind_of?(Mgmg::Equip)
+				if pre[1].mag_das < cur[1].mag_das
+					return cur
+				elsif pre[1].mag_das == cur[1].mag_das
+					if cur[1].total_cost.sum < pre[1].total_cost.sum
+						return cur
+					end
+				end
+				return pre
+			else
+				if pre[1] < cur[1]
+					return cur
+				end
+				return pre
+			end
+		end
+		private def bus_next_a(a)
+			0.upto(a.length-1) do |i|
+				[0, 2].each do |j|
+					a[i][j] += 1
+					if a[i][j] == 5
+						a[i][j] = 0
+					else
+						return a
+					end
+				end
+				a[i][1] += 1
+				if a[i][1] == 2
+					a[i][1] = 0
+				else
+					return a
+				end
+			end
+			nil
+		end
+	end
+end

data/lib/mgmg/poly.rb

@@ -139,10 +139,12 @@ module Mgmg
 			ret
 		end
 		def +(other)
+			other = self.coerce(other)[0] unless other.kind_of?(self.class)
 			mat = @mat.padd(other.mat)
 			self.class.new(mat, 28, 0, 12, 12)
 		end
 		def -(other)
+			other = self.coerce(other)[0] unless other.kind_of?(self.class)
 			mat = @mat.padd(other.mat.scalar(-1))
 			self.class.new(mat, 28, 0, 12, 12)
 		end
@@ -204,6 +206,85 @@ module Mgmg
 			end
 			ret.nil? ? 0 : ret
 		end
+		
+		def coerce(other)
+			[self.class.new(Mat.new(1, 1, other), 28, 0, 12, 12), self]
+		end
+		def <(other)
+			foo = self-other
+			(foo.mat.row_size-1).downto(0) do |s|
+				(foo.mat.col_size-1).downto(0) do |c|
+					bar = foo.mat.body[s][c]
+					if bar < 0
+						return true
+					elsif 0 < bar
+						return false
+					end
+				end
+			end
+			false
+		end
+		def <=(other)
+			foo = self-other
+			(foo.mat.row_size-1).downto(0) do |s|
+				(foo.mat.col_size-1).downto(0) do |c|
+					bar = foo.mat.body[s][c]
+					if bar < 0
+						return true
+					elsif 0 < bar
+						return false
+					end
+				end
+			end
+			true
+		end
+		def >(other)
+			foo = other-self
+			(foo.mat.row_size-1).downto(0) do |s|
+				(foo.mat.col_size-1).downto(0) do |c|
+					bar = foo.mat.body[s][c]
+					if bar < 0
+						return true
+					elsif 0 < bar
+						return false
+					end
+				end
+			end
+			false
+		end
+		def >=(other)
+			foo = other-self
+			(foo.mat.row_size-1).downto(0) do |s|
+				(foo.mat.col_size-1).downto(0) do |c|
+					bar = foo.mat.body[s][c]
+					if bar < 0
+						return true
+					elsif 0 < bar
+						return false
+					end
+				end
+			end
+			true
+		end
+		def ==(other)
+			foo = self-other
+			(foo.mat.row_size-1).downto(0) do |s|
+				(foo.mat.col_size-1).downto(0) do |c|
+					bar = foo.mat.body[s][c]
+					return false if bar != 0
+				end
+			end
+			true
+		end
+		def <=>(other)
+			if self == other
+				0
+			elsif self < other
+				-1
+			else
+				1
+			end
+		end
 	end
 	class << TPolynomial
 		ParamIndex = Hash.new