mgmg 1.4.1 → 1.5.1

data/lib/mgmg/optimize.rb

@@ -2,8 +2,12 @@ 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)] )
+		def phydef_optimize(str, smith, comp=smith, opt: Option.new)
+			best = if smith.nil? then
+				[str, str.poly(:phydef, opt: opt), str.poly(:magdef, opt: opt), str.poly(:cost, opt: opt)]
+			else
+				[str, str.build(smith, comp, opt: opt)]
+			end
 			str = Mgmg.check_string(str)
 			ai = 0
 			while str.sub!(/(帽子|フード|サンダル)\([宝木骨][12][宝木骨]1\)/){
@@ -19,7 +23,7 @@ module Mgmg
 			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
+					if m[1].sub(/綿1\)/, '皮1)').build(smith, opt: opt).weight == m[1].sub(/皮1\)/, '綿1)').build(smith, opt: opt).weight
 						skin = true
 					end
 				else
@@ -35,7 +39,11 @@ module Mgmg
 				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)
+					best = if smith.nil? then
+						pd_better(best, [r, r.poly(:phydef, opt: opt), r.poly(:magdef, opt: opt), r.poly(:cost, opt: opt)], opt.magdef_maximize)
+					else
+						pd_better(best, [r, r.build(smith, comp, opt: opt)], opt.magdef_maximize)
+					end
 					b = pd_next_b(b)
 				end
 				a = pd_next_a(a)
@@ -49,7 +57,11 @@ module Mgmg
 					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)
+						best = if smith.nil? then
+							pd_better(best, [r, r.poly(:phydef, opt: opt), r.poly(:magdef, opt: opt), r.poly(:cost, opt: opt)], opt.magdef_maximize)
+						else
+							pd_better(best, [r, r.build(smith, comp, opt: opt)], opt.magdef_maximize)
+						end
 						b = pd_next_b(b)
 					end
 					a = pd_next_a(a)
@@ -102,7 +114,7 @@ module Mgmg
 				end
 				return pre
 			else
-				raise "Unexpected Error"
+				raise UnexpectedError
 			end
 		end
 		private def pd_apply_idx(str, a, b)
@@ -146,8 +158,8 @@ module Mgmg
 		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)] )
+		def buster_optimize(str, smith, comp=smith, opt: Option.new)
+			best = ( smith.nil? ? [str, str.poly(:mag_das, opt: opt)] : [str, str.build(smith, comp, opt: opt)] )
 			str = Mgmg.check_string(str)
 			ai = -1
 			org = nil
@@ -162,7 +174,7 @@ module Mgmg
 			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)] ))
+				best = bus_better(best, ( smith.nil? ? [r, r.poly(:mag_das, opt: opt)] : [r, r.build(smith, comp, opt: opt)] ))
 				a = bus_next_a(a)
 			end
 			best[0]

data/lib/mgmg/option.rb

