“字符串”技能树

恐惧剑刃

源自：http://rpg.blue/thread-336098-1-1.html

---

看似很复杂，其实很简单。

---

脚本参考，当然要自行做一些整合

选择窗口

1. # --------------------
   
2.   # 重要！！！！！！！！
   
3.   # --------------------
   
4.   attr_accessor :skill_case
   
5.   attr_accessor :shuzhi_hash

复制代码

初始化

1. # --------------------
   
2.     # 重要！！！！！！！！
   
3.     # --------------------
   
4.    
   
5.     # 判断选择状态用的哈希表
   
6.     @skill_case = {}
   
7.    
   
8.     # 树枝的哈希表
   
9.     @shuzhi_hash = {}

复制代码

添加

1. # ------------------
   
2.     # 描绘图标与树枝
   
3.     # ------------------
   
4.    
   
5.     # 循环准备
   
6.     xunhuan_time = 0
   
7.    
   
8.     jineng_time = 0
   
9.    
   
10.     # 简化
    
11.     #@shuzhi_array.size - 1
    
12.     #@shuzhi_array[jianqu1].split(/◎/)[0].to_i
    
13.       
    
14.     jianqu1 = @shuzhi_array.size - 1
    
15.     jxmh = @shuzhi_array[jianqu1].split(/◎/)[0].to_i
    
16.    
    
17.     # 矩形
    
18.     rect = Rect.new(0, 0, 24, 24)
    
19. 
    
20.       
    
21.     # 循环
    
22.     for i in @shuzhi_array
    
23.       # 坐标
    
24.       x = (xunhuan_time % jxmh) * 32 + 4
    
25.       y = (xunhuan_time / jxmh) * 32 + 4
    
26.       # 不等与"☆"描绘
    
27.       if i != "☆"
    
28.         case i
    
29.         # 技能图标
    
30.         when "★"
    
31.           # 图标透明度
    
32.           unless @actor.skills.include?(@skill[jineng_time].id)
    
33.             opacity_icon = 160
    
34.           else
    
35.             opacity_icon = 255
    
36.           end
    
37.           self.contents.blt(x, y, @icon[jineng_time], rect, opacity_icon)
    
38.           # 以XY坐标为主键技能为值
    
39.           @skill_case[x.to_s+"◎"+y.to_s] = @skill[jineng_time]
    
40.           jineng_time += 1
    
41.         # 树枝
    
42.         when "→"
    
43.           self.contents.blt(x, y, @shuzhi_picture[0], rect)
    
44.           # 以XY坐标为主键方向字符为值
    
45.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "→"
    
46.         when "←"
    
47.           self.contents.blt(x, y, @shuzhi_picture[1], rect)
    
48.           # 以XY坐标为主键方向字符为值
    
49.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "←"
    
50.         when "↑"
    
51.           self.contents.blt(x, y, @shuzhi_picture[2], rect)
    
52.           # 以XY坐标为主键方向字符为值
    
53.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↑"
    
54.         when "↓"
    
55.           self.contents.blt(x, y, @shuzhi_picture[3], rect)
    
56.           # 以XY坐标为主键方向字符为值
    
57.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↓"
    
58.         when "↖"
    
59.           self.contents.blt(x, y, @shuzhi_picture[4], rect)
    
60.           # 以XY坐标为主键方向字符为值
    
61.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↖"
    
62.         when "↗"
    
63.           self.contents.blt(x, y, @shuzhi_picture[5], rect)
    
64.           # 以XY坐标为主键方向字符为值
    
65.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↗"
    
66.         when "↘"
    
67.           self.contents.blt(x, y, @shuzhi_picture[6], rect)
    
68.           # 以XY坐标为主键方向字符为值
    
69.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↘"
    
70.         when "↙"
    
71.           self.contents.blt(x, y, @shuzhi_picture[7], rect)
    
72.           # 以XY坐标为主键方向字符为值
    
73.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↙"
    
74.         end
    
75.       end
    
76.       # 项目判断
    
77.       xunhuan_time += 1
    
78.     end

复制代码

