超好用的技能消耗物品怎么同时消耗多样不同数量的物品？

lirn

[pre lang="ruby"]module IISNOW_ITEM_CONSUME_SKILL
  
  PATTERN = /.*I:ID(\d+)N(\d+)(.*)/m  
  # 非专业人士请勿修改，正则匹配式,修改后注意备注写法的改变,下同
  PATTERN_E = /.*EQU:ID(\d+).*/m
  PATTERN_A = /.*ARM:ID(\d+).*/m
  STR_UN_CONSUM = "UN" # 物品不消耗标识
  
  TP_ICON = 189  # 你说你懂的
  MP_ICON = 188
  
  STYLE = 2 # 界面风格(支持1,2,3,4效果自己体会,不推荐4)
  STYLE_A = 2 # 提示风格（支持1,2,3,同上）
  PLACE = 3 # 消耗物品的图标与数目间的间距
  PLACE_E = 2 # 不同消耗物品间的间距
  ORDER = [0,1,2]     # 从右往左的消耗显示顺序（0，TP;1，MP;2，物品）
  
  COLOR_ITEM = Color.new(255,255,255) # 物品消耗数目的字的颜色
  COLOR_WE_L = Color.new(255,0,0) # 具体限定武器的框的颜色
  COLOR_WE_A = Color.new(255,0,0) # 具体限定防具的框的颜色
  COLOR_UN_I = Color.new(0,255,0) # 物品限定但不消耗的提示框的颜色
  
  TRAN_DE = 100 # 风格_A2下的透明度再次降低（最大为160）
end

