记得最终幻想（战略版）里有这么个系统 觉得还是一个装备带1个技能就够了
话说LZ最好不要设置成“@XXX” 因为太多脚本是这么设置了 什么魔法商店啊等等 为什么不设置成一个特殊点的符号呢  变量前面是@ 所以想把@改成别的 全局搜索全部改掉的方法也是行不通的 最好把修改符号的地方全部标出 或者用一个脚本里没有出现过的符号  
但是关于窗口兼容还是应该考虑下 最好信息显示成可以随时变更的 因为这个描绘位置定死了 稍微改下装备窗口 位置就不对了

看起来真的很不错啊，下下来看看

有一种ＬＺ把旧东西翻新了一道，然后又拿出来卖的感觉，貌似比以前强大了。
那我说几点吧。

首先咋又是名字上@XXX啊？ 好吧，转移话题。

此外你有木有发现你那些进度条是在默认的界面上画的，那么局限性可想而知，说白了就是必须使用默认的窗口才能使用你这脚本，况且是否支持装备扩充不得而知。

再来扩展性，一般来说一个装备学会技能无可争议，作者可以选择是否附加技能。但是我要附加两个，三个呢？这里讲的扩展性，就是在1.0版就要为以后的版本提供接口。

然后你可以参考这样的设置方式。
直接从技能的描述上取得信息。
比如，钢剑
钢铁打造的剑，威力不错。附加技能旋风，养成值达到800可习得该技能。附加技能十字斩，养成值达到900可习得该技能。
这样的描述通俗易懂。注意蓝色字尾关键字，直接在描述里面搜索关键字，进而获得附加装备的信息以及养成值。

然后具体在游戏里面显示呢就是。
钢铁打造的剑，威力不错 旋风 > 500 / 800 十字斩 > 300 / 900(当然也可以是别的表现方式)，因为描述直接就是放在帮助窗口里，所以无论什么样的窗口系统都能兼容进去。

写一个脚本如果要想用的人多就要有，易用性，易查性，易改性，兼容性。

有多少人愿意放弃华丽一点的界面系统来用你这个JAEP技能，最简单的那个更换装备显示详细更改信息的（用默认界面的作者80%都在用。）你能兼容上不？额，装备扩充呢？

此贴绝非吐槽，只是建议，现在愿意发布技术的人太少了，66的人啊。。...

坐等VX版。。。。

看上去是个好东西。
支持一下楼主。




Minax代码似乎都写得啰嗦了点。

1. return min[x,y,z] == max[x,y,z] ? true : false

复制代码

这样的语句完全没有必要吧……

1. return min[x,y,z] == max[x,y,z]

复制代码

就可以了。

代码写的又有些没有必要

1.       min[x,y,z] = [0, [min[x,y,z] += value, max[x,y,z]].min].max

复制代码

这里，为什么中间要用+=呢，虽然是没有问题，但是会对变量进行两次赋值，这就显得没有必要了。  

为什么$jaes要独立出来、还要修改存档结构？建议还是把它保存到$game_temp里面把。兼容也可以变好的。


orzfly于2011-8-26 07:01补充以下内容：
为什么 Minax 中几乎每个函数我都能写成一行……



高强度压缩了一下，性能未测试。
其实剩下4个函数也可以用multirange_each处理掉。

1. # -----------------------------------------------------------------------------
   
2. # Minax
   
3. # ver:1.0 (compressed by orzFly)
   
4. # date:2011.8.23
   
5. #                                                                     -by.Ultra
   
6. # -----------------------------------------------------------------------------
   
7. # ◆性能：
   
8. # Minax 工作效率测试
   
9. # 测试电脑：1.81 GHz   1.5G RAM
   
10. # MIN类1秒处理>30万个单元，同时处理上限为300万个单元（临近10秒备份）
    
11. # MAX类1秒处理>150万个单元，同时处理上限为2000万个单元（临近10秒备份）
    
