请高手帮忙~

hykwf233

我想做一个开关，当该开关打开时，角色1每项攻击技能和普通攻击都带某个“状态”。例如：让敌人有10%机会带“麻痺”等。

---

版务信息：本贴由楼主自主结贴～

hykwf233

请各位帮忙~~谢谢~~~

灯笼菜刀王

1. $麻痹开关 = 1
   
2. class Game_Battler
   
3.     def attack_effect(attacker)
   
4.     # 清除会心一击标志
   
5.     self.critical = false
   
6.     # 第一命中判定
   
7.     hit_result = (rand(100) < attacker.hit)
   
8.     # 命中的情况下
   
9.     if hit_result == true
   
10.       # 计算基本伤害
    
11.       atk = [attacker.atk - self.pdef / 2, 0].max
    
12.       self.damage = atk * (20 + attacker.str) / 20
    
13.       # 属性修正
    
14.       self.damage *= elements_correct(attacker.element_set)
    
15.       self.damage /= 100
    
16.       # 伤害符号正确的情况下
    
17.       if self.damage > 0
    
18.         # 会心一击修正
    
19.         if rand(100) < 4 * attacker.dex / self.agi
    
20.           self.damage *= 2
    
21.           self.critical = true
    
22.         end
    
23.         # 防御修正
    
24.         if self.guarding?
    
25.           self.damage /= 2
    
26.         end
    
27.       end
    
28.       # 分散
    
29.       if self.damage.abs > 0
    
30.         amp = [self.damage.abs * 15 / 100, 1].max
    
31.         self.damage += rand(amp+1) + rand(amp+1) - amp
    
32.       end
    
33.       # 第二命中判定
    
34.       eva = 8 * self.agi / attacker.dex + self.eva
    
35.       hit = self.damage < 0 ? 100 : 100 - eva
    
36.       hit = self.cant_evade? ? 100 : hit
    
37.       hit_result = (rand(100) < hit)
    
38.     end
    
39.     # 命中的情况下
    
40.     if hit_result == true
    
41.       # 状态冲击解除
    
42.       remove_states_shock
    
43.       # HP 的伤害计算
    
44.       self.hp -= self.damage
    
45.       # 状态变化
    
46.       @state_changed = false
    
47.       states_plus(attacker.plus_state_set)
    
48.       states_minus(attacker.minus_state_set)
    
49.       for i in 1...$data_states.size
    
50.       sid = $data_states[i].id if $data_states[i].name == "麻痹"
    
51.       end
    
52.       self.add_state(sid) if abcdefg(attacker)
    
53.     # Miss 的情况下
    
54.     else
    
55.       # 伤害设置为 "Miss"
    
56.       self.damage = "Miss"
    
57.       # 清除会心一击标志
    
58.       self.critical = false
    
59.     end
    
60.     # 过程结束
    
61.     return true
    
62.   end
    
63. def skill_effect(user, skill)
    
64.     # 清除会心一击标志
    
65.     self.critical = false
    
66.     # 特技的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
    
67.     # 或者特技的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
    
68.     if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
    
69.        ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
    
70.       # 过程结束
    
71.       return false
    
72.     end
    
73.     # 清除有效标志
    
74.     effective = false
    
75.     # 公共事件 ID 是有效的情况下,设置为有效标志
    
76.     effective |= skill.common_event_id > 0
    
77.     # 第一命中判定
    
78.     hit = skill.hit
    
79.     if skill.atk_f > 0
    
80.       hit *= user.hit / 100
    
81.     end
    
82.     hit_result = (rand(100) < hit)
    
83.     # 不确定的特技的情况下设置为有效标志
    
84.     effective |= hit < 100
    
85.     # 命中的情况下
    
86.     if hit_result == true
    
87.       # 计算威力
    
88.       power = skill.power + user.atk * skill.atk_f / 100
    
89.       if power > 0
    
90.         power -= self.pdef * skill.pdef_f / 200
    
91.         power -= self.mdef * skill.mdef_f / 200
    
92.         power = [power, 0].max
    
93.       end
    
94.       # 计算倍率
    
95.       rate = 20
    
96.       rate += (user.str * skill.str_f / 100)
    
97.       rate += (user.dex * skill.dex_f / 100)
    
98.       rate += (user.agi * skill.agi_f / 100)
    
99.       rate += (user.int * skill.int_f / 100)
    
100.       # 计算基本伤害
     
101.       self.damage = power * rate / 20
     
102.       # 属性修正
     