class Window_SkillList
  
  include IISNOW_ITEM_CONSUME_SKILL
  
  def col_max
    case STYLE
    when 1,3,4
      return 2
    when 2
      return 1
    end
  end
  
  def item_height
    case STYLE
    when 3
      line_height * 2
    when 1,2,4
      line_height + 1
    end
  end
  
  def draw_item(index)
    skill = @data[index]
    if skill
      rect = item_rect(index)
      rect.width -= 4
      draw_item_name(skill, rect.x, rect.y, enable?(skill))
      draw_skill_cost(rect, skill)
    end
  end
  
  alias :iisnow_draw_item_name :draw_item_name
  def draw_item_name(item, x, y, enabled = true, width = 172)
    iisnow_draw_item_name(item, x, y, enabled,width)
    rect_temp = text_size(item.name)
    if @actor.skill_eq_limt(item)
      draw_kuang(x + 24 + PLACE  + rect_temp.width,y,24,24,COLOR_WE_L,enabled)
      draw_icon(@actor.skill_eq_limt(item).icon_index,x + 24 + PLACE + rect_temp.width,y,enabled)
      rect_temp.width += (24 + PLACE_E)
    end
    if @actor.skill_ar_limt(item)
      draw_kuang(x + 24 + PLACE + rect_temp.width,y,24,24,COLOR_WE_A,enabled)
      draw_icon(@actor.skill_ar_limt(item).icon_index,x + 24 + PLACE + rect_temp.width,y,enabled)
    end
  end
  
  def draw_skill_cost(rect, skill)
    str = create_string(skill)
    color = [tp_cost_color,mp_cost_color,COLOR_ITEM]
    str.each_with_index do |str,i|
      next unless str
      change_color(color[ORDER], enable?(skill))
      kuang = false
      case i
      when ORDER.index(2)
        icon_index = str[0].icon_index
        kuang = true if str[2]
        str = str[1]
      when ORDER.index(1)
        icon_index = MP_ICON
      when ORDER.index(0)
        icon_index = TP_ICON
      end
      contents.font.size = STYLE == 1 ? Font.default_size - 6 : Font.default_size
      draw_style(icon_index,rect,str,skill,kuang)
    end
    contents.font.size = Font.default_size
  end
  
  def draw_style(icon_index,rect,str,skill,kuang)
    case STYLE
    when 1
      draw_kuang(rect.width - 24 + rect.x,rect.y,24,24,COLOR_UN_I,enable?(skill)) if kuang
      draw_icon(icon_index,rect.width - 24 + rect.x,rect.y,enable?(skill))
      draw_text(Rect.new(rect.x + rect.width - 24,rect.y + 8,24,16),str,2) if str.to_i != 1
      rect.width -= (24 + PLACE_E)
    when 2,4
      draw_text(rect,str,2) if str.to_i != 1
      rect.width -= (text_size(str).width + PLACE) if str.to_i != 1
      draw_kuang(rect.width - 24 + rect.x,rect.y,24,24,COLOR_UN_I,enable?(skill)) if kuang
      draw_icon(icon_index,rect.width - 24 + rect.x,rect.y,enable?(skill))
      rect.width -= (24 + PLACE_E)
    when 3
      rect_temp = rect.clone
      rect_temp.y += (rect_temp.height / 2)
      rect_temp.height /= 2
      draw_text(rect_temp,str,2) if str.to_i != 1
      rect.width -= (text_size(str).width + PLACE) if str.to_i != 1
      draw_kuang(rect.width - 24 + rect.x,rect_temp.y,24,24,COLOR_UN_I,enable?(skill)) if kuang
      draw_icon(icon_index,rect.width - 24 + rect.x,rect_temp.y,enable?(skill))
      rect.width -= (24 + PLACE_E)
    end
  end
  
  def draw_kuang(x,y,w,h,c,fl)
    c.alpha = fl ? 255 : translucent_alpha - (STYLE_A == 2 ? TRAN_DE : 0)
    case STYLE_A
    when 1
      contents.fill_rect(x,y,w,1,c)
      contents.fill_rect(x,y + 1,1,h - 1,c)
      contents.fill_rect(x + 1,y + h - 1,w - 1,1,c)
      contents.fill_rect(x + w -1,y + 1,1,h - 2,c)
    when 2
      contents.fill_rect(x,y,w,h,c)
    end
  end
  
  def create_string(skill)
    str1 = @actor.skill_tp_cost(skill)
    str2 = @actor.skill_mp_cost(skill)
    str3 = @actor.skill_it_cost(skill)
    str1 = str1 > 0 ?  str1.to_s : nil
    str2 = str2 > 0 ?  str2.to_s : nil
    str3 = str3[1] > 0 ? [str3[0],str3[1].to_s,str3[2]] : nil
    str = [str1,str2,str3]
    iisnow = [str[ORDER[0]],str[ORDER[1]],str[ORDER[2]]]
    iisnow
  end
  
end

class Game_BattlerBase
  
  include IISNOW_ITEM_CONSUME_SKILL
  
  def skill_it_cost(skill)
    skill.note.match(PATTERN)
    item = $data_items[$1.to_i] if $1 != 0
    num = $2.to_i
    flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
    return [item,num,flag]
  end
  
  def skill_eq_limt(skill)
    skill.note.match(PATTERN_E)
    eq = $data_weapons[$1.to_i] if $1 != 0
    return eq
  end
  
  def skill_ar_limt(skill)
    skill.note.match(PATTERN_A)
    eq = $data_armors[$1.to_i] if $1 != 0
    return eq
  end
  
  alias :iisnow_skill_cost_payable? :skill_cost_payable?
  def skill_cost_payable?(skill)
    result1 = iisnow_skill_cost_payable?(skill)
    if skill_it_cost(skill)[0]
      result2 = $game_party.item_number(skill_it_cost(skill)[0]) >= skill_it_cost(skill)[1]
      return result1 && result2
    end
    return result1
  end
  
  alias :iisnow_pay_skill_cost :pay_skill_cost
  def pay_skill_cost(skill)
    iisnow_pay_skill_cost(skill)
    if skill_it_cost(skill)[0] && !skill_it_cost(skill)[2]
      $game_party.gain_item(skill_it_cost(skill)[0],-skill_it_cost(skill)[1])
    end
  end

end