12. # ◆函数：
    
13. # Minax 全部函数简要
    
14. # 函数(参数)                                       * 函数处理简要
    
15. # ━ minax_table(size)                             * 生成 MIN 与 MAX 多维数组
    
16. # ━ min_full?(type,unit)                          * 判断MIN是否达到上限 MAX
    
17. # ┏ min_set(type,set)                             * 用数据设置到 MIN
    
18. # ┗ max_set(type,set)                             * 用数据设置到 MAX
    
19. # ┏ min_all_cover(type,value)                     * MIN 全部代入某值
    
20. # ┗ max_all_cover(type,value)                     * MAX 全部代入某值
    
21. # ┏ min_all_pr(type,value)                        * MIN 全部增减某值
    
22. # ┗ max_all_pr(type,value)                        * MAX 全部增减某值
    
23. # ┏ min_range_cover(type,value,qx,zx,qy,zy,qz,zz) * MIN 范围代入某值
    
24. # ┗ max_range_cover(type,value,qx,zx,qy,zy,qz,zz) * MAX 范围代入某值
    
25. # ┏ min_range_pr(type,value,qx,zx,qy,zy,qz,zz)    * MIN 范围增减某值
    
26. # ┗ max_range_pr(type,value,qx,zx,qy,zy,qz,zz)    * MAX 范围增减某值
    
27. # ┏ min_unit_cover(type,unit,value)               * MIN 单元代入某值
    
28. # ┗ max_unit_cover(type,unit,value)               * MAX 单元代入某值
    
29. # ┏ min_unit_pr(type,unit,value)                  * MIN 单元增减某值
    
30. # ┗ max_unit_pr(type,unit,value)                  * MAX 单元增减某值
    
31. # ◆参数：
    
32. # Minax 全部参数规格
    
33. # 参数      * 参数结构规格              * 参数内容规格
    
34. # size      * {"T"=>[x,y,z],""=>[]…}   * T为字符串 x,y,z为整数
    
35. # type      * "T"                       * T为字符串
    
36. # set       * [[x,y,z,num],[]…]        * x,y,z值为每维范围内 num为整数，浮点数
    
37. # value     * num                       * num为整数，浮点数
    
38. # unit      * [x,y,z]                   * x,y,z值为每维范围内
    
39. # qx,qy,qz  * x,y,z                     * x,y,z值为每维范围内
    
40. # zx,zy,zz  * x,y,z                     * x,y,z值为每维范围内
    
41. # -----------------------------------------------------------------------------
    
42. class Minax
    
43.   attr_accessor :min
    
44.   attr_accessor :max
    
45.   attr_accessor :size
    
46.   def initialize
    
47.     @min = {}
    
48.     @max = {}
    
49.     @size = {}
    
50.   end
    
51.   # ---------------------------------------------------------------------------
    
52.   # 多 Range each by orzFly
    
53.   # ex: multirange_each(0..2, 1..5, 1..2) {|*a| p a}
    
54.   # ---------------------------------------------------------------------------
    
55.   def multirange_each(*args)
    
56.     args[0].each { |i|
    
57.       args.size > 1 ?
    
58.         (multirange_each(*args[1, args.size - 1]) { |*v| yield(i, *v) }) :
    
59.         (yield(i))
    
60.     }
    
61.     nil
    
62.   end
    
63.   # ---------------------------------------------------------------------------
    
64.   # 多维数组生成
    
65.   # 规则：MIN 与 MAX 尺寸相同
    
66.   # size：数据尺寸
    
67.   # ---------------------------------------------------------------------------
    
68.   def minax_table(size)
    
69.     size.each {|k,v|
    
70.       @size[k] = v
    
71.       @min[k] = Table.new(*v)
    
72.       @max[k] = Table.new(*v)
    
73.     }
    
74.   end
    
75.   # ---------------------------------------------------------------------------
    
76.   # MIN 是否达上限（=MAX）
    