帮助刷新

1. # 刷新帮助
   
2.   def update_help
   
3.    
   
4.    
   
5.     # 为了刷新，就只好牺牲内存了
   
6.    
   
7.     # 判断
   
8.     #if self.index != @old_index
   
9.       # 隐藏帮助
   
10.       @help_window.visible = false
    
11.       # 简化写法
    
12.       jianqu1 = @shuzhi_array.size - 1
    
13.       jxmh = @shuzhi_array[jianqu1].split(/◎/)[0].to_i
    
14.       # 帮助坐标
    
15.       x = (self.index % jxmh) * 32
    
16.       y = (self.index / jxmh) * 32
    
17.       # 循环
    
18.       for i in @skill_case.keys
    
19.         # 判断
    
20.         if i == (x+4).to_s+"◎"+(y+4).to_s
    
21.           @help_window.set_text(
    
22.           x + 50, y, @skill_case[(x+4).to_s+"◎"+(y+4).to_s], @actor)
    
23.         end
    
24.       end
    
25.     #  @old_index = self.index
    
26.     #end
    
27.    
    
28.   end

复制代码

1.   # 刷新选择窗口
   
2.   def update_select_window
   
3.     # B键的按下
   
4.     if Input.trigger?(Input::B)
   
5.       $scene = Scene_Map.new
   
6.     end
   
7.     # C键的按下
   
8.     if Input.trigger?(Input::C)
   
9.       
   
10.       # 获取坐标，以坐标为媒介（主键）获取相关信息
    
11.       
    
12.       # 坐标
    
13.       jianqu1 = SHEZHI::ACTOR_ARRAY[@actor.id].size - 1
    
14.       jxmh = SHEZHI::ACTOR_ARRAY[@actor.id][jianqu1].split(/◎/)[0].to_i
    
15.       
    
16.       x = (@select_window.index % jxmh) * 32 + 4
    
17.       y = (@select_window.index / jxmh) * 32 + 4
    
18.       
    
19.       # 判断是否选中技能
    
20.       if @select_window.skill_case[x.to_s+"◎"+y.to_s] != nil
    
21.         # 简化，方便之后使用skill值
    
22.         skill = @select_window.skill_case[x.to_s+"◎"+y.to_s]
    
23.         # 判断技能是否已经领悟
    
24.         unless @actor.skills.include?(skill)
    
25. 
    
26.           # ------------------
    
27.           # 判断技能树关系
    
28.           # （判断基础技能是否学习）
    
29.           # ------------------
    
30.           # 连接线：→←↑↓↖↗↘↙
    
31.           # ------------------
    
32.          
    
33.           # 判断准备
    
34.           base_skill_array = []
    
35.          
    
36.           # 左边：
    
37.           x_copy = x - 32
    
38.           y_copy = y
    
39.          
    
40.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
    
41.             # 简化
    
42.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
    
43.             # 分歧
    
44.             if shuzhi == "→"
    
45. 
    
46.               # 获得基础技能坐标
    
47.               x_copy = x - 64
    
48.               y_copy = y
    
49.               # 简化，通过基础技能坐标获取基础技能
    
50.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
    
51.               base_skill_array << base
    
52.               
    
53.             end
    
54.           end
    
55.          
    
56.           # 右边：
    
57.           x_copy = x + 32
    
58.           y_copy = y
    
59.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
    
60.             # 简化
    
61.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
    
62.             # 分歧
    
63.             if shuzhi == "←"
    
64. 
    
65.               # 获得基础技能坐标
    
66.               x_copy = x + 64
    
67.               y_copy = y
    
68.               # 简化，通过基础技能坐标获取基础技能
    
69.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
    
70.               base_skill_array << base
    
71.               
    
72.             end
    
73.           end
    
74.          
    
75.           # 上边：
    
76.           x_copy = x
    
77.           y_copy = y - 32
    
78.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
    
79.             # 简化
    
80.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
    
81.             # 分歧
    
82.             if shuzhi == "↓"
    
83. 
    
84.               # 获得基础技能坐标
    
85.               x_copy = x
    