class Game_Actor
  
  alias :iisnow_skill_wtype_ok? :skill_wtype_ok?
  def skill_wtype_ok?(skill)
    result1 = iisnow_skill_wtype_ok?(skill)
    result2 = skill_eq_limt(skill) ? weapons.include?(skill_eq_limt(skill)) : true
    result3 = skill_ar_limt(skill) ? armors.include?(skill_ar_limt(skill)) : true
    return result1 && result2 && result3
  end
  
end[/pre]

其实，我是打算用来做生活技能用的。虽然我也知道有一些制作的脚本，但是我是不希望有材料有钱就能无限做，我的设定是每次使用会消耗魔法和时间（游戏中的），由于涉及变量比较多，需要每个生产都会有不同的变量，以我的能力不大可能大规模修改那些脚本，于是我就相出了一个办法。通过技能计算公式给变量。然后由公共事件来执行。

这个脚本很适合，但是，目前这个脚本只能消耗一种物品，没办法同时消耗多种不同数量的物品，而那个帖子也有许多人问同样的问题。我之所以不再等是因为上述考虑要涉及到不少变量开关，如果真的没办法我也得花上不少时间去找其他可能的方法，所以才到这里问了。

lirn

由于我是不懂脚本，我想到一个笨办法，但乱改可能有很大麻烦，所以我来问问。

就上述脚本同类的只能读取一个，那我选择增加备注栏的数目应该可以吧。

比如一开始的

[pre lang="ruby"]PATTERN = /.*I:ID(\d+)N(\d+)(.*)/m  [/pre]

我再添加一个
[pre lang="ruby"]PATTERN_1= /.*I1:ID(\d+)N(\d+)(.*)/m  [/pre]



[pre lang="ruby"]  def skill_it_cost(skill)
    skill.note.match(PATTERN)
    item = $data_items[$1.to_i] if $1 != 0
    num = $2.to_i
    flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
    return [item,num,flag]
    skill.note.match(PATTERN_1)
    item = $data_items[$1.to_i] if $1 != 0
    num = $2.to_i
    flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
    return [item,num,flag]
  end
  [/pre]

然后这样行不？

lirn

1. module IISNOW_ITEM_CONSUME_SKILL
   
2.   
   
3.   PATTERN = /.*I0:I(\d+)N(\d+)(.*)/m  
   
4.   # 非专业人士请勿修改，正则匹配式,修改后注意备注写法的改变,下同
   
5.   PATTERN_1 = /.*I1:I(\d+)N(\d+)(.*)/m
   
6.   PATTERN_2 = /.*I2:I(\d+)N(\d+)(.*)/m
   
7.   PATTERN_3 = /.*I3:I(\d+)N(\d+)(.*)/m
   
8.   PATTERN_4 = /.*I4:I(\d+)N(\d+)(.*)/m
   
9.   PATTERN_5 = /.*I5:I(\d+)N(\d+)(.*)/m
   
10.   PATTERN_E = /.*EQU:ID(\d+).*/m
    
11.   PATTERN_A = /.*ARM:ID(\d+).*/m
    
12.   STR_UN_CONSUM = "UN" # 物品不消耗标识
    
13.   
    
14.   TP_ICON = 189  # 你说你懂的
    
15.   MP_ICON = 188
    
16.   
    
17.   STYLE = 2 # 界面风格(支持1,2,3,4效果自己体会,不推荐4)
    
18.   STYLE_A = 2 # 提示风格（支持1,2,3,同上）
    
19.   PLACE = 3 # 消耗物品的图标与数目间的间距
    
20.   PLACE_E = 2 # 不同消耗物品间的间距
    
21.   ORDER = [0,1,2]     # 从右往左的消耗显示顺序（0，TP;1，MP;2，物品）
    
22.   
    
23.   COLOR_ITEM = Color.new(255,255,255) # 物品消耗数目的字的颜色
    
24.   COLOR_WE_L = Color.new(255,0,0) # 具体限定武器的框的颜色
    