103.       self.damage *= elements_correct(skill.element_set)
     
104.       self.damage /= 100
     
105.       # 伤害符号正确的情况下
     
106.       if self.damage > 0
     
107.         # 防御修正
     
108.         if self.guarding?
     
109.           self.damage /= 2
     
110.         end
     
111.       end
     
112.       # 分散
     
113.       if skill.variance > 0 and self.damage.abs > 0
     
114.         amp = [self.damage.abs * skill.variance / 100, 1].max
     
115.         self.damage += rand(amp+1) + rand(amp+1) - amp
     
116.       end
     
117.       # 第二命中判定
     
118.       eva = 8 * self.agi / user.dex + self.eva
     
119.       hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
     
120.       hit = self.cant_evade? ? 100 : hit
     
121.       hit_result = (rand(100) < hit)
     
122.       # 不确定的特技的情况下设置为有效标志
     
123.       effective |= hit < 100
     
124.     end
     
125.     # 命中的情况下
     
126.     if hit_result == true
     
127.       # 威力 0 以外的物理攻击的情况下
     
128.       if skill.power != 0 and skill.atk_f > 0
     
129.         # 状态冲击解除
     
130.         remove_states_shock
     
131.         # 设置有效标志
     
132.         effective = true
     
133.       end
     
134.       # HP 的伤害减法运算
     
135.       last_hp = self.hp
     
136.       self.hp -= self.damage
     
137.       effective |= self.hp != last_hp
     
138.       # 状态变化
     
139.       @state_changed = false
     
140.       effective |= states_plus(skill.plus_state_set)
     
141.       effective |= states_minus(skill.minus_state_set)
     
142.       if abcdefg(attacker)
     
143.       for i in 1...$data_states.size
     
144.       sid = $data_states[i].id if $data_states[i].name == "麻痹"
     
145.       end
     
146.       self.add_state(sid)
     
147.       @state_changed = true
     
148.       end
     
149.       # 威力为 0 的场合
     
150.       if skill.power == 0
     
151.         # 伤害设置为空的字串
     
152.         self.damage = ""
     
153.         # 状态没有变化的情况下
     
154.         unless @state_changed
     
155.           # 伤害设置为 "Miss"
     
156.           self.damage = "Miss"
     
157.         end
     
158.       end
     
159.     # Miss 的情况下
     
160.     else
     
161.       # 伤害设置为 "Miss"
     
162.       self.damage = "Miss"
     
163.     end
     
164.     # 不在战斗中的情况下
     
165.     unless $game_temp.in_battle
     
166.       # 伤害设置为 nil
     
167.       self.damage = nil
     
168.     end
     
169.     # 过程结束
     
170.     return effective
     
171.   end
     
172. def abcdefg(attacker)
     
173.     a = attacker
     
174.     if a.is_a?(Game_Actor)
     
175.       b = rand(10)
     
176.       if $game_switches[$麻痹开关] and a.id == 1 and b == 0
     
177.         return true
     
178.       else
     
179.         return false
     
180.       end
     
181.     else
     
182.       return false
     
183.     end
     
184.   end
     
185. end

复制代码

把这段脚本塞到MAIN前，名字随便，  并在状态栏里设置一个叫“麻痹”的状态（名字一定要写对，否则会出错-。-）就可以了。 默认开关1号，想改就到脚本最上面改。

声明，不负责售后服务。

hykwf233

真奇怪！我使用的时候提示142行出错！？

灯笼菜刀王

~~~
错误的提示是什么，还有把错误的地方帖出来看看。


-。-我自己使用是没问题，这个是少数有经过自己测试的脚本~~~

主要的是名字要写对“麻痹”直接复制进去吧-。-，有些版本的写法不同....

其他的应该就没有什么问题了，我是贯彻“傻瓜式使用方法”这一理念写的....

还有，冲突问题不小-，-，毕竟直接修改ATTACK_EFFECT和SKILL_EFFECT这两个热门-.-

=========分割分割==============

-v-b犯了的严重的错误，漏了一个句子~现在已经修正.....

1. 
   
2. $麻痹开关 = 1
   
3. class Game_Battler
   
4.     def attack_effect(attacker)
   
5.     # 清除会心一击标志
   
6.     self.critical = false
   
7.     # 第一命中判定
   
8.     hit_result = (rand(100) < attacker.hit)
   
9.     # 命中的情况下
   
10.     if hit_result == true
    
11.       # 计算基本伤害
    
12.       atk = [attacker.atk - self.pdef / 2, 0].max
    