@@ -0,0 +1,84 @@
+module Mgmg
+	class Option
+		def initialize(
+			left_associative: true,
+			smith_min: nil, armor_min:nil, comp_min: nil, smith_max: 10000, armor_max: 10000, comp_max: 10000,
+			step: 1, magdef_maximize: true,
+			target_weight: 0, reinforcement: [], buff: nil,
+			irep: nil, cut_exp: Float::INFINITY
+		)
+			@left_associative = left_associative
+			@smith_min = smith_min
+			@armor_min = armor_min
+			@comp_min = comp_min
+			@smith_max = smith_max
+			@armor_max = armor_max
+			@comp_max = comp_max
+			@step = step
+			@magdef_maximize = magdef_maximize
+			@target_weight = target_weight
+			@reinforcement = reinforcement
+			unless buff.nil?
+				if @reinforcement.empty?
+					@reinforcement = buff
+				else
+					raise ArgumentError, "reinforcement and buff are exclusive"
+				end
+			end
+			@irep = irep
+			@cut_exp = cut_exp
+		end
+		attr_accessor :left_associative, :smith_min, :armor_min, :comp_min, :smith_max, :armor_max, :comp_max
+		attr_accessor :step, :magdef_maximize, :target_weight, :reinforcement, :irep, :cut_exp
+		def initialize_copy(other)
+			@left_associative = other.left_associative
+			@smith_min = other.smith_min
+			@armor_min = other.armor_min
+			@comp_min = other.comp_min
+			@smith_max = other.smith_max
+			@armor_max = other.armor_max
+			@comp_max = other.comp_max
+			@step = other.step
+			@magdef_maximize = other.magdef_maximize
+			@target_weight = other.target_weight
+			@reinforcement = other.reinforcement.dup
+			@irep = other.irep
+			@cut_exp = other.cut_exp
+		end
+		def update_sa_min(recipe, force=true)
+			case recipe
+			when String
+				if @smith_min.nil? && @armor_min
+					@smith_min = @armor_min
+				end
+				if force || @smith_min.nil?
+					s = recipe.min_level(@target_weight, opt: self)
+					@smith_min = s if force || @smith_min.nil?
+					@armor_min = s if force || @armor_min.nil?
+				end
+			when Enumerable
+				if force || @smith_min.nil? || @armor_min.nil?
+					@target_weight = [@target_weight, @target_weight] if @target_weight.kind_of? Numeric
+					s, a = recipe.min_level(*@target_weight, opt: self)
+					@smith_min = s if force || @smith_min.nil?
+					@armor_min = a if force || @armor_min.nil?
+				end
+			else
+				raise ArgumentError, 'recipe should be String or Enumerable'
+			end
+			self
+		end
+		def set_default(recipe, force: false)
+			update_sa_min(recipe, force)
+			@comp_min = recipe.min_comp(opt: self) if force || @comp_min.nil?
+			@irep = recipe.ir(opt: self) if force || @irep.nil?
+			self
+		end
+		def buff
+			@reinforcement
+		end
+		def buff=(v)
+			@reinforcement = v
+		end
+	end
+end

data/lib/mgmg/poly.rb

@@ -301,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/recipe.rb