25.   COLOR_WE_A = Color.new(255,0,0) # 具体限定防具的框的颜色
    
26.   COLOR_UN_I = Color.new(0,255,0) # 物品限定但不消耗的提示框的颜色
    
27.   
    
28.   TRAN_DE = 100 # 风格_A2下的透明度再次降低（最大为160）
    
29. end
    
30. 
    
31. class Window_SkillList
    
32.   
    
33.   include IISNOW_ITEM_CONSUME_SKILL
    
34.   
    
35.   def col_max
    
36.     case STYLE
    
37.     when 1,3,4
    
38.       return 2
    
39.     when 2
    
40.       return 1
    
41.     end
    
42.   end
    
43.   
    
44.   def item_height
    
45.     case STYLE
    
46.     when 3
    
47.       line_height * 2
    
48.     when 1,2,4
    
49.       line_height + 1
    
50.     end
    
51.   end
    
52.   
    
53.   def draw_item(index)
    
54.     skill = @data[index]
    
55.     if skill
    
56.       rect = item_rect(index)
    
57.       rect.width -= 4
    
58.       draw_item_name(skill, rect.x, rect.y, enable?(skill))
    
59.       draw_skill_cost(rect, skill)
    
60.     end
    
61.   end
    
62.   
    
63.   alias :iisnow_draw_item_name :draw_item_name
    
64.   def draw_item_name(item, x, y, enabled = true, width = 172)
    
65.     iisnow_draw_item_name(item, x, y, enabled,width)
    
66.     rect_temp = text_size(item.name)
    
67.     if @actor.skill_eq_limt(item)
    
68.       draw_kuang(x + 24 + PLACE  + rect_temp.width,y,24,24,COLOR_WE_L,enabled)
    
69.       draw_icon(@actor.skill_eq_limt(item).icon_index,x + 24 + PLACE + rect_temp.width,y,enabled)
    
70.       rect_temp.width += (24 + PLACE_E)
    
71.     end
    
72.     if @actor.skill_ar_limt(item)
    
73.       draw_kuang(x + 24 + PLACE + rect_temp.width,y,24,24,COLOR_WE_A,enabled)
    
74.       draw_icon(@actor.skill_ar_limt(item).icon_index,x + 24 + PLACE + rect_temp.width,y,enabled)
    
75.     end
    
76.   end
    
77.   
    
78.   def draw_skill_cost(rect, skill)
    
79.     str = create_string(skill)
    
80.     color = [tp_cost_color,mp_cost_color,COLOR_ITEM]
    
81.     str.each_with_index do |str,i|
    
82.       next unless str
    
83.       change_color(color[ORDER[i]], enable?(skill))
    
84.       kuang = false
    
85.       case i
    
86.       when ORDER.index(2)
    
87.         icon_index = str[0].icon_index
    
88.         kuang = true if str[2]
    
89.         str = str[1]
    
90.       when ORDER.index(1)
    
91.         icon_index = MP_ICON
    
92.       when ORDER.index(0)
    
93.         icon_index = TP_ICON
    
94.       end
    
95.       contents.font.size = STYLE == 1 ? Font.default_size - 6 : Font.default_size
    
96.       draw_style(icon_index,rect,str,skill,kuang)
    
97.     end
    
98.     contents.font.size = Font.default_size
    
99.   end
    
100.   
     
101.   def draw_style(icon_index,rect,str,skill,kuang)
     
102.     case STYLE
     
103.     when 1
     
104.       draw_kuang(rect.width - 24 + rect.x,rect.y,24,24,COLOR_UN_I,enable?(skill)) if kuang
     
105.       draw_icon(icon_index,rect.width - 24 + rect.x,rect.y,enable?(skill))
     
106.       draw_text(Rect.new(rect.x + rect.width - 24,rect.y + 8,24,16),str,2) if str.to_i != 1
     
107.       rect.width -= (24 + PLACE_E)
     
108.     when 2,4
     