77.   # 规则：是则返回 true，否则返回 false
    
78.   # type：MAX 类型
    
79.   # unit：MAX 单元地址
    
80.   # ---------------------------------------------------------------------------
    
81.   def min_full?(type,unit)
    
82.     v = @size[type]
    
83.     return @min[type][*v] == @max[type][*v]
    
84.   end
    
85.   # ---------------------------------------------------------------------------
    
86.   # MIN 加载设置
    
87.   # 规则：设置数组最后一个单元为设置值
    
88.   # type：MIN 类型
    
89.   # set：设置数据
    
90.   # ---------------------------------------------------------------------------
    
91.   def min_set(type,set)
    
92.     set.each {|i|
    
93.       @min[type][*(i[0, @size[type].size])] = i[-1]
    
94.     }
    
95.   end
    
96.   # ---------------------------------------------------------------------------
    
97.   # MAX 加载设置
    
98.   # 规则：设置数组最后一个单元为设置值
    
99.   # type：MIN 类型
    
100.   # set：设置数据
     
101.   # ---------------------------------------------------------------------------
     
102.   def max_set(type,set)
     
103.     set.each {|i|
     
104.       @max[type][*(i[0, @size[type].size])] = i[-1]
     
105.     }
     
106.   end
     
107.   # ---------------------------------------------------------------------------
     
108.   # MIN 全部代入
     
109.   # 规则：MIN 上限为 MAX
     
110.   # type：MIN 类型
     
111.   # value：代入的值
     
112.   # ---------------------------------------------------------------------------
     
113.   def min_all_cover(type,value)
     
114.     multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
     
115.       @min[type][*arg] = [value, @max[type][*arg]].min
     
116.     }
     
117.   end
     
118.   # ---------------------------------------------------------------------------
     
119.   # MAX 全部代入
     
120.   # 规则：MAX 无限制
     
121.   # type：MAX 类型
     
122.   # value：代入的值
     
123.   # ---------------------------------------------------------------------------
     
124.   def max_all_cover(type,value)
     
125.     multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
     
126.       @max[type][*arg] = value
     
127.     }
     
128.   end
     
129.   # ---------------------------------------------------------------------------
     
130.   # MIN 全部增减
     
131.   # 规则：MIN 下限为 0，上限为 MAX
     
132.   # type：MIN 类型
     
133.   # value：增加的值，负数为减
     
134.   # ---------------------------------------------------------------------------
     
135.   def min_all_pr(type,value)
     
136.     multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
     
137.       @min[type][*arg] = [0, [@min[type][*arg] + value, @max[type][*arg]].min].max
     
138.     }
     
139.   end
     
140.   # ---------------------------------------------------------------------------
     
141.   # MAX 全部增减
     
142.   # 规则：MAX 无限制
     
143.   # type：MAX 类型
     
144.   # value：增加的值，负数为减
     
145.   # ---------------------------------------------------------------------------
     
146.   def max_all_pr(type,value)
     
147.     multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
     
148.       @max[type][*arg] = @max[type][*arg] + value
     
149.     }
     
150.   end
     
151.   # ---------------------------------------------------------------------------
     
152.   # MIN 范围代入
     
153.   # 规则：MIN 上限为 MAX
     
154.   # type：MIN 类型
     
155.   # value：代入的值
     
156.   # qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
     
157.   # zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
     
158.   # ---------------------------------------------------------------------------
     
