查看: 19009|回复: 27

[搬运汉化] 被动技能插件dsPassiveSkill汉化版

[复制链接]
梦石
0
星屑
3958
在线时间
445 小时
注册时间
2019-3-3
回帖
80
发表于 2019-8-7 22:29:07 | 显示全部楼层 |阅读模式

加入我们,或者,欢迎回来。

您需要 登录 才可以下载或查看,没有账号?注册会员

×
本帖最后由 多卡多卡 于 2019-8-7 22:55 编辑

这是以前一个在日站上找到的插件,然后为了使用方便就汉化了一下,同时加了一些私货进去,比如原版没有的道具掉率,金钱掉率,属性攻击,治疗量,TP上限等也可以作为被动技能的效果。
使用方法:
1.技能类型中多加一个被动技能类型
搜狗截图20190807221402.png
2.插件参数中把参数调至与技能类型的编号相同,该类型技能战斗外可见,而战斗中将会被隐藏
搜狗截图20190807221425.png
搜狗截图20190807222746.png 搜狗截图20190807221758.png 搜狗截图20190807221657.png
3.在技能的注释栏填入相应的文字
搜狗截图20190807221530.png
4.如果是纯被动技能,则还需要把技能的范围和使用场合做如下调整,同时技能类型一定要调成你选择的类型。
如果是拥有被动效果的主动技能则不需要进行调整,技能类型保持原样即可。
搜狗截图20190807222404.png
dsPassiveSkill.zip (5.58 KB, 下载次数: 1205)
这个东西和主题无关,想要的可以拿去用↓
把逃跑按钮塞进去的MOG_BattleCommands.zip (132.72 KB, 下载次数: 368)



评分

参与人数 8赞 +8 收起 理由
woliebe + 1 精品文章
xiri2019 + 1 我很赞同
kmyxyjyld + 1 精品文章
一梦如是 + 1 我很赞同
mog-yep + 1 精品文章
apeont + 1 精品文章
脚本盲 + 1 我很赞同
白嫩白嫩的 + 1 精品文章

查看全部评分