@@ -0,0 +1,172 @@
+module Mgmg
+	class Recipe
+		def initialize(recipe, para=:power, **kw)
+			@recipe = recipe
+			@recipe.each(&:freeze) if @recipe.kind_of?(Enumerable)
+			@recipe.freeze
+			@para = para
+			@option = Option.new(**kw).set_default(@recipe)
+		end
+		attr_reader :recipe
+		attr_accessor :para
+		def initialize_copy(other)
+			@recipe = other.recipe.dup
+			@option = other.option.dup
+		end
+		private def temp_opt(**kw)
+			if kw.empty?
+				@option
+			else
+				ret = @option.dup
+				kw.each do |key, value|
+					ret.method((key.to_s+'=').to_sym).call(value)
+					ret.update_sa_min(@recipe) if key == :target_weight
+					ret.irep.add_reinforcement(value) if key == :reinforcement || key == :buff
+					if key == :left_associative
+						ret.irep = @recipe.ir(opt: ret).add_reinforcement(ret.reinforcement)
+					end
+				end
+				ret
+			end
+		end
+		def option(**kw)
+			@option = temp_opt(*kw)
+			@option
+		end
+		def option=(new_option)
+			@option = new_option.set_default(@recipe)
+		end
+		def replace(new_recipe, para: @para, **kw)
+			@recipe = new_recipe
+			@recipe.each(&:freeze) if @recipe.kind_of?(Enumerable)
+			@recipe.freeze
+			@para = para
+			@option = Option.new(**kw).set_default(@recipe)
+			self
+		end
+		def min_weight
+			@recipe.min_weight(opt: @option)
+		end
+		def max_weight(include_outsourcing=false)
+			@recipe.max_weight(opt: @option)
+		end
+		def min_level(w=@option.target_weight, include_outsourcing=false)
+			@recipe.min_level(w, include_outsourcing, opt: @option)
+		end
+		def min_levels(w=1)
+			@recipe.min_levels(w, opt: @option)
+		end
+		def min_levels_max(w=1)
+			@recipe.min_levels_max(w, opt: @option)
+		end
+		def min_smith
+			@recipe.min_smith
+		end
+		def min_comp
+			@recipe.min_comp
+		end
+		def build(smith=-1, armor=smith, comp=armor.tap{armor=smith}, **kw)
+			opt = temp_opt(**kw)
+			smith, armor, comp = opt.smith_min, opt.armor_min, opt.comp_min if smith.nil?
+			case @recipe
+			when String
+				recipe.build(smith, comp, opt: opt)
+			when Enumerable
+				recipe.build(smith, armor, comp, opt: opt)
+			else
+				raise BrokenRecipeError
+			end
+		end
+		def show(smith=-1, armor=smith, comp=armor.tap{armor=smith}, para: @para, **kw)
+			opt = temp_opt(**kw)
+			smith, armor, comp = opt.smith_min, opt.armor_min, opt.comp_min if smith.nil?
+			case @recipe
+			when String
+				recipe.show(smith, comp, para: para, opt: opt)
+			when Enumerable
+				recipe.show(smith, armor, comp, para: para, opt: opt)
+			else
+				raise BrokenRecipeError
+			end
+		end
+		def search(target, para: @para, **kw)
+			opt = temp_opt(**kw)
+			@recipe.search(para, target, opt: opt)
+		end
+		private def correct_level(s, ac, x, opt)
+			if s.nil?
+				if x.equal?(false)
+					s, ac, x = opt.smith_min, opt.comp_min, nil
+				else
+					s, ac, x = opt.smith_min, opt.armor_min, opt.comp_min
+				end
+			else
+				s = 0 if s < 0
+				ac = 0 if ac < 0
+				if x.equal?(false)
+					x = nil
+				else
+					x = 0 if x < 0
+				end
+			end
+			[s, ac, x]
+		end
+		def para_call(smith=-1, armor=smith, comp=armor.tap{armor=smith}, para: @para, **kw)
+			opt = temp_opt(**kw)
+			smith, armor, comp = correct_level(smith, armor, comp, opt)
+			case @recipe
+			when String
+				opt.irep.para_call(para, smith, comp)
+			when Enumerable
+				opt.irep.para_call(para, smith, armor, comp)
+			else
+				raise InvalidRecipeError
+			end
+		end
+		def ir(**kw)
+			temp_opt(**kw).irep
+		end
+		%i|attack phydef magdef hp mp str dex speed magic atkstr atk_sd dex_as mag_das magic2 magmag pmdef|.each do |sym|
+			define_method(sym) do |s, ac=s, x=false, **kw|
+				s, ac, x = correct_level(s, ac, x, temp_opt(**kw))
+				ir(**kw).method(sym).call(s, ac, x)
+			end
+		end
+		%i|power fpower|.each do |sym|
+			define_method(sym) do |s, a=s, c=a.tap{a=s}, **kw|
+				s, a, c = correct_level(s, a, c, temp_opt(**kw))
+				ir(**kw).method(sym).call(s, a, c)
+			end
+		end
+		%i|smith_cost comp_cost cost|.each do |sym|
+			define_method(sym) do |s, c=s, outsourcing=false, **kw|
+				s, c, x = correct_level(s, c, false, temp_opt(**kw))
+				ir(**kw).method(sym).call(s, c, out_sourcing)
+			end
+		end
+		def poly(para=@para, **kw)
+			opt = temp_opt(**kw)
+			if @recipe.kind_of?(String)
+				@recipe.poly(para, opt: opt)
+			else
+				raise InvalidRecipeError, "Mgmg::Recipe#poly is available only for String recipes."
+			end
+		end
+		def phydef_optimize(smith=nil, comp=smith, **kw)
+			opt = temp_opt(**kw)
+			if @recipe.kind_of?(String)
+				@recipe.phydef_optimize(smith, comp, opt: opt)
+			else
+				raise InvalidRecipeError, "Mgmg::Recipe#phydef_optimize is available only for String recipes."
+			end
+		end
+		def buster_optimize(smith=nil, comp=smith, **kw)
+			opt = temp_opt(**kw)
+			if @recipe.kind_of?(String)
+				@recipe.buster_optimize(smith, comp, opt: opt)
+			else
+				raise InvalidRecipeError, "Mgmg::Recipe#buster_optimize is available only for String recipes."
+			end
+		end
+	end
+end

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)
+					cuisine(SystemCuisine[arg])
+				else
+					raise InvalidReinforcementNameError, arg
+				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