159.   def min_range_cover(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
     
160.     v = @size[type]
     
161.     min = @min[type]
     
162.     max = @max[type]
     
163.     case v.size
     
164.       when 1
     
165.         zx = v[0] - zx - 1 if zx > 0
     
166.         (v[0]-qx-zx).times {|x|
     
167.           min[x+qx] = [value,max[x+qx]].min
     
168.         }
     
169.       when 2
     
170.         zx = v[0] - zx - 1 if zx > 0
     
171.         zy = v[1] - zy - 1 if zy > 0
     
172.         (v[0]-qx-zx).times {|x|
     
173.           (v[1]-qy-zy).times {|y|
     
174.             min[x+qx,y+qy] = [value,max[x+qx,y+qy]].min
     
175.           }
     
176.         }
     
177.       when 3
     
178.         zx = v[0] - zx - 1 if zx > 0
     
179.         zy = v[1] - zy - 1 if zy > 0
     
180.         zz = v[2] - zz - 1 if zz > 0
     
181.         (v[0]-qx-zx).times {|x|
     
182.           (v[1]-qy-zy).times {|y|
     
183.             (v[2]-qz-zz).times {|z|
     
184.               min[x+qx,y+qy,z+qz] = [value,max[x+qx,y+qy,z+qz]].min
     
185.             }
     
186.           }
     
187.         }
     
188.     end
     
189.   end
     
190.   # ---------------------------------------------------------------------------
     
191.   # MAX 范围代入
     
192.   # 规则：MAX 无限制
     
193.   # type：MAX 类型
     
194.   # value：代入的值
     
195.   # qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
     
196.   # zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
     
197.   # ---------------------------------------------------------------------------
     
198.   def max_range_cover(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
     
199.     v = @size[type]
     
200.     max = @max[type]
     
201.     case v.size
     
202.       when 1
     
203.         zx = v[0] - zx - 1 if zx > 0
     
204.         (v[0]-qx-zx).times {|x|
     
205.           max[x+qx] = value
     
206.         }
     
207.       when 2
     
208.         zx = v[0] - zx - 1 if zx > 0
     
209.         zy = v[1] - zy - 1 if zy > 0
     
210.         (v[0]-qx-zx).times {|x|
     
211.           (v[1]-qy-zy).times {|y|
     
212.             max[x+qx,y+qy] = value
     
213.           }
     
214.         }
     
215.       when 3
     
216.         zx = v[0] - zx - 1 if zx > 0
     
217.         zy = v[1] - zy - 1 if zy > 0
     
218.         zz = v[2] - zz - 1 if zz > 0
     
219.         (v[0]-qx-zx).times {|x|
     
220.           (v[1]-qy-zy).times {|y|
     
221.             (v[2]-qz-zz).times {|z|
     
222.               max[x+qx,y+qy,z+qz] = value
     
223.             }
     
224.           }
     
225.         }
     
226.     end
     
227.   end
     
228.   # ---------------------------------------------------------------------------
     
229.   # MIN 范围增减
     
230.   # 规则：MIN 下限为 0，上限为 MAX
     
231.   # type：MIN 类型
     
232.   # value：增加的值，负数为减
     
233.   # qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
     
234.   # zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
     
235.   # ---------------------------------------------------------------------------
     
236.   def min_range_pr(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
     
237.     v = @size[type]
     
238.     min = @min[type]
     
239.     max = @max[type]
     
240.     case v.size
     
241.       when 1
     
242.         zx = v[0] - zx - 1 if zx > 0
     
243.         (v[0]-qx-zx).times {|x|
     
244.           min[x+qx] =
     
245.           [0, [min[x+qx] += value, max[x+qx]].min].max
     
246.         }
     
247.       when 2
     
248.         zx = v[0] - zx - 1 if zx > 0
     
249.         zy = v[1] - zy - 1 if zy > 0
     
250.         (v[0]-qx-zx).times {|x|
     
251.           (v[1]-qy-zy).times {|y|
     
252.             min[x+qx,y+qy] =
     
253.             [0, [min[x+qx,y+qy] += value, max[x+qx,y+qy]].min].max
     
254.           }
     
255.         }
     
256.       when 3
     
257.         zx = v[0] - zx - 1 if zx > 0
     
258.         zy = v[1] - zy - 1 if zy > 0
     
259.         zz = v[2] - zz - 1 if zz > 0
     
260.         (v[0]-qx-zx).times {|x|
     
261.           (v[1]-qy-zy).times {|y|
     
262.             (v[2]-qz-zz).times {|z|
     
263.               min[x+qx,y+qy,z+qz] =
     
264.               [0, [min[x+qx,y+qy,z+qz] += value, max[x+qx,y+qy,z+qz]].min].max
     
265.             }
     
266.           }
     
267.         }
     
268.     end
     
269.   end
     
270.   # ---------------------------------------------------------------------------
     
271.   # MAX 范围增减
     
272.   # 规则：MAX 无限制
     
273.   # type：MAX 类型
     
274.   # value：增加的值，负数为减
     
275.   # qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
     
276.   # zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
     
277.   # ---------------------------------------------------------------------------
     
278.   def max_range_pr(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
     
279.     v = @size[type]
     
280.     max = @max[type]
     
281.     case v.size
     
282.       when 1
     
283.         zx = v[0] - zx - 1 if zx > 0
     
284.         (v[0]-qx-zx).times {|x|
     
285.           max[x+qx] += value
     
286.         }
     
287.       when 2
     
288.         zx = v[0] - zx - 1 if zx > 0
     
289.         zy = v[1] - zy - 1 if zy > 0
     
290.         (v[0]-qx-zx).times {|x|
     
291.           (v[1]-qy-zy).times {|y|
     
292.             max[x+qx,y+qy] += value
     
293.           }
     
294.         }
     
295.       when 3
     
296.         zx = v[0] - zx - 1 if zx > 0
     
297.         zy = v[1] - zy - 1 if zy > 0
     
298.         zz = v[2] - zz - 1 if zz > 0
     
299.         (v[0]-qx-zx).times {|x|
     
300.           (v[1]-qy-zy).times {|y|
     
301.             (v[2]-qz-zz).times {|z|
     
302.               max[x+qx,y+qy,z+qz] += value
     
303.             }
     
304.           }
     
305.         }
     
306.     end
     
307.   end
     
308.   # ---------------------------------------------------------------------------
     
309.   # MIN 单元代入
     
310.   # 规则：MIN 上限为 MAX
     
311.   # type：MIN 类型
     
312.   # unit：MIN 单元地址
     
313.   # value：增加的值，负数为减
     
314.   # ---------------------------------------------------------------------------
     
315.   def min_unit_cover(type,unit,value)
     
316.     @min[type][*unit] = [value,@max[type][*unit]].min
     
317.   end
     
318.   # ---------------------------------------------------------------------------
     
319.   # MAX 单元代入
     
320.   # 规则：无限制
     
321.   # type：MAX 类型
     
322.   # unit：MAX 单元地址
     
323.   # value：增加的值，负数为减
     
324.   # ---------------------------------------------------------------------------
     
325.   def max_unit_cover(type,unit,value)
     
326.     @max[type][*unit] = value
     
327.   end
     
328.   # ---------------------------------------------------------------------------
     
329.   # MIN 单元增减
     
330.   # 规则：MIN 下限为 0，上限为 MAX
     
331.   # type：MIN 类型
     
332.   # unit：MIN 单元地址
     
333.   # value：增加的值，负数为减
     
334.   # ---------------------------------------------------------------------------
     
335.   def min_unit_pr(type,unit,value)
     
336.     @min[type][*unit] = [0, [@min[type][*unit] + value, @max[type][*unit][x]].min].max
     
337.   end
     
338.   # ---------------------------------------------------------------------------
     
339.   # MAX 单元增减
     
340.   # 规则：MAX 无限制
     
341.   # type：MAX 类型
     
342.   # unit：MAX 单元地址
     
343.   # value：增加的值，负数为减
     
344.   # ---------------------------------------------------------------------------
     
345.   def max_unit_pr(type,unit,value)
     
346.     @max[type][*unit] = @max[type][*unit] + value
     
347.   end
     
348. end

复制代码