13.       self.damage = atk * (20 + attacker.str) / 20
    
14.       # 属性修正
    
15.       self.damage *= elements_correct(attacker.element_set)
    
16.       self.damage /= 100
    
17.       # 伤害符号正确的情况下
    
18.       if self.damage > 0
    
19.         # 会心一击修正
    
20.         if rand(100) < 4 * attacker.dex / self.agi
    
21.           self.damage *= 2
    
22.           self.critical = true
    
23.         end
    
24.         # 防御修正
    
25.         if self.guarding?
    
26.           self.damage /= 2
    
27.         end
    
28.       end
    
29.       # 分散
    
30.       if self.damage.abs > 0
    
31.         amp = [self.damage.abs * 15 / 100, 1].max
    
32.         self.damage += rand(amp+1) + rand(amp+1) - amp
    
33.       end
    
34.       # 第二命中判定
    
35.       eva = 8 * self.agi / attacker.dex + self.eva
    
36.       hit = self.damage < 0 ? 100 : 100 - eva
    
37.       hit = self.cant_evade? ? 100 : hit
    
38.       hit_result = (rand(100) < hit)
    
39.     end
    
40.     # 命中的情况下
    
41.     if hit_result == true
    
42.       # 状态冲击解除
    
43.       remove_states_shock
    
44.       # HP 的伤害计算
    
45.       self.hp -= self.damage
    
46.       # 状态变化
    
47.       @state_changed = false
    
48.       states_plus(attacker.plus_state_set)
    
49.       states_minus(attacker.minus_state_set)
    
50.       for i in 1...$data_states.size
    
51.       sid = $data_states[i].id if $data_states[i].name == "麻痹"
    
52.       end
    
53.       self.add_state(sid) if abcdefg(attacker)
    
54.     # Miss 的情况下
    
55.     else
    
56.       # 伤害设置为 "Miss"
    
57.       self.damage = "Miss"
    
58.       # 清除会心一击标志
    
59.       self.critical = false
    
60.     end
    
61.     # 过程结束
    
62.     return true
    
63.   end
    
64. def skill_effect(user, skill)
    
65.     # 清除会心一击标志
    
66.     self.critical = false
    
67.     # 特技的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
    
68.     # 或者特技的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
    
69.     if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
    
70.        ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
    
71.       # 过程结束
    
72.       return false
    
73.     end
    
74.     # 清除有效标志
    
75.     effective = false
    
76.     # 公共事件 ID 是有效的情况下,设置为有效标志
    
77.     effective |= skill.common_event_id > 0
    
78.     # 第一命中判定
    
79.     hit = skill.hit
    
80.     if skill.atk_f > 0
    
81.       hit *= user.hit / 100
    
82.     end
    
83.     hit_result = (rand(100) < hit)
    
84.     # 不确定的特技的情况下设置为有效标志
    
85.     effective |= hit < 100
    
86.     # 命中的情况下
    
87.     if hit_result == true
    
88.       # 计算威力
    
89.       power = skill.power + user.atk * skill.atk_f / 100
    
90.       if power > 0
    
91.         power -= self.pdef * skill.pdef_f / 200
    
92.         power -= self.mdef * skill.mdef_f / 200
    
93.         power = [power, 0].max
    
94.       end
    
95.       # 计算倍率
    
96.       rate = 20
    
97.       rate += (user.str * skill.str_f / 100)
    
98.       rate += (user.dex * skill.dex_f / 100)
    
99.       rate += (user.agi * skill.agi_f / 100)
    
100.       rate += (user.int * skill.int_f / 100)
     
101.       # 计算基本伤害
     
102.       self.damage = power * rate / 20
     
103.       # 属性修正
     
104.       self.damage *= elements_correct(skill.element_set)
     
105.       self.damage /= 100
     
106.       # 伤害符号正确的情况下
     
107.       if self.damage > 0
     
108.         # 防御修正
     
109.         if self.guarding?
     
110.           self.damage /= 2
     
111.         end
     
112.       end
     
113.       # 分散
     
114.       if skill.variance > 0 and self.damage.abs > 0
     
115.         amp = [self.damage.abs * skill.variance / 100, 1].max
     
116.         self.damage += rand(amp+1) + rand(amp+1) - amp
     
117.       end
     
118.       # 第二命中判定
     
119.       eva = 8 * self.agi / user.dex + self.eva
     
120.       hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
     
121.       hit = self.cant_evade? ? 100 : hit
     