109.       draw_text(rect,str,2) if str.to_i != 1
     
110.       rect.width -= (text_size(str).width + PLACE) if str.to_i != 1
     
111.       draw_kuang(rect.width - 24 + rect.x,rect.y,24,24,COLOR_UN_I,enable?(skill)) if kuang
     
112.       draw_icon(icon_index,rect.width - 24 + rect.x,rect.y,enable?(skill))
     
113.       rect.width -= (24 + PLACE_E)
     
114.     when 3
     
115.       rect_temp = rect.clone
     
116.       rect_temp.y += (rect_temp.height / 2)
     
117.       rect_temp.height /= 2
     
118.       draw_text(rect_temp,str,2) if str.to_i != 1
     
119.       rect.width -= (text_size(str).width + PLACE) if str.to_i != 1
     
120.       draw_kuang(rect.width - 24 + rect.x,rect_temp.y,24,24,COLOR_UN_I,enable?(skill)) if kuang
     
121.       draw_icon(icon_index,rect.width - 24 + rect.x,rect_temp.y,enable?(skill))
     
122.       rect.width -= (24 + PLACE_E)
     
123.     end
     
124.   end
     
125.   
     
126.   def draw_kuang(x,y,w,h,c,fl)
     
127.     c.alpha = fl ? 255 : translucent_alpha - (STYLE_A == 2 ? TRAN_DE : 0)
     
128.     case STYLE_A
     
129.     when 1
     
130.       contents.fill_rect(x,y,w,1,c)
     
131.       contents.fill_rect(x,y + 1,1,h - 1,c)
     
132.       contents.fill_rect(x + 1,y + h - 1,w - 1,1,c)
     
133.       contents.fill_rect(x + w -1,y + 1,1,h - 2,c)
     
134.     when 2
     
135.       contents.fill_rect(x,y,w,h,c)
     
136.     end
     
137.   end
     
138.   
     
139.   def create_string(skill)
     
140.     str1 = @actor.skill_tp_cost(skill)
     
141.     str2 = @actor.skill_mp_cost(skill)
     
142.     str3 = @actor.skill_it_cost(skill)
     
143.     str4 = @actor.skill_it1_cost(skill)
     
144.     str1 = str1 > 0 ?  str1.to_s : nil
     
145.     str2 = str2 > 0 ?  str2.to_s : nil
     
146.     str3 = str3[1] > 0 ? [str3[0],str3[1].to_s,str3[2]] : nil
     
147.     str4 = str4[1] > 0 ? [str4[0],str4[1].to_s,str4[2]] : nil#4
     
148.     str = [str1,str2,str3,str4]
     
149.     iisnow = [str[ORDER[0]],str[ORDER[1]],str[ORDER[2]]]
     
150.     iisnow
     
151.   end
     
152.   
     
153. end
     
154. 
     
155. class Game_BattlerBase
     
156.   
     
157.   include IISNOW_ITEM_CONSUME_SKILL
     
158.   
     
159.   def skill_it_cost(skill)
     
160.     skill.note.match(PATTERN)
     
161.     item = $data_items[$1.to_i] if $1 != 0
     
162.     num = $2.to_i
     
163.     flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
     
164.     return [item,num,flag]
     
165.   end
     
166.   
     
167.     def skill_it1_cost(skill)#加
     
168.     skill.note.match(PATTERN_1)
     
169.     item = $data_items[$1.to_i] if $1 != 0
     
170.     num = $2.to_i
     
171.     flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
     
172.     return [item,num,flag]
     
173.   end#加
     
174.       def skill_it2_cost(skill)#加
     
175.     skill.note.match(PATTERN_2)
     
176.     item = $data_items[$1.to_i] if $1 != 0
     
177.     num = $2.to_i
     
178.     flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
     
179.     return [item,num,flag]
     
180.   end#加
     
181.       def skill_it3_cost(skill)#加
     
182.     skill.note.match(PATTERN_3)
     