86.               y_copy = y - 64
    
87.               # 简化，通过基础技能坐标获取基础技能
    
88.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
    
89.               base_skill_array << base
    
90. 
    
91.             end
    
92.           end
    
93.          
    
94.           # 下边：
    
95.           x_copy = x
    
96.           y_copy = y + 32
    
97.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
    
98.             # 简化
    
99.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
    
100.             # 分歧
     
101.             if shuzhi == "↑"
     
102. 
     
103.               # 获得基础技能坐标
     
104.               x_copy = x
     
105.               y_copy = y + 64
     
106.               # 简化，通过基础技能坐标获取基础技能
     
107.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
     
108.               base_skill_array << base
     
109. 
     
110.             end
     
111.           end
     
112.          
     
113.           # 左上方：
     
114.           x_copy = x - 32
     
115.           y_copy = y - 32
     
116.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
     
117.             # 简化
     
118.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
     
119.             # 分歧
     
120.             if shuzhi == "↘"
     
121. 
     
122.               # 获得基础技能坐标
     
123.               x_copy = x - 64
     
124.               y_copy = y - 64
     
125.               # 简化，通过基础技能坐标获取基础技能
     
126.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
     
127.               base_skill_array << base
     
128. 
     
129.             end
     
130.           end
     
131.          
     
132.           # 右上方：
     
133.           x_copy = x + 32
     
134.           y_copy = y - 32
     
135.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
     
136.             # 简化
     
137.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
     
138.             # 分歧
     
139.             if shuzhi == "↙"
     
140. 
     
141.               # 获得基础技能坐标
     
142.               x_copy = x + 64
     
143.               y_copy = y - 64
     
144.               # 简化，通过基础技能坐标获取基础技能
     
145.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
     
146.               base_skill_array << base
     
147. 
     
148.             end
     
149.           end
     
150.          
     
151.           # 右下方：
     
152.           x_copy = x + 32
     
153.           y_copy = y + 32
     
154.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
     
155.             # 简化
     
156.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
     
157.             # 分歧
     
158.             if shuzhi == "↖"
     
159. 
     
160.               # 获得基础技能坐标
     
161.               x_copy = x + 64
     
162.               y_copy = y + 64
     
163.               # 简化，通过基础技能坐标获取基础技能
     
164.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
     
165.               base_skill_array << base
     
166. 
     
167.             end
     
168.           end
     
169.          
     
170.           # 左下方：
     
171.           x_copy = x - 32
     
172.           y_copy = y + 32
     
173.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
     
174.             # 简化
     
175.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
     
176.             # 分歧
     
177.             if shuzhi == "↗"
     
178. 
     
179.               # 获得基础技能坐标
     
180.               x_copy = x - 64
     
181.               y_copy = y + 64
     
182.               # 简化，通过基础技能坐标获取基础技能
     
183.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
     
184.               base_skill_array << base
     
185. 
     
186.             end
     
187.           end
     
188.          
     
189.           # 处理干净
     
190.           @yes_or_no = nil
     
191.          
     
192.           # 正式判断
     
193.           if base_skill_array != []
     
194.             for i in base_skill_array
     
195.               # 任意一项基础技能已经领悟，把true就赋予@yes_or_no
     
196.               if @actor.skills.include?(i.id)
     
197.                 @yes_or_no = true
     
198.               end
     
199.             end
     
200.             if @yes_or_no
     
201.               # 领悟技能
     
202.               @actor.learn_skill(skill.id)
     
203.               # 选择窗口刷新
     
204.               @select_window.refresh
     
205.               # 刷新帮助窗口
     
206.               @select_window.update_help
     
207.             end
     
208.           else
     
209.             # 领悟技能
     
210.             @actor.learn_skill(skill.id)
     
211.             # 选择窗口刷新
     
212.             @select_window.refresh
     
213.             # 刷新帮助窗口
     
214.             @select_window.update_help
     
215.           end
     
216. 
     
217.         end#include?
     
218.       end#select
     
219.       
     
220.     end#if input c
     
221.   end#def

复制代码

---