122.       hit_result = (rand(100) < hit)
     
123.       # 不确定的特技的情况下设置为有效标志
     
124.       effective |= hit < 100
     
125.     end
     
126.     # 命中的情况下
     
127.     if hit_result == true
     
128.       # 威力 0 以外的物理攻击的情况下
     
129.       if skill.power != 0 and skill.atk_f > 0
     
130.         # 状态冲击解除
     
131.         remove_states_shock
     
132.         # 设置有效标志
     
133.         effective = true
     
134.       end
     
135.       # HP 的伤害减法运算
     
136.       last_hp = self.hp
     
137.       self.hp -= self.damage
     
138.       effective |= self.hp != last_hp
     
139.       # 状态变化
     
140.       @state_changed = false
     
141.       effective |= states_plus(skill.plus_state_set)
     
142.       effective |= states_minus(skill.minus_state_set)
     
143.       attacker = user
     
144.       if abcdefg(attacker)
     
145.       for i in 1...$data_states.size
     
146.       sid = $data_states[i].id if $data_states[i].name == "麻痹"
     
147.       end
     
148.       self.add_state(sid)
     
149.       @state_changed = true
     
150.       end
     
151.       # 威力为 0 的场合
     
152.       if skill.power == 0
     
153.         # 伤害设置为空的字串
     
154.         self.damage = ""
     
155.         # 状态没有变化的情况下
     
156.         unless @state_changed
     
157.           # 伤害设置为 "Miss"
     
158.           self.damage = "Miss"
     
159.         end
     
160.       end
     
161.     # Miss 的情况下
     
162.     else
     
163.       # 伤害设置为 "Miss"
     
164.       self.damage = "Miss"
     
165.     end
     
166.     # 不在战斗中的情况下
     
167.     unless $game_temp.in_battle
     
168.       # 伤害设置为 nil
     
169.       self.damage = nil
     
170.     end
     
171.     # 过程结束
     
172.     return effective
     
173.   end
     
174. def abcdefg(attacker)
     
175.     a = attacker
     
176.     if a.is_a?(Game_Actor)
     
177.       b = rand(10)
     
178.       if $game_switches[$麻痹开关] and a.id == 1 and b == 0
     
179.         return true
     
180.       else
     
181.         return false
     
182.       end
     
183.     else
     
184.       return false
     
185.     end
     
186.   end
     
187. end

复制代码

---

系统信息：本贴由楼主认可为正确答案，66RPG感谢您的热情解答～

hykwf233

首先感谢楼上的这个脚本，谢谢~
另外~因为我是完全的脚本白痴，所以有些地方看不懂，请见谅。
请问这个脚本是只对1P适用吗？
如何设置其状态的出现率呢？
能否同时使用两个一样的脚本？例如：1开关打开时带A状态，2开关打开时带B状态？
普通攻击也带属性吗？

hykwf233

谢谢~

hykwf233

这么好的脚本，不把功能介绍清楚，实在太~~~~~~~~可惜了~

灯笼菜刀王

- -~ 给了实例还不够么，直接塞MANI前就能使用了还不简便么~~~

功能就是你主楼说的

我想做一个开关（$麻痹开关），当该开关打开时，角色1每项攻击技能和普通攻击都带某个“状态”。例如：让敌人有10%机会带“麻痺”等。

全部符合~~~ 当别人工作完成的时候附加的问题算售后服务，已经声明不负责。

其实这个脚本很简单，只定义了一个判断，当条件满足（开关打开，角色ID为1，10%几率）的时候返回true，然后在附加状态上用这个分歧，true的时候强制附加状态而已。想改就按着改就可以了~

做游戏的新手

以下引用灯笼菜刀王于2008-9-19 18:59:14的发言：

- -~ 给了实例还不够么，直接塞MANI前就能使用了还不简便么~~~

功能就是你主楼说的

我想做一个开关（$麻痹开关），当该开关打开时，角色1每项攻击技能和普通攻击都带某个“状态”。例如：让敌人有10%机会带“麻痺”等。

全部符合~~~ 当别人工作完成的时候附加的问题算售后服务，已经声明不负责。

其实这个脚本很简单，只定义了一个判断，当条件满足（开关打开，角色ID为1，10%几率）的时候返回true，然后在附加状态上用这个分歧，true的时候强制附加状态而已。想改就按着改就可以了~


[本贴由作者于 2008-9-19 19:00:34 最后编辑]

拜托菜刀兄
人家要的是$game_switches[x]的变量