183.     item = $data_items[$1.to_i] if $1 != 0
     
184.     num = $2.to_i
     
185.     flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
     
186.     return [item,num,flag]
     
187.   end#加
     
188.   
     
189.   def skill_it4_cost(skill)#加
     
190.     skill.note.match(PATTERN_4)
     
191.     item = $data_items[$1.to_i] if $1 != 0
     
192.     num = $2.to_i
     
193.     flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
     
194.     return [item,num,flag]
     
195.   end#加
     
196.       
     
197.   def skill_it5_cost(skill)#加
     
198.     skill.note.match(PATTERN_5)
     
199.     item = $data_items[$1.to_i] if $1 != 0
     
200.     num = $2.to_i
     
201.     flag = $3.match(/^#{STR_UN_CONSUM}/) if $3
     
202.     return [item,num,flag]
     
203.   end#加
     
204.   
     
205.   def skill_eq_limt(skill)
     
206.     skill.note.match(PATTERN_E)
     
207.     eq = $data_weapons[$1.to_i] if $1 != 0
     
208.     return eq
     
209.   end
     
210.   
     
211.   def skill_ar_limt(skill)
     
212.     skill.note.match(PATTERN_A)
     
213.     eq = $data_armors[$1.to_i] if $1 != 0
     
214.     return eq
     
215.   end
     
216.   
     
217.   alias :iisnow_skill_cost_payable? :skill_cost_payable?
     
218.   def skill_cost_payable?(skill)
     
219.     result1 = iisnow_skill_cost_payable?(skill)
     
220.     if skill_it_cost(skill)[0]
     
221.       result2 = $game_party.item_number(skill_it_cost(skill)[0]) >= skill_it_cost(skill)[1]
     
222.       return result1 && result2
     
223.       elsif  skill_it1_cost(skill)[0] #加
     
224.       result4 = $game_party.item_number(skill_it1_cost(skill)[0]) >= skill_it1_cost(skill)[1]
     
225.       return result1 && result4
     
226.       elsif skill_it2_cost(skill)[0] #加
     
227.       result5 = $game_party.item_number(skill_it2_cost(skill)[0]) >= skill_it2_cost(skill)[1]
     
228.       return result1 && result5
     
229.       elsif skill_it3_cost(skill)[0] #加
     
230.       result6 = $game_party.item_number(skill_it3_cost(skill)[0]) >= skill_it3_cost(skill)[1]
     
231.       return result1 && result6
     
232.       elsif skill_it4_cost(skill)[0] #加
     
233.       result7 = $game_party.item_number(skill_it4_cost(skill)[0]) >= skill_it4_cost(skill)[1]
     
234.       return result1 && result7
     
235.       elsif skill_it5_cost(skill)[0] #加
     
236.       result8 = $game_party.item_number(skill_it5_cost(skill)[0]) >= skill_it5_cost(skill)[1]
     
237.       return result1 && result8
     
238.     end
     
239.     return result1
     
240.   end
     
241.   
     
242.   alias :iisnow_pay_skill_cost :pay_skill_cost
     
243.   def pay_skill_cost(skill)
     
244.     iisnow_pay_skill_cost(skill)
     
245.     if skill_it_cost(skill)[0] && !skill_it_cost(skill)[2]
     
246.       $game_party.gain_item(skill_it_cost(skill)[0],-skill_it_cost(skill)[1])
     
247.     end
     
248.     if skill_it1_cost(skill)[0] && !skill_it1_cost(skill)[2]#加
     
249.       $game_party.gain_item(skill_it1_cost(skill)[0],-skill_it1_cost(skill)[1])
     
250.     end #加
     
251.     if skill_it2_cost(skill)[0] && !skill_it2_cost(skill)[2]#加
     
252.       $game_party.gain_item(skill_it2_cost(skill)[0],-skill_it2_cost(skill)[1])
     
253.     end #加
     
254.     if skill_it3_cost(skill)[0] && !skill_it3_cost(skill)[2]#加
     
255.       $game_party.gain_item(skill_it3_cost(skill)[0],-skill_it3_cost(skill)[1])
     
256.     end #加
     
257.     if skill_it4_cost(skill)[0] && !skill_it4_cost(skill)[2]#加
     
258.       $game_party.gain_item(skill_it4_cost(skill)[0],-skill_it4_cost(skill)[1])
     
259.     end #加
     
260.     if skill_it5_cost(skill)[0] && !skill_it5_cost(skill)[2]#加
     
261.       $game_party.gain_item(skill_it5_cost(skill)[0],-skill_it5_cost(skill)[1])
     
262.     end #加
     
263.   end
     
264. 
     
265. end
     
266. 
     
267. class Game_Actor
     
268.   
     
269.   alias :iisnow_skill_wtype_ok? :skill_wtype_ok?
     
270.   def skill_wtype_ok?(skill)
     
271.     result1 = iisnow_skill_wtype_ok?(skill)
     
272.     result2 = skill_eq_limt(skill) ? weapons.include?(skill_eq_limt(skill)) : true
     
273.     result3 = skill_ar_limt(skill) ? armors.include?(skill_ar_limt(skill)) : true
     
274.     return result1 && result2 && result3
     
275.   end
     
276.   
     
277. end

复制代码

我想了一个笨办法，通过添加这些来增加这些。目前来说确实做到了消耗多样问题，但还有几个个问题。图标没描绘是小事，大问题那就是能否使用技能这里。

1. alias :iisnow_skill_cost_payable? :skill_cost_payable?
   
2.   def skill_cost_payable?(skill)
   
3.     result1 = iisnow_skill_cost_payable?(skill)
   
4.     if skill_it_cost(skill)[0]
   
5.       result2 = $game_party.item_number(skill_it_cost(skill)[0]) >= skill_it_cost(skill)[1]
   
6.       return result1 && result2
   
7.       elsif  skill_it1_cost(skill)[0] #加
   
8.       result4 = $game_party.item_number(skill_it1_cost(skill)[0]) >= skill_it1_cost(skill)[1]
   
9.       return result1 && result4
   
10.       elsif skill_it2_cost(skill)[0] #加
    
11.       result5 = $game_party.item_number(skill_it2_cost(skill)[0]) >= skill_it2_cost(skill)[1]
    
12.       return result1 && result5
    
13.       elsif skill_it3_cost(skill)[0] #加
    
14.       result6 = $game_party.item_number(skill_it3_cost(skill)[0]) >= skill_it3_cost(skill)[1]
    
15.       return result1 && result6
    
16.       elsif skill_it4_cost(skill)[0] #加
    
17.       result7 = $game_party.item_number(skill_it4_cost(skill)[0]) >= skill_it4_cost(skill)[1]
    
18.       return result1 && result7
    
19.       elsif skill_it5_cost(skill)[0] #加
    
20.       result8 = $game_party.item_number(skill_it5_cost(skill)[0]) >= skill_it5_cost(skill)[1]
    
21.       return result1 && result8
    
22.     end
    
23.     return result1
    
24.   end

复制代码

没猜错的话，应该是这段有问题。因为只要有了其中一种物品，就会return result1，技能就可以使用，请问应该要怎么做？

三途亚梦

脚本我还没细看，话说既然提到要消耗“时间”你，你想要如何达成呢？

如果单纯的是作为生活技能看待的话，我更建议你找一个物品选择扩张的脚本，然后纯事件做这样的生活技能。

lirn

三途亚梦 发表于 2015-5-9 02:31
脚本我还没细看，话说既然提到要消耗“时间”你，你想要如何达成呢？

如果单纯的是作为生活技能 ...

消耗时间一类的可以用公共事件完成。

我在计算公式里写的就是输入变量，然后根本变量执行相关事件。

目前我的朋友已经帮我完成了，只要其中一个不满足就返回0。

现在就差技能描绘，不过这算是小事情了。