梦石
0
星屑
22879
在线时间
8598 小时
注册时间
2011-12-31
回帖
3270
发表于 2019-8-7 22:43:02 | 显示全部楼层
最新版dsPassiveSkill.jsver1.11.1
MITライセンス
dsPassiveSkill00.png
dsPassiveSkill.jsver1.11.1
  1. //==============================================================================
  2. // dsPassiveSkill.js
  3. // Copyright (c) 2015 - 2019 DOURAKU
  4. // Released under the MIT License.
  5. // [url]http://opensource.org/licenses/mit-license.php[/url]
  6. //==============================================================================

  7. /*:
  8. * @plugindesc パッシブスキルを実装するプラグイン ver1.11.1
  9. * @author 道楽
  10. *
  11. * @param Show Battle
  12. * @desc パッシブスキルを戦闘中に表示するか
  13. * (true なら表示する / false なら表示しない)
  14. * @default true
  15. * @type boolean
  16. *
  17. * @param Show Battle Switch ID
  18. * @desc 戦闘中のパッシブスキル表示を制御するスイッチのID
  19. * (0なら「Show Battle」の設定に従う)
  20. * @default 0
  21. * @type number
  22. *
  23. * @help
  24. * このプラグインは以下のメモタグの設定ができます。
  25. *
  26. * -----------------------------------------------------------------------------
  27. * スキルに設定するメモタグ
  28. *
  29. * --------
  30. * ・装備できる武器の種類を追加(Equip Weapon)
  31. * <passiveEWPN[武器タイプ]>
  32. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  33. *
  34. * --------
  35. * ・装備できる防具の種類を追加(Equip Armor)
  36. * <passiveEARM[防具タイプ]>
  37. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  38. *
  39. * --------
  40. * ・特定の通常能力値をアップ(Parameter Boost)
  41. * <passivePBST[能力値番号]:[上昇量(%)]>
  42. *  [能力値番号] - 上昇させる通常能力値の番号を1桁の数値で設定する。(数字)
  43. *                 0 - HP
  44. *                 1 - MP
  45. *                 2 - 攻撃力
  46. *                 3 - 防御力
  47. *                 4 - 魔法力
  48. *                 5 - 魔法防御
  49. *                 6 - 敏捷性
  50. *                 7 - 運
  51. *  [上昇量(%)]  - 能力値の上昇量。
  52. *                 %ありなら倍率、なしなら直値となる。(数字)
  53. *                 装備なし状態の能力値に対しての倍率がかかる。
  54. *
  55. * --------
  56. * ・一定の条件下において、特定の通常能力値をアップ(Parameter Boost Ex)
  57. * <passivePBSTEX[能力値番号]:[上昇量(%)],[参照する条件],[判定する値]>
  58. *  [能力値番号]   - passivePBST参照
  59. *  [上昇量(%)]    - passivePBST参照
  60. *  [参照する条件] - 効果を発揮する条件を以下の中から設定する。(文字列)
  61. *                   HPUP - HPが特定の値以上の場合に効果を発揮
  62. *                   HPLW - HPが特定の値以下の場合に効果を発揮
  63. *                   MPUP - MPが特定の値以上の場合に効果を発揮
  64. *                   MPLW - MPが特定の値以下の場合に効果を発揮
  65. *                   TPUP - TPが特定の値以上の場合に効果を発揮
  66. *                   TPLW - TPが特定の値以下の場合に効果を発揮
  67. *                   STAT - 特定のステートを受けている場合に効果を発揮
  68. *  [判定する値]   - 条件の判定に使用するパーセンテージ。(数字)
  69. *                   STATの場合はステート番号。(数字)
  70. *
  71. * 例) HP50%以下で攻撃力が50%アップするスキルを作成する場合
  72. * <passivePBSTEX2:50%,HPUP,50>
  73. *
  74. * --------
  75. * ・特定の追加能力値をアップ(XParameter Boost)
  76. * <passiveXPBST[能力値番号]:[上昇量]>
  77. *  [能力値番号] - 上昇させる追加能力値の番号を1桁の数値で設定する。(数字)
  78. *                 0 - 命中率
  79. *                 1 - 回避率
  80. *                 2 - 会心率
  81. *                 3 - 会心回避率
  82. *                 4 - 魔法回避率
  83. *                 5 - 魔法反射率
  84. *                 6 - 反撃率
  85. *                 7 - HP再生率
  86. *                 8 - MP再生率
  87. *                 9 - TP再生率
  88. *  [上昇量]     - 能力値の上昇量。(数字)
  89. *
  90. * --------
  91. * ・一定の条件下において、特定の追加能力値をアップ(XParameter Boost Ex)
  92. * <passiveXPBSTEX[能力値番号]:[上昇量],[参照する条件],[判定する値]>
  93. *  [能力値番号]   - passiveXPBST参照
  94. *  [上昇量]       - passiveXPBST参照
  95. *  [参照する条件] - passivePBSTEX参照
  96. *  [判定する値]   - passivePBSTEX参照
  97. *
  98. * 例) MP最大時にHPが5%再生するスキルを作成する場合
  99. * <passiveXPBSTEX7:5,MPUP,100>
  100. *
  101. * --------
  102. * ・特定の特殊能力値をアップ(SParameter Boost)
  103. * <passiveSPBST[能力値番号]:[上昇量]>
  104. *  [能力値番号] - 上昇させる特殊能力値の番号を1桁の数値で設定する。(数字)
  105. *                 0 - 狙われ率
  106. *                 1 - 防御効果率
  107. *                 2 - 回復効果率
  108. *                 3 - 薬の知識率
  109. *                 4 - MP消費率
  110. *                 5 - TPチャージ率
  111. *                 6 - 物理ダメージ率
  112. *                 7 - 魔法ダメージ率
  113. *                 8 - 床ダメージ率
  114. *                 9 - 経験値獲得率
  115. *  [上昇量]     - 能力値の上昇量。(数字)
  116. *
  117. * --------
  118. * ・一定の条件下において、特定の追加能力値をアップ(XParameter Boost Ex)
  119. * <passiveSPBSTEX[能力値番号]:[上昇量],[参照する条件],[判定する値]>
  120. *  [能力値番号]   - passiveSPBST参照
  121. *  [上昇量]       - passiveSPBST参照
  122. *  [参照する条件] - passivePBSTEX参照
  123. *  [判定する値]   - passivePBSTEX参照
  124. *
  125. * 例) TPが50%以上の時に狙われやすくするスキルを作成する場合
  126. * <passiveSPBSTEX0:50,TPUP,50>
  127. *
  128. * --------
  129. * ※更新に伴い非推奨 (passivePBSTEXを使用してください)
  130. * ・一定のHP以下の場合のみ特定の通常能力値をアップ(Indomitable)
  131. * <passiveINDM[能力値番号]:[HP残量率],[上昇量(%)]>
  132. *  [能力値番号] - passivePBST参照
  133. *  [HP残量率]   - 効果が発揮されるHPの残量率を%で設定する。(数字)
  134. *  [上昇量(%)]  - 能力値の上昇量。
  135. *                 %ありなら倍率、なしなら直値となる。(数字)
  136. *                 装備なし状態の能力値に対しての倍率がかかる。
  137. *
  138. * --------
  139. * ※更新に伴い非推奨 (passiveXPBSTEXを使用してください)
  140. * ・一定のHP以下の場合のみ特定の追加能力値をアップ(XIndomitable)
  141. * <passiveXINDM[能力値番号]:[HP残量率],[上昇量]>
  142. *  [能力値番号] - passiveXPBST参照
  143. *  [HP残量率]   - 効果が発揮されるHPの残量率を%で設定する。(数字)
  144. *  [上昇量]     - 能力値の上昇量。(数字)
  145. *
  146. * --------
  147. * ※更新に伴い非推奨 (passiveSPBSTEXを使用してください)
  148. * ・一定のHP以下の場合のみ特定の特殊能力値をアップ(SIndomitable)
  149. * <passiveSINDM[能力値番号]:[HP残量率],[上昇量]>
  150. *  [能力値番号] - passiveSPBST参照
  151. *  [HP残量率]   - 効果が発揮されるHPの残量率を%で設定する。(数字)
  152. *  [上昇量]     - 能力値の上昇量。(数字)
  153. *
  154. * --------
  155. * ・属性有効度を設定(Element Rate)
  156. * <passiveELEM[属性番号]:[倍率]>
  157. *  [属性番号] - 有効度を設定する属性の番号を2桁の数値で設定する。(数字)
  158. *  [有効度]   - 有効度を表すパーセンテージ。(数字)
  159. *               職業等で設定されている属性有効度に乗算されます。
  160. *
  161. * --------
  162. * ・ステート有効度を設定(State Rate)
  163. * <passiveSTAT[ステート番号]:[有効度]>
  164. *  [ステート番号] - 耐性を上昇させるステートの番号を4桁の数値で設定する。(数字)
  165. *  [有効度]       - 有効度を表すパーセンテージ。(数字)
  166. *                   職業等で設定されているステート有効度に乗算されます。
  167. *
  168. * --------
  169. * ・無効化できるステートを追加(State Regist)
  170. * <passiveSTREG[ステート番号]>
  171. *  [ステート番号] - 無効化できるステートの番号を4桁の数値で設定する。(数字)
  172. *
  173. * --------
  174. * ・攻撃時ステートを設定(Attack State)
  175. * <passiveATKST[ステート番号]:[付与率]>
  176. *  [ステート番号] - 攻撃時に付与するステートの番号を4桁の数値で設定する。(数字)
  177. *  [付与率]       - 付与率を表すパーセンテージ。(数字)
  178. *                   職業等で設定されているステート付与率に加算されます。
  179. *
  180. * --------
  181. * ・スキルタイプ追加(Add Skill Type)
  182. * <passiveAST[スキルタイプ番号]>
  183. *  [スキルタイプ番号] - スキルタイプの番号を2桁の数値で設定する。(数字)
  184. *
  185. * --------
  186. * ・武器装備時の通常能力値の上昇量をアップ(Weapon Mastery)
  187. * <passiveWPNM[武器タイプ]:[上昇量(%)]>
  188. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  189. *  [上昇量(%)]  - 装備時の能力値の上昇量。
  190. *                 %ありなら倍率、なしなら直値となる。(数字)
  191. *
  192. * --------
  193. * ・武器装備時の追加能力値の上昇量をアップ(Weapon MasteryX)
  194. * <passiveWPNMX[武器タイプ]:[上昇量(%)]>
  195. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  196. *  [上昇量(%)]  - 装備時の能力値の上昇量。
  197. *                 %ありなら倍率、なしなら直値となる。(数字)
  198. *
  199. * --------
  200. * ・武器装備時の特殊能力値の上昇量をアップ(Weapon MasteryS)
  201. * <passiveWPNMS[武器タイプ]:[上昇量(%)]>
  202. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  203. *  [上昇量(%)]  - 装備時の能力値の上昇量。
  204. *                 %ありなら倍率、なしなら直値となる。(数字)
  205. *                 (倍率は100%を基準として計算されます)
  206. *
  207. * --------
  208. * ・武器装備時に特定の通常能力値をアップ(Weapon Parameter Boost)
  209. * <passiveWPBST[武器タイプ]_[能力値番号]:[上昇量]>
  210. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  211. *  [能力値番号] - 上昇させる通常能力値の番号を1桁の数値で設定する。(数字)
  212. *                 0 - HP
  213. *                 1 - MP
  214. *                 2 - 攻撃力
  215. *                 3 - 防御力
  216. *                 4 - 魔法力
  217. *                 5 - 魔法防御
  218. *                 6 - 敏捷性
  219. *                 7 - 運
  220. *  [上昇量]     - 装備時の能力値の上昇量。(数字)
  221. *
  222. * --------
  223. * ・武器装備時に特定の追加能力値をアップ(Weapon XParameter Boost)
  224. * <passiveWXPBST[武器タイプ]_[能力値番号]:[上昇量]>
  225. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  226. *  [能力値番号] - 上昇させる追加能力値の番号を1桁の数値で設定する。(数字)
  227. *                 0 - 命中率
  228. *                 1 - 回避率
  229. *                 2 - 会心率
  230. *                 3 - 会心回避率
  231. *                 4 - 魔法回避率
  232. *                 5 - 魔法反射率
  233. *                 6 - 反撃率
  234. *                 7 - HP再生率
  235. *                 8 - MP再生率
  236. *                 9 - TP再生率
  237. *  [上昇量]     - 装備時の能力値の上昇量。(数字)
  238. *
  239. * --------
  240. * ・武器装備時に特定の特殊能力値をアップ(Weapon SParameter Boost)
  241. * <passiveWSPBST[武器タイプ]_[能力値番号]:[上昇量]>
  242. *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
  243. *  [能力値番号] - 上昇させる特殊能力値の番号を1桁の数値で設定する。(数字)
  244. *                 0 - 狙われ率
  245. *                 1 - 防御効果率
  246. *                 2 - 回復効果率
  247. *                 3 - 薬の知識率
  248. *                 4 - MP消費率
  249. *                 5 - TPチャージ率
  250. *                 6 - 物理ダメージ率
  251. *                 7 - 魔法ダメージ率
  252. *                 8 - 床ダメージ率
  253. *                 9 - 経験値獲得率
  254. *  [上昇量]     - 装備時の能力値の上昇量。(数字)
  255. *
  256. * --------
  257. * ・防具装備時の通常能力値をアップ(Armor Mastery)
  258. * <passiveARMM[防具タイプ]:[上昇量(%)]>
  259. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  260. *  [上昇量(%)]  - 装備時の能力値の上昇量。
  261. *                 %ありなら倍率、なしなら直値となる。(数字)
  262. *
  263. * --------
  264. * ・防具装備時の追加能力値の上昇量をアップ(Armor MasteryX)
  265. * <passiveARMMX[防具タイプ]:[上昇量(%)]>
  266. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  267. *  [上昇量(%)]  - 装備時の能力値の上昇量。
  268. *                 %ありなら倍率、なしなら直値となる。(数字)
  269. *
  270. * --------
  271. * ・防具装備時の特殊能力値の上昇量をアップ(Armor MasteryS)
  272. * <passiveARMMS[防具タイプ]:[上昇量(%)]>
  273. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  274. *  [上昇量(%)]  - 装備時の能力値の上昇量。
  275. *                 %ありなら倍率、なしなら直値となる。(数字)
  276. *                 (倍率は100%を基準として計算されます)
  277. *
  278. * --------
  279. * ・防具装備時に特定の通常能力値をアップ(Armor Parameter Boost)
  280. * <passiveARBST[防具タイプ]_[能力値番号]:[上昇量]>
  281. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  282. *  [能力値番号] - 上昇させる通常能力値の番号を1桁の数値で設定する。(数字)
  283. *                 0 - HP
  284. *                 1 - MP
  285. *                 2 - 攻撃力
  286. *                 3 - 防御力
  287. *                 4 - 魔法力
  288. *                 5 - 魔法防御
  289. *                 6 - 敏捷性
  290. *                 7 - 運
  291. *  [上昇量]     - 装備時の能力値の上昇量。(数字)
  292. *
  293. * --------
  294. * ・防具装備時に特定の追加能力値をアップ(Armor XParameter Boost)
  295. * <passiveAXPBST[防具タイプ]_[能力値番号]:[上昇量]>
  296. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  297. *  [能力値番号] - 上昇させる追加能力値の番号を1桁の数値で設定する。(数字)
  298. *                 0 - 命中率
  299. *                 1 - 回避率
  300. *                 2 - 会心率
  301. *                 3 - 会心回避率
  302. *                 4 - 魔法回避率
  303. *                 5 - 魔法反射率
  304. *                 6 - 反撃率
  305. *                 7 - HP再生率
  306. *                 8 - MP再生率
  307. *                 9 - TP再生率
  308. *  [上昇量]     - 装備時の能力値の上昇量。(数字)
  309. *
  310. * --------
  311. * ・防具装備時に特定の特殊能力値をアップ(Armor SParameter Boost)
  312. * <passiveASPBST[防具タイプ]_[能力値番号]:[上昇量]>
  313. *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
  314. *  [能力値番号] - 上昇させる特殊能力値の番号を1桁の数値で設定する。(数字)
  315. *                 0 - 狙われ率
  316. *                 1 - 防御効果率
  317. *                 2 - 回復効果率
  318. *                 3 - 薬の知識率
  319. *                 4 - MP消費率
  320. *                 5 - TPチャージ率
  321. *                 6 - 物理ダメージ率
  322. *                 7 - 魔法ダメージ率
  323. *                 8 - 床ダメージ率
  324. *                 9 - 経験値獲得率
  325. *  [上昇量]     - 装備時の能力値の上昇量。(数字)
  326. *
  327. * --------
  328. * ・先制攻撃率をアップ(Preemptive)
  329. * <passivePREE:[上昇量]>
  330. *  [上昇量] - 先制攻撃率のアップ率を%で設定する。(数字)
  331. *
  332. * --------
  333. * ・不意打ち率をダウン(Anti Surprise)
  334. * <passiveASUP:[下降量]>
  335. *  [下降量] - 不意打ち率のダウン率を%で設定する。(数字)
  336. *
  337. * --------
  338. * ・二刀流を有効にする(Dual Wield)
  339. * <passiveDUAL>
  340. *
  341. * --------
  342. * ・行動回数を追加する(Action Plus)
  343. * <passiveAPLUS:[追加確率]>
  344. *  [追加確率(%)] - 行動を追加する確率を表すパーセンテージ。(数字)
  345. *
  346. * --------
  347. * ・自動戦闘を有効にする(Auto Battle)
  348. * <passiveAUTO>
  349. *
  350. * --------
  351. * ・防御を有効にする(Guard)
  352. * <passiveGUARD>
  353. *
  354. * --------
  355. * ・身代わり状態にする(Substitute)
  356. * <passiveSUBS>
  357. *
  358. * --------
  359. * ・TP持ち越しを有効にする(Preserve Tp)
  360. * <passivePRETP>
  361. *
  362. */

  363. var Imported = Imported || {};
  364. Imported.dsPassiveSkill = true;

  365. (function (exports) {
  366.         'use strict';

  367.         exports.Param = (function() {
  368.                 var ret = {};
  369.                 var parameters = PluginManager.parameters('dsPassiveSkill');
  370.                 ret.ShowBattle = Boolean(parameters['Show Battle'] === 'true' || false);
  371.                 ret.ShowBattleSwitchId = Number(parameters['Show Battle Switch ID']);
  372.                 return ret;
  373.         })();

  374.         //--------------------------------------------------------------------------
  375.         /** Utility */
  376.         function Utility() {}

  377.         Utility.calcParamBoost = function(baseParam, metaData)
  378.         {
  379.                 var ret = 0;
  380.                 var re = /([-]?\d+)(%?)/i;
  381.                 var match = re.exec(metaData);
  382.                 if ( match )
  383.                 {
  384.                         if ( match[2] === '%' )
  385.                         {
  386.                                 var rate = Number(match[1]) * 0.01;
  387.                                 ret = Math.floor(baseParam * rate);
  388.                         }
  389.                         else
  390.                         {
  391.                                 ret = Number(match[1]);
  392.                         }
  393.                 }
  394.                 return ret;
  395.         };

  396.         Utility.calcXParamBoost = function(metaData)
  397.         {
  398.                 var ret = 0;
  399.                 var re = /([-]?\d+)/i;
  400.                 var match = re.exec(metaData);
  401.                 if ( match )
  402.                 {
  403.                         ret = Number(match[1]) * 0.01;
  404.                 }
  405.                 return ret;
  406.         };

  407.         Utility.calcSParamBoost = function(metaData)
  408.         {
  409.                 var ret = 0;
  410.                 var re = /([-]?\d+)/i;
  411.                 var match = re.exec(metaData);
  412.                 if ( match )
  413.                 {
  414.                         ret = Number(match[1]) * 0.01;
  415.                 }
  416.                 return ret;
  417.         };

  418.         Utility.calcMastery = function(baseParam, metaData)
  419.         {
  420.                 var ret = 0;
  421.                 var re = /([-]?\d+)(%?)/i;
  422.                 var match = re.exec(metaData);
  423.                 if ( match )
  424.                 {
  425.                         if ( match[2] === '%' )
  426.                         {
  427.                                 var rate = Number(match[1]) * 0.01;
  428.                                 ret = Math.floor(baseParam * rate);
  429.                         }
  430.                         else
  431.                         {
  432.                                 ret = Number(match[1]);
  433.                         }
  434.                 }
  435.                 return ret;
  436.         };

  437.         Utility.calcMasteryX = function(baseParam, metaData)
  438.         {
  439.                 var ret = 0;
  440.                 var re = /([-]?\d+)(%?)/i;
  441.                 var match = re.exec(metaData);
  442.                 if ( match )
  443.                 {
  444.                         if ( match[2] === '%' )
  445.                         {
  446.                                 var rate = Number(match[1]) * 0.01;
  447.                                 ret = baseParam * rate;
  448.                         }
  449.                         else
  450.                         {
  451.                                 ret = Number(match[1]);
  452.                         }
  453.                 }
  454.                 return ret;
  455.         };

  456.         Utility.calcMasteryS = function(baseParam, metaData)
  457.         {
  458.                 var ret = 0;
  459.                 var re = /([-]?\d+)(%?)/i;
  460.                 var match = re.exec(metaData);
  461.                 if ( match )
  462.                 {
  463.                         if ( match[2] === '%' )
  464.                         {
  465.                                 var rate = Number(match[1]) * 0.01;
  466.                                 ret = (baseParam-1.0) * rate;
  467.                         }
  468.                         else
  469.                         {
  470.                                 ret = Number(match[1]);
  471.                         }
  472.                 }
  473.                 return ret;
  474.         };

  475.         //--------------------------------------------------------------------------
  476.         /** Game_Actor */
  477.         var _Game_Actor_initMembers = Game_Actor.prototype.initMembers;
  478.         Game_Actor.prototype.refreshSkillTypes = function()
  479.         {
  480.                 _Game_Actor_initMembers.call(this);
  481.                 this._psSkillTypes = [];
  482.         };

  483.         Game_Actor.prototype.refreshSkillTypes = function()
  484.         {
  485.                 this._psSkillTypes = [];
  486.                 var skillTypesMax = $dataSystem.skillTypes.length;
  487.                 for ( var ii = 1; ii < skillTypesMax; ii++ )
  488.                 {
  489.                         var tag = 'passiveAST' + ('00'+ii).slice(-2);
  490.                         var find = false;
  491.                         this.iteratePassiveSkill(tag, function(metaData) {
  492.                                 find = true;
  493.                         });
  494.                         if ( find )
  495.                         {
  496.                                 this._psSkillTypes.push(ii);
  497.                         }
  498.                 }
  499.         };

  500.         var _Game_Actor_refresh = Game_Actor.prototype.refresh;
  501.         Game_Actor.prototype.refresh = function()
  502.         {
  503.                 _Game_Actor_refresh.call(this);
  504.                 this.refreshSkillTypes();
  505.         };

  506.         var _Game_Actor_learnSkill = Game_Actor.prototype.learnSkill;
  507.         Game_Actor.prototype.learnSkill = function(skillId)
  508.         {
  509.                 var lastDualWield = this.isDualWield();
  510.                 _Game_Actor_learnSkill.call(this, skillId);
  511.                 if ( lastDualWield !== this.isDualWield() )
  512.                 {
  513.                         this.refresh();
  514.                 }
  515.                 this.refreshSkillTypes();
  516.         };

  517.         Game_Actor.prototype.iteratePassiveSkill = function(metaName, callback)
  518.         {
  519.                 this.skills().forEach(function(skill) {
  520.                         if ( skill.meta[metaName] )
  521.                         {
  522.                                 callback(skill.meta[metaName]);
  523.                         }
  524.                 });
  525.         };

  526.         Game_Actor.prototype.evaluateCondition = function(condition, value)
  527.         {
  528.                 var ret = false;
  529.                 switch ( condition )
  530.                 {
  531.                 case 'HPUP': ret = (this.hpRate() >= value * 0.01) ? true : false; break;
  532.                 case 'HPLW': ret = (this.hpRate() <= value * 0.01) ? true : false; break;
  533.                 case 'MPUP': ret = (this.mpRate() >= value * 0.01) ? true : false; break;
  534.                 case 'MPLW': ret = (this.mpRate() <= value * 0.01) ? true : false; break;
  535.                 case 'TPUP': ret = (this.tpRate() >= value * 0.01) ? true : false; break;
  536.                 case 'TPLW': ret = (this.tpRate() <= value * 0.01) ? true : false; break;
  537.                 case 'STAT': ret = this.isStateAffected(value);                    break;
  538.                 }
  539.                 return ret;
  540.         };

  541.         Game_Actor.prototype.itemTraitsWithId = function(item, code, dataId)
  542.         {
  543.                 return item.traits.filter(function(trait) {
  544.                         return trait.code === code && trait.dataId === dataId;
  545.                 });
  546.         };

  547.         Game_Actor.prototype.itemTraitsSum = function(item, code, id)
  548.         {
  549.                 return this.itemTraitsWithId(item, code, id).reduce(function(r, trait) {
  550.                         return r + trait.value;
  551.                 }, 0);
  552.         };

  553.         var _Game_Actor_paramBase = Game_Actor.prototype.paramBase;
  554.         Game_Actor.prototype.paramBaseDirect = function(paramId)
  555.         {
  556.                 return _Game_Actor_paramBase.call(this, paramId);
  557.         };

  558.         Game_Actor.prototype.paramBaseBoost = function(paramId)
  559.         {
  560.                 var baseParam = this.paramBaseDirect(paramId);
  561.                 var ret = 0;
  562.                 var tagPBST = 'passivePBST' + ('0'+paramId).slice(-1);
  563.                 this.iteratePassiveSkill(tagPBST, function(metaData) {
  564.                         ret += Utility.calcParamBoost(baseParam, metaData);
  565.                 });
  566.                 var tagPBSTEX = 'passivePBSTEX' + ('0'+paramId).slice(-1);
  567.                 this.iteratePassiveSkill(tagPBSTEX, function(metaData) {
  568.                         var splitData = metaData.split(',');
  569.                         if ( this.evaluateCondition(splitData[1], Number(splitData[2])) )
  570.                         {
  571.                                 ret += Utility.calcParamBoost(baseParam, splitData[0]);
  572.                         }
  573.                 }.bind(this));
  574.                 var tagINDM = 'passiveINDM' + ('0'+paramId).slice(-1);
  575.                 this.iteratePassiveSkill(tagINDM, function(metaData) {
  576.                         var re = /(\d+)\,([-]?\d+)(%?)/i;
  577.                         var match = re.exec(metaData);
  578.                         if ( match )
  579.                         {
  580.                                 if ( this.hpRate() <= Number(match[1]) * 0.01 )
  581.                                 {
  582.                                         if ( match[3] === '%' )
  583.                                         {
  584.                                                 var rate = Number(match[2]) * 0.01;
  585.                                                 ret += Math.floor(baseParam * rate);
  586.                                         }
  587.                                         else
  588.                                         {
  589.                                                 ret += Number(match[2]);
  590.                                         }
  591.                                 }
  592.                         }
  593.                 }.bind(this));
  594.                 return ret;
  595.         };

  596.         Game_Actor.prototype.paramBase = function(paramId)
  597.         {
  598.                 var ret = this.paramBaseDirect(paramId);
  599.                 ret += this.paramBaseBoost(paramId);
  600.                 return ret;
  601.         };

  602.         var _Game_Actor_paramPlus = Game_Actor.prototype.paramPlus;
  603.         Game_Actor.prototype.paramPlusDirect = function(paramId)
  604.         {
  605.                 return _Game_Actor_paramPlus.call(this, paramId);
  606.         };

  607.         Game_Actor.prototype.paramPlusBoost = function(paramId)
  608.         {
  609.                 var ret = 0;
  610.                 this.equips().forEach(function(item) {
  611.                         if ( item )
  612.                         {
  613.                                 if ( DataManager.isWeapon(item) )
  614.                                 {
  615.                                         if ( item.params[paramId] > 0 )
  616.                                         {
  617.                                                 var tagWPNM = 'passiveWPNM' + ('00'+item.wtypeId).slice(-2);
  618.                                                 this.iteratePassiveSkill(tagWPNM, function(metaData) {
  619.                                                         ret += Utility.calcMastery(item.params[paramId], metaData);
  620.                                                 });
  621.                                         }
  622.                                         var tagWPBST = 'passiveWPBST' + ('00'+item.wtypeId).slice(-2) + '_' + paramId;
  623.                                         this.iteratePassiveSkill(tagWPBST, function(metaData) {
  624.                                                 ret += Number(metaData);
  625.                                         });
  626.                                 }
  627.                                 else if ( DataManager.isArmor(item) )
  628.                                 {
  629.                                         if ( item.params[paramId] > 0 )
  630.                                         {
  631.                                                 var tagARMM = 'passiveARMM' + ('00'+item.atypeId).slice(-2);
  632.                                                 this.iteratePassiveSkill(tagARMM, function(metaData) {
  633.                                                         ret += Utility.calcMastery(item.params[paramId], metaData);
  634.                                                 });
  635.                                         }
  636.                                         var tagAPBST = 'passiveAPBST' + ('00'+item.atypeId).slice(-2) + '_' + paramId;
  637.                                         this.iteratePassiveSkill(tagAPBST, function(metaData) {
  638.                                                 ret += Number(metaData);
  639.                                         });
  640.                                 }
  641.                         }
  642.                 }, this);
  643.                 return ret;
  644.         };

  645.         Game_Actor.prototype.paramPlus = function(paramId)
  646.         {
  647.                 var ret = this.paramPlusDirect(paramId);
  648.                 ret += this.paramPlusBoost(paramId);
  649.                 return ret;
  650.         };

  651.         var _Game_Actor_xparam = Game_Actor.prototype.xparam;
  652.         Game_Actor.prototype.xparamDirect = function(xparamId)
  653.         {
  654.                 return _Game_Actor_xparam.call(this, xparamId);
  655.         };

  656.         Game_Actor.prototype.xparam = function(xparamId)
  657.         {
  658.                 var ret = this.xparamDirect(xparamId);
  659.                 var tagPBST = 'passiveXPBST' + ('0'+xparamId).slice(-1);
  660.                 this.iteratePassiveSkill(tagPBST, function(metaData) {
  661.                         ret += Utility.calcXParamBoost(metaData);
  662.                 });
  663.                 var tagPBSTEX = 'passiveXPBSTEX' + ('0'+xparamId).slice(-1);
  664.                 this.iteratePassiveSkill(tagPBSTEX, function(metaData) {
  665.                         var splitData = metaData.split(',');
  666.                         if ( this.evaluateCondition(splitData[1], Number(splitData[2])) )
  667.                         {
  668.                                 ret += Utility.calcXParamBoost(splitData[0]);
  669.                         }
  670.                 }.bind(this));
  671.                 var tagINDM = 'passiveXINDM' + ('0'+xparamId).slice(-1);
  672.                 this.iteratePassiveSkill(tagINDM, function(metaData) {
  673.                         var re = /(\d+)\,([-]?\d+)/i;
  674.                         var match = re.exec(metaData);
  675.                         if ( match )
  676.                         {
  677.                                 if ( this.hpRate() <= Number(match[1]) * 0.01 )
  678.                                 {
  679.                                         ret += Number(match[2]) * 0.01;
  680.                                 }
  681.                         }
  682.                 }.bind(this));
  683.                 this.equips().forEach(function(item) {
  684.                         if ( item )
  685.                         {
  686.                                 var value = this.itemTraitsSum(item, Game_BattlerBase.TRAIT_XPARAM, xparamId);
  687.                                 if ( DataManager.isWeapon(item) )
  688.                                 {
  689.                                         if ( value > 0 )
  690.                                         {
  691.                                                 var tagWPNMX = 'passiveWPNMX' + ('00'+item.wtypeId).slice(-2);
  692.                                                 this.iteratePassiveSkill(tagWPNMX, function(metaData) {
  693.                                                         ret += Utility.calcMasteryX(value, metaData);
  694.                                                 });
  695.                                         }
  696.                                         var tagWPBST = 'passiveWXPBST' + ('00'+item.wtypeId).slice(-2) + '_' + xparamId;
  697.                                         this.iteratePassiveSkill(tagWPBST, function(metaData) {
  698.                                                 ret += Number(metaData) * 0.01;
  699.                                         });
  700.                                 }
  701.                                 else if ( DataManager.isArmor(item) )
  702.                                 {
  703.                                         if ( value > 0 )
  704.                                         {
  705.                                                 var tagARMMX = 'passiveARMMX' + ('00'+item.atypeId).slice(-2);
  706.                                                 this.iteratePassiveSkill(tagARMMX, function(metaData) {
  707.                                                         ret += Utility.calcMasteryX(value, metaData);
  708.                                                 });
  709.                                         }
  710.                                         var tagAPBST = 'passiveAXPBST' + ('00'+item.atypeId).slice(-2) + '_' + xparamId;
  711.                                         this.iteratePassiveSkill(tagAPBST, function(metaData) {
  712.                                                 ret += Number(metaData) * 0.01;
  713.                                         });
  714.                                 }
  715.                         }
  716.                 }, this);
  717.                 return ret;
  718.         };

  719.         var _Game_Actor_sparam = Game_Actor.prototype.sparam;
  720.         Game_Actor.prototype.sparamDirect = function(sparamId)
  721.         {
  722.                 return _Game_Actor_sparam.call(this, sparamId);
  723.         };

  724.         Game_Actor.prototype.sparam = function(sparamId)
  725.         {
  726.                 var ret = this.sparamDirect(sparamId);
  727.                 var tagPBST = 'passiveSPBST' + ('0'+sparamId).slice(-1);
  728.                 this.iteratePassiveSkill(tagPBST, function(metaData) {
  729.                         ret += Utility.calcSParamBoost(metaData);
  730.                 });
  731.                 var tagPBSTEX = 'passiveSPBSTEX' + ('0'+sparamId).slice(-1);
  732.                 this.iteratePassiveSkill(tagPBSTEX, function(metaData) {
  733.                         var splitData = metaData.split(',');
  734.                         if ( this.evaluateCondition(splitData[1], Number(splitData[2])) )
  735.                         {
  736.                                 ret += Utility.calcSParamBoost(splitData[0]);
  737.                         }
  738.                 }.bind(this));
  739.                 var tagINDM = 'passiveSINDM' + ('0'+sparamId).slice(-1);
  740.                 this.iteratePassiveSkill(tagINDM, function(metaData) {
  741.                         var re = /(\d+)\,([-]?\d+)/i;
  742.                         var match = re.exec(metaData);
  743.                         if ( match )
  744.                         {
  745.                                 if ( this.hpRate() <= Number(match[1]) * 0.01 )
  746.                                 {
  747.                                         ret += Number(match[2]) * 0.01;
  748.                                 }
  749.                         }
  750.                 }.bind(this));
  751.                 this.equips().forEach(function(item) {
  752.                         if ( item )
  753.                         {
  754.                                 var value = this.itemTraitsSum(item, Game_BattlerBase.TRAIT_SPARAM, sparamId);
  755.                                 if ( DataManager.isWeapon(item) )
  756.                                 {
  757.                                         if ( value > 0 )
  758.                                         {
  759.                                                 var tagWPNMS = 'passiveWPNMS' + ('00'+item.wtypeId).slice(-2);
  760.                                                 this.iteratePassiveSkill(tagWPNMS, function(metaData) {
  761.                                                         ret += Utility.calcMasteryS(value, metaData);
  762.                                                 });
  763.                                         }
  764.                                         var tagWPBST = 'passiveWSPBST' + ('00'+item.wtypeId).slice(-2) + '_' + sparamId;
  765.                                         this.iteratePassiveSkill(tagWPBST, function(metaData) {
  766.                                                 ret += Number(metaData) * 0.01;
  767.                                         });
  768.                                 }
  769.                                 else if ( DataManager.isArmor(item) )
  770.                                 {
  771.                                         if ( value > 0 )
  772.                                         {
  773.                                                 var tagARMMS = 'passiveARMMS' + ('00'+item.atypeId).slice(-2);
  774.                                                 this.iteratePassiveSkill(tagARMMS, function(metaData) {
  775.                                                         ret += Utility.calcMasteryS(value, metaData);
  776.                                                 });
  777.                                         }
  778.                                         var tagAPBST = 'passiveASPBST' + ('00'+item.atypeId).slice(-2) + '_' + sparamId;
  779.                                         this.iteratePassiveSkill(tagAPBST, function(metaData) {
  780.                                                 ret += Number(metaData) * 0.01;
  781.                                         });
  782.                                 }
  783.                         }
  784.                 }, this);
  785.                 return ret;
  786.         };

  787.         var _Game_Actor_elementRate = Game_Actor.prototype.elementRate;
  788.         Game_Actor.prototype.elementRate = function(elementId)
  789.         {
  790.                 var ret = _Game_Actor_elementRate.call(this, elementId);
  791.                 var tag = 'passiveELEM' + ('00'+elementId).slice(-2);
  792.                 this.iteratePassiveSkill(tag, function(metaData) {
  793.                         var re = /([-]?\d+)/i;
  794.                         var match = re.exec(metaData);
  795.                         if ( match )
  796.                         {
  797.                                 ret *= Number(match[1]) * 0.01;
  798.                         }
  799.                 });
  800.                 return ret;
  801.         };

  802.         var _Game_Actor_stateRate = Game_Actor.prototype.stateRate;
  803.         Game_Actor.prototype.stateRate = function(stateId)
  804.         {
  805.                 var ret = _Game_Actor_stateRate.call(this, stateId);
  806.                 var tag = 'passiveSTAT' + ('0000'+stateId).slice(-4);
  807.                 this.iteratePassiveSkill(tag, function(metaData) {
  808.                         var re = /([-]?\d+)/i;
  809.                         var match = re.exec(metaData);
  810.                         if ( match )
  811.                         {
  812.                                 ret *= Number(match[1]) * 0.01;
  813.                         }
  814.                 });
  815.                 return ret;
  816.         };

  817.         var _Game_Actor_stateResistSet = Game_Actor.prototype.stateResistSet;
  818.         Game_Actor.prototype.stateResistSet = function()
  819.         {
  820.                 var ret = _Game_Actor_stateResistSet.call(this);
  821.                 var num = $dataStates.length;
  822.                 for ( var ii = 1; ii < num; ii++ )
  823.                 {
  824.                         var tag = 'passiveSTREG' + ('0000'+ii).slice(-4);
  825.                         this.iteratePassiveSkill(tag, function(metaData) {
  826.                                 if ( !ret.contains(ii) )
  827.                                 {
  828.                                         ret.push(ii);
  829.                                 }
  830.                         });
  831.                 }
  832.                 return ret;
  833.         };

  834.         var _Game_Actor_attackStates = Game_Actor.prototype.attackStates;
  835.         Game_Actor.prototype.attackStates = function()
  836.         {
  837.                 var ret = _Game_Actor_attackStates.call(this);
  838.                 var num = $dataStates.length;
  839.                 for ( var ii = 1; ii < num; ii++ )
  840.                 {
  841.                         var tag = 'passiveATKST' + ('0000'+ii).slice(-4);
  842.                         this.iteratePassiveSkill(tag, function(metaData) {
  843.                                 if ( !ret.contains(ii) )
  844.                                 {
  845.                                         ret.push(ii);
  846.                                 }
  847.                         });
  848.                 }
  849.                 return ret;
  850.         };

  851.         var _Game_Actor_attackStatesRate = Game_Actor.prototype.attackStatesRate;
  852.         Game_Actor.prototype.attackStatesRate = function(stateId)
  853.         {
  854.                 var ret = _Game_Actor_attackStatesRate.call(this, stateId);
  855.                 var tag = 'passiveATKST' + ('0000'+stateId).slice(-4);
  856.                 this.iteratePassiveSkill(tag, function(metaData) {
  857.                         var re = /([-]?\d+)/i;
  858.                         var match = re.exec(metaData);
  859.                         if ( match )
  860.                         {
  861.                                 ret += Number(match[1]) * 0.01;
  862.                         }
  863.                 });
  864.                 return ret;
  865.         };

  866.         var _Game_Actor_addedSkillTypes = Game_Actor.prototype.addedSkillTypes;
  867.         Game_Actor.prototype.addedSkillTypes = function()
  868.         {
  869.                 var ret = _Game_Actor_addedSkillTypes.call(this);
  870.                 if ( this._psSkillTypes )
  871.                 {
  872.                         this._psSkillTypes.forEach(function(stype) {
  873.                                 if ( ret.indexOf(stype) < 0 )
  874.                                 {
  875.                                         ret.push(stype);
  876.                                 }
  877.                         });
  878.                 }
  879.                 return ret;
  880.         };

  881.         var _Game_Actor_isEquipWtypeOk = Game_Actor.prototype.isEquipWtypeOk;
  882.         Game_Actor.prototype.isEquipWtypeOk = function(wtypeId)
  883.         {
  884.                 var ret = _Game_Actor_isEquipWtypeOk.call(this, wtypeId);
  885.                 var tag = 'passiveEWPN' + ('00'+wtypeId).slice(-2);
  886.                 this.iteratePassiveSkill(tag, function(metaData) {
  887.                         ret = true;
  888.                 });
  889.                 return ret;
  890.         };

  891.         var _Game_Actor_isEquipAtypeOk = Game_Actor.prototype.isEquipAtypeOk;
  892.         Game_Actor.prototype.isEquipAtypeOk = function(atypeId)
  893.         {
  894.                 var ret = _Game_Actor_isEquipAtypeOk.call(this, atypeId);
  895.                 var tag = 'passiveEARM' + ('00'+atypeId).slice(-2);
  896.                 this.iteratePassiveSkill(tag , function(metaData) {
  897.                         ret = true;
  898.                 });
  899.                 return ret;
  900.         };

  901.         var _Game_Actor_isDualWield = Game_Actor.prototype.isDualWield;
  902.         Game_BattlerBase.prototype.isDualWield = function()
  903.         {
  904.                 var ret = _Game_Actor_isDualWield.call(this);
  905.                 var tag = 'passiveDUAL';
  906.                 this.iteratePassiveSkill(tag, function(metaData) {
  907.                         ret = true;
  908.                 });
  909.                 return ret;
  910.         };

  911.         var _Game_Actor_actionPlusSet = Game_Actor.prototype.actionPlusSet;
  912.         Game_Actor.prototype.actionPlusSet = function()
  913.         {
  914.                 var ret = _Game_Actor_actionPlusSet.call(this);
  915.                 var tag = 'passiveAPLUS';
  916.                 this.iteratePassiveSkill(tag, function(metaData) {
  917.                         var re = /(\d+)/i;
  918.                         var match = re.exec(metaData);
  919.                         if ( match )
  920.                         {
  921.                                 ret.push(Number(match[1]) * 0.01);
  922.                         }
  923.                 });
  924.                 return ret;
  925.         };

  926.         var _Game_Actor_isAutoBattle = Game_Actor.prototype.isAutoBattle;
  927.         Game_Actor.prototype.isAutoBattle = function()
  928.         {
  929.                 var ret = _Game_Actor_isAutoBattle.call(this);
  930.                 var tag = 'passiveAUTO';
  931.                 this.iteratePassiveSkill(tag, function(metaData) {
  932.                         ret = true;
  933.                 });
  934.                 return ret;
  935.         };

  936.         var _Game_Actor_isGuard = Game_Actor.prototype.isGuard;
  937.         Game_Actor.prototype.isGuard = function()
  938.         {
  939.                 var ret = _Game_Actor_isGuard.call(this);
  940.                 if ( this.canMove() )
  941.                 {
  942.                         var tag = 'passiveGUARD';
  943.                         this.iteratePassiveSkill(tag, function(metaData) {
  944.                                 ret = true;
  945.                         });
  946.                 }
  947.                 return ret;
  948.         };

  949.         var _Game_Actor_isSubstitute = Game_Actor.prototype.isSubstitute;
  950.         Game_Actor.prototype.isSubstitute = function()
  951.         {
  952.                 var ret = _Game_Actor_isSubstitute.call(this);
  953.                 if ( this.canMove() )
  954.                 {
  955.                         var tag = 'passiveSUBS';
  956.                         this.iteratePassiveSkill(tag, function(metaData) {
  957.                                 ret = true;
  958.                         });
  959.                 }
  960.                 return ret;
  961.         };

  962.         var _Game_Actor_isPreserveTp = Game_Actor.prototype.isPreserveTp;
  963.         Game_Actor.prototype.isPreserveTp = function(flagId)
  964.         {
  965.                 var ret = _Game_Actor_isPreserveTp.call(this);
  966.                 var tag = 'passivePRETP';
  967.                 this.iteratePassiveSkill(tag, function(metaData) {
  968.                         ret = true;
  969.                 });
  970.                 return ret;
  971.         };

  972.         //--------------------------------------------------------------------------
  973.         /** Game_Party */
  974.         var _Game_Party_ratePreemptive = Game_Party.prototype.ratePreemptive;
  975.         Game_Party.prototype.ratePreemptive = function(troopAgi)
  976.         {
  977.                 var rate = _Game_Party_ratePreemptive.call(this, troopAgi);
  978.                 this.battleMembers().some(function(actor) {
  979.                         actor.iteratePassiveSkill('passivePREE', function(metaData) {
  980.                                 rate += Number(metaData) * 0.01;
  981.                         });
  982.                 });
  983.                 return rate.clamp(0.0, 1.0);
  984.         };

  985.         var _Game_Party_rateSurprise = Game_Party.prototype.rateSurprise;
  986.         Game_Party.prototype.rateSurprise = function(troopAgi)
  987.         {
  988.                 var rate = _Game_Party_rateSurprise.call(this, troopAgi);
  989.                 this.battleMembers().some(function(actor) {
  990.                         actor.iteratePassiveSkill('passiveASUP', function(metaData) {
  991.                                 rate -= Number(metaData) * 0.01 * rate;
  992.                         });
  993.                 });
  994.                 return rate.clamp(0.0, 1.0);
  995.         };

  996.         //--------------------------------------------------------------------------
  997.         /** Window_BattleSkill */
  998.         var _Window_BattleSkill_includes = Window_BattleSkill.prototype.includes;
  999.         Window_BattleSkill.prototype.includes = function(item)
  1000.         {
  1001.                 if ( !this.showPassiveSkill() )
  1002.                 {
  1003.                         if ( item )
  1004.                         {
  1005.                                 var re = /<passive/;
  1006.                                 if ( re.test(item.note) )
  1007.                                 {
  1008.                                         return false;
  1009.                                 }
  1010.                         }
  1011.                 }
  1012.                 return _Window_BattleSkill_includes.call(this, item);
  1013.         };

  1014.         Window_BattleSkill.prototype.showPassiveSkill = function()
  1015.         {
  1016.                 if ( exports.Param.ShowBattleSwitchId > 0 )
  1017.                 {
  1018.                         return $gameSwitches.value(exports.Param.ShowBattleSwitchId);
  1019.                 }
  1020.                 else
  1021.                 {
  1022.                         return exports.Param.ShowBattle;
  1023.                 }
  1024.         };

  1025. }((this.dsPassiveSkill = this.dsPassiveSkill || {})));
