技能按照sp消耗排序系统（2016.11.8 更新）

我是好人a1a1

理论上来说，后期技能多了，强力的技能都排在后面，很不方便，所以制作了一个技能按照sp消耗排序系统
由于sp消耗排序，太复杂，而且好像也没人写过这方面的脚本，只能自行研究
目的是达到强力技能在前面的效果，本意是sp消耗越大排的越前，由于不太擅长脚本，只能写个简单的脚本，实用性还行
原理简单粗暴，直接将原有的技能倒过来
Window_Skill第40行原来脚本
     for i in 0...@actor.skills.size
      skill = $data_skills[@actor.skills]
      if skill != nil
        @data.push(skill)
      end
    end
把这段脚本替换成

1. #=============================================================================
   
2. 
   
3. #技能按照sp消耗排序系统（2016.11.8 更新）
   
4. 
   
5. #-----------------------------------------------------------------------------
   
6. 
   
7. # 作者：我是好人a1a1
   
8. 
   
9. #=============================================================================
   
10. 
    
11.     for i in 0...@actor.skills.size
    
12.         haoren=@actor.skills.size
    
13.         haoren=haoren-1
    
14.         haoren=haoren-i
    
15.         skill = $data_skills[@actor.skills[haoren]]
    
16.       if skill != nil
    
17.         @data.push(skill)
    
18.       end
    
19.     end

复制代码

这样技能就能按照sp消耗排序了

fux2

楼主这个实现方法有点玄妙，在下没看出来是怎么取到SP值的……
我这里提供一个方法

1. class Window_Skill < Window_Selectable
   
2.   alias :_r :refresh
   
3.   def refresh
   
4.     if self.contents != nil
   
5.       self.contents.dispose
   
6.       self.contents = nil
   
7.     end
   
8.    @data = []
   
9.     for i in 0...@actor.skills.size
   
10.       skill = $data_skills[@actor.skills[i]]
    
11.       if skill != nil
    
12.         @data.push(skill)
    
13.       end
    
14.     end
    
15.     @data = @data.sort_by{|sk| sk.sp_cost}.reverse
    
16.     @item_max = @data.size
    
17.     if @item_max > 0
    
18.       self.contents = Bitmap.new(width - 32, row_max * 32)
    
19.       for i in 0...@item_max
    
20.         draw_item(i)
    
21.       end
    
22.     end
    
23.   end
    
24. end

复制代码

其实就是在45和46行之间添加了一行

1. @data = @data.sort_by{|sk| sk.sp_cost}.reverse

复制代码

我是好人a1a1

fux2 发表于 2016-11-9 13:25
楼主这个实现方法有点玄妙，在下没看出来是怎么取到SP值的……
我这里提供一个方法

目的是达到强力技能在前面的效果，本意是sp消耗越大排的越前，由于不太擅长脚本，只能写个简单的脚本，实用性还行
原理简单粗暴：直接将原有的技能倒过来
由于sp消耗排序，太复杂，而且好像也没人写过这方面的脚本，只能自行研究
这是我研究的成果，我尽力了。。。
只能做到将原有的技能倒过来，并不是真正的sp消耗排序
算是抛砖引玉吧
另外请教一下 复制代码 ，我不会弄 复制代码 这个功能，有劳管理员帮忙编辑了
其实，我的并不是真正的sp消耗排序，只是用了巧妙的方法，把技能排序重组
你写的代码，才是真正的sp消耗排序，我有时间再慢慢研究，再向你请教
最近一直很忙，而且一直在倒弄 按键重复上次技能 的系统

RyanBern

如果是简单的倒排的话，改成这样就好了

RUBY 代码复制

@data = @actors.skills.sort.reverse.map{|id| $data_skills[id]}
@data.reject!{|skill| skill.nil?}

@data = @actors.skills.sort.reverse.map{|id| $data_skills[id]}


@data.reject!{|skill| skill.nil?}

其中第二行的作用是删掉其中的无效值。如果很自信自己的数据没问题也可以不写。

最后，祝节日快乐早日成为 fux2 巨巨一样的大醋。

我是好人a1a1

RyanBern 发表于 2016-11-11 09:05
如果是简单的倒排的话，改成这样就好了
@data = @actors.skills.sort.reverse.map{|id| $data_skills}
@dat ...

仔细研究了你们的脚本，发现完全看不懂，搜遍了帮助文档，只找到sort和sort!，解析不出sort_by其中的逻辑，请问这种方法是在哪里学的？
sort
sort!
sort {|a, b| ... }
sort! {|a, b| ... }
对数组内容进行排序。若带块调用时，将把 2 个参数传给块，然后使用块的计算结果进行比较。若没有块时，使用 <=> 运算符进行比较。sort! 的对数组单元的排序过程具有破环性。

sort 将生成一个经过排序的新数组并返回它，sort! 通常会返回 self。