复制代码
回复

使用道具 举报

梦石
0
星屑
6814
在线时间
461 小时
注册时间
2012-2-19
回帖
37
发表于 2019-9-2 12:46:28 | 显示全部楼层
这插件跟yep的某个插件冲突了,不生效

点评

发现不管说什么只要配上滑稽的头像,感觉就像在开玩笑,哈哈哈  发表于 2019-9-2 17:35
回复

使用道具 举报

梦石
0
星屑
206
在线时间
27 小时
注册时间
2019-6-13
回帖
25
发表于 2020-3-8 13:47:41 | 显示全部楼层
说实话 有点没看懂怎用
回复

使用道具 举报

梦石
0
星屑
89
在线时间
11 小时
注册时间
2020-3-21
回帖
10
发表于 2020-3-21 19:04:21 | 显示全部楼层
谢谢,正要找这个
回复

使用道具 举报

梦石
0
星屑
576
在线时间
234 小时
注册时间
2015-7-21
回帖
24
发表于 2020-4-23 21:54:48 | 显示全部楼层
请问这个插件不卡吧?比YEP的被动更好吗
回复

使用道具 举报

梦石
0
星屑
17
在线时间
5 小时
注册时间
2020-8-2
回帖
16
发表于 2020-8-5 13:03:50 | 显示全部楼层
6666感谢
回复

使用道具 举报

梦石
0
星屑
68
在线时间
6 小时
注册时间
2020-9-21
回帖
5
发表于 2020-12-31 15:24:19 | 显示全部楼层
谢谢分享
回复

使用道具 举报

梦石
0
星屑
103
在线时间
12 小时
注册时间
2020-5-20
回帖
24
发表于 2021-1-18 21:59:06 | 显示全部楼层
谢谢分享
回复

使用道具 举报

梦石
0
星屑
218
在线时间
23 小时
注册时间
2021-1-10
回帖
9
发表于 2021-1-24 05:48:16 | 显示全部楼层
passiveATKST这个效果貌似只能普通攻击时候附带效果诶,有没有技能也能用的?
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册会员

本版积分规则

Powered by Discuz! X5.0 © 2001-2026 Discuz! Team.

在本版发帖返回顶部