设为首页收藏本站|繁體中文
开启辅助访问

Project1

 找回密码
 注册会员
新版主页
搜索
Project1»广场 › 技术讨论 › RPG Maker VX 讨论区 › 请高手给我个横版脚本
返回列表 发新帖
查看: 1693|回复: 3
打印 上一主题 下一主题

[已经过期] 请高手给我个横版脚本

[复制链接]
灵の楠楠

Lv1.梦旅人

梦石
0
星屑
50
在线时间
45 小时
注册时间
2012-1-17
帖子
53
跳转到指定楼层
1楼
发表于 2012-1-17 15:06:48 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
我是个新手，请高手多多指教
我希望大家能给我个横版战斗脚本，谢谢:loveliness:
回复

使用道具 举报

寂静的夜里

Lv4.逐梦者 (版主)

职业の水客

梦石
0
星屑
14148
在线时间
7223 小时
注册时间
2010-6-16
帖子
3499

开拓者
2楼
发表于 2012-1-17 15:10:27 | 只看该作者
http://rpg.blue/thread-110309-1-1.html
http://rpg.blue/thread-94289-1-1.html
善用搜索
一个看图的地方
群爆炸重建后状态：论坛老人最多（只剩下了活跃的老人），技术力很强（依旧不变）的编程灌水群：901540785
专门讨论RM相关的Q群：56875149
PS：第一个群不是专门讨论RM的，第二个才是哦。
回复

使用道具 举报

灵の楠楠

Lv1.梦旅人

梦石
0
星屑
50
在线时间
45 小时
注册时间
2012-1-17
帖子
53
3楼
 楼主| 发表于 2012-1-17 15:43:43 | 只看该作者
本帖最后由 灵の楠楠 于 2012-1-17 16:47 编辑

…………………………………………



那里的东西都打不开，有没有详细一点的


──灵の楠楠于2012-1-17 16:48补充内容：
回复

使用道具 举报

锐·小杜

Lv1.梦旅人

梦石
0
星屑
137
在线时间
464 小时
注册时间
2012-1-16
帖子
1227
4楼
发表于 2012-1-17 21:33:32 | 只看该作者

本脚本来自  妖精图书馆

首先，把下面这个脚本放到  ▼ 外来RGSS插件脚本素材  的下面。

取名为               系统设定
  1. ==============================================================================
  2. # ■ module N01 Ver2.6
  3. # 汉化by约束
  4. #
  5. #作者 RPG探险队
  6. #
  7. #原版的網址 http://rpgex.sakura.ne.jp/home/sozai/sozai_top.html#VXブー
  8. #
  9. #版本 SideView2.7 for VX
  10. #
  11. #版權聲明 RPGツクールVXとXPのスクリプト素材。利用規約ナッシング。
  12. # 著作権もサポートも無いものとお考えください。使用は自己責任でお願いします。
  13. # （没有规定－＝）
  14. #------------------------------------------------------------------------------
  15. # 　横版战斗系统设定项目。
  16. #==============================================================================
  17. module N01
  18. #--------------------------------------------------------------------------
  19. # ● 设定
  20. #--------------------------------------------------------------------------
  21. # 主人公初期位置　第一人 第二人 第三人 第四人
  22. # X轴 Y轴 X轴 Y轴 X轴 Y轴 X轴 Y轴
  23. ACTOR_POSITION = [[415,120],[435,150],[455,180],[475,210]]
  24. # 战斗成员最大数(可改动人数) 当人数变动时，上方的坐标也要相应变动
  25. MAX_MEMBER = 4

  27. # 战斗中行动结束后、到下个角色行动开始之间的等待时间。
  28. ACTION_WAIT = 10
  29. # 敌方溃败(被击破时的退场)前的等待时间
  30. COLLAPSE_WAIT = 12
  31. # 胜利前的等待时间
  32. WIN_WAIT = 70

  34. # 战斗背景在画面中位置的设定 FLOOR = [ X轴, Y轴, 透明度]
  35. FLOOR = [ 0, 96,128]
  36. # 未装备武器地情况下攻击时显示的动画ID
  37. NO_WEAPON = 82
  38. # 二刀流设定 当双手装备武器时一次攻击的伤害数值。数值为%
  39. # 　 通常攻击 技能、物品
  40. TWO_SWORDS_STYLE = [ 50, 100]
  41. # 状态扩张・自动复活的动画ID
  42. RESURRECTION = 41
  43. # 使用吸收攻击对象的HP回复时，对吸收者造成伤害是true
  44. ABSORB_DAMAGE = true

  46. # 伤害数字图片的文件名(横向等距的从零到九依次排列的图片)
  47. DAMAGE_GRAPHICS = "Number+"
  48. # 回复数字图片的文件名
  49. RECOVER_GRAPHICS = "Number-"
  50. # 显示数值时的文字间隔
  51. NUM_INTERBAL = -3
  52. # 显示数值时的显示时间
  53. NUM_DURATION = 68
  54. # 伤害窗口关闭、只显示文字时的情况是true
  55. NON_DAMAGE_WINDOW = false
  56. # 伤害窗口中所显示的词语。如果不想显示的情况请""这样消除掉引号中内容即可。
  57. POP_DAMAGE0 = "" # 伤害数值为0时(数字0将不被显示)
  58. POP_MISS = "miss！" # 攻击因攻击者原因没有击中时　
  59. POP_EVA = "回避！" # 攻击因被被攻击者躲开时　
  60. POP_CRI = "会心一击！" # 会心一击手机
  61. POP_MP_DAM = "伤害MP" # 受到MP的伤害时
  62. POP_MP_REC = "回复MP" # 回复MP时

  64. # 阴影效果　使用的话是true不使用时是false
  65. SHADOW = true
  66. # 识别步行效果　在战斗中人物使用步行效果的话是true不使用时是false
  67. # false的情况下、一定要使用自己的行走图，不要使用脚本范例中的。
  68. # 还有，No1之后的图片大小要统一(不是全人物统一，单一人物的统一即可)
  69. WALK_ANIME = true
  70. # 角色战斗图中用图的动画动作格数（横分割数）
  71. ANIME_PATTERN = 3
  72. # 角色战斗图中用图的动画种类数（纵分割数）
  73. ANIME_KIND = 4

  75. # 背后攻击(偷袭时的画面反转)　使用的话是true不使用的是false
  76. BACK_ATTACK = true
  77. # 背后攻击时战斗背景不反转的情况是false
  78. BACK_ATTACK_NON_BACK_MIRROR = true
  79. # 将背后攻击设置为无效时 偷袭效果依然发挥。
  80. # 全部都是装备上所需装备时、发挥技能时，才会有效果。
  81. # 防止背后攻击的武器ID　举例) = [1]　多数时的举例) = [1,2]
  82. NON_BACK_ATTACK_WEAPONS = []
  83. # 防止背后攻击的盾ID
  84. NON_BACK_ATTACK_ARMOR1 = []
  85. # 防止背后攻击的头部防具ID
  86. NON_BACK_ATTACK_ARMOR2 = []
  87. # 防止背后攻击的身体防具ID
  88. NON_BACK_ATTACK_ARMOR3 = []
  89. # 防止背后攻击的装饰品ID
  90. NON_BACK_ATTACK_ARMOR4 = []
  91. # 防止背后攻击的技能ID
  92. NON_BACK_ATTACK_SKILLS = []
  93. # 一定会发生背后攻击的开关No(会优先于防止)
  94. BACK_ATTACK_SWITCH = []

  96. #==============================================================================
  97. # ■ 单独战斗动作
  98. #------------------------------------------------------------------------------
  99. # 　使用的是连贯动作，这里的单独是没有意义的。
  100. #==============================================================================
  101. # 这里的单独动作名，请不要重复。
  102. # 与连贯动作名重复没有问题。
  103. ANIME = {
  104. #--------------------------------------------------------------------------
  105. # ● 角色动画的设定
  106. #--------------------------------------------------------------------------
  107. # 文件No…使用战斗动作图的号码。
  108. # 0的情况是使用行走图对应。
  109. # 1以后的是像"人物行走图文件名+_1"这样，参照文件名后的附加数字
  110. # 来判别的。例)$拉尔夫_1　的文件名No是1
  111. # 战斗动作图全部都是从人物行走图文件夹内读取。
  112. #
  113. # 种类…战斗动作图的分隔纵列。从上开始0到3依次。
  114. # 速度…动画的更新速度。数值越低更新速度越快。
  115. # 循环… [0=往复循环] [1=循环一次] [2=不循环]
  116. # 等待…不循环(2)的情况下、到动画显示结束的等待时间。
  117. # 固定…如果动画不作固定的情况、指定分割号码(横向位置)。不固定的情况是-1。反向再生是-2。
  118. # Z轴…在面前显示的话是正数。相较通常情况靠前的显示。
  119. # 影…表示阴影效果的话是true、不表示为false
  120. # 武器…武器表示的情况填入武器动作名。不表示的情况为""。

  122. # 目标动画名 文件No 种类 速度 循环 等待 固定 Z轴 影 武器
  123. "待机" => [ 0, 1, 15, 0, 0, -1, 0, true,"" ],
  124. "待机(固定)" => [ 0, 1, 10, 2, 0, 1, 0, true,"" ],
  125. "向右(固定)" => [ 0, 2, 10, 1, 2, 1, 0, true,"" ],
  126. "伤害" => [ 0, 3, 4, 2, 0, -1, 0, true,"" ],
  127. "无法战斗" => [ 0, 3, 10, 1, 8, 0, 0, true,"" ],
  128. "前进" => [ 0, 1, 1, 1, 0, -1, 0, true,"" ],
  129. "后退" => [ 0, 2, 2, 1, 0, -1, 0, true,"" ],
  130. "头上显示" => [ 0, 1, 2, 1, 0, -1, 600, true,"" ],
  131. "武器挥动攻击" => [ 0, 1, 1, 2, 0, -1, 2, true,"纵挥动"],
  132. "武器挥动攻击L" => [ 0, 1, 1, 2, 0, -1, 2, true,"纵挥动L"],
  133. "武器挥动攻击缓" => [ 0, 1, 6, 2, 0, -1, 2, true,"纵挥动"],
  134. "武器下旋转" => [ 0, 1, 2, 2, 0, -1, 2, true,"下旋转"],
  135. "武器上旋转" => [ 0, 1, 2, 2, 0, -1, 2, true,"上旋转"],
  136. "举起武器" => [ 0, 1, 2, 2, 28, -1, 2, true,"举起"],

  138. #--------------------------------------------------------------------------
  139. # ● 武器动作　让武器图像动起来的方法
  140. #--------------------------------------------------------------------------
  141. # 这里使用的武器动作名、必须是上面角色动画中设置的武器动作名。

  143. # X轴…横向移动距离。
  144. # Y轴…纵向移动距离。
  145. # Z轴…如果让此动作显示时武器在人物前方写作true。
  146. # 初始角度…武器在动作前的最初角度。半圆的0～360度。复数情况为反半圆。
  147. # 完毕角度…动作完毕时的角度。
  148. # 原点…武器旋转时的原点。[0…中心] [1…左上] [2…右上] [3…左下] [4…右下]
  149. # 反转…当为true时，动作前武器的图像将会显示为反转的。
  150. # X扩…X轴放大率、武器横向放大率。1是同等、2是2倍、0.5是1/2。
  151. # Y扩…Y轴放大率、武器纵向放大率。1是同等、2是2倍、0.5是1/2。
  152. # 调X…略微调整X轴。这里的数字是调整武器初期的X坐标。
  153. # 调Y…略微调整Y轴。这里的数字是调整武器初期的Y坐标。
  154. # 二刀…限定于二刀流为true、将以二刀流来显示左边武器动作的武器画像。
  155. # 如果不是二刀流的情况会自动跳过角色动画。

  157. # 武器动作名　　 X轴 Y轴 Z轴 初始角度 完毕角度 原点 反转 X扩 Y扩 调X 调Y 二刀
  158. "纵挥动" => [ 6, 8,false,-135, 45, 4,false, 1, 1, -4, -6,false],
  159. "纵挥动L" => [ 6, 8,false,-135, 45, 4,false, 1, 1, -4, -6, true],
  160. "下旋转" => [ 6, 8,false, 270, 45, 4,false, 1, 1, -4, -6,false],
  161. "上旋转" => [ 6, 8,false, 45,-100, 4,false, 1, 1, -4, -6,false],
  162. "举起" => [ 6, -4,false, 90, -45, 4,false, 1, 1, -4, -6,false],

  164. #--------------------------------------------------------------------------
  165. # ● 角色移动 敌方的X轴移动是以相反的复数计算。
  166. #--------------------------------------------------------------------------
  167. # 目标…坐标移动的参照 [0=自身现在的位置] [1=目标] [2=窗口] [3=初期位置]
  168. # X轴…从对象所看X坐标。绝对值就算是最低时也会比时间高
  169. # Y轴…从对象所看Y坐标。绝对值就算是最低时也会比时间高
  170. # 时间…移动时间。数值越大越缓慢。这里是用距离除以时间所得每格行动距离。
  171. # 加速…正数是加速、负数是减速。这里是每格行动的加速或减速。
  172. # 跳跃…跳跃轨道。正数是向下跳、负数是向上跳。0是不跳。
  173. # 动画…这里的移动所使用的角色动画名。

  175. # 目标 X轴 Y轴 时间 加速 跳跃 动画
  176. "不能移动" => [ 0, 0, 0, 1, 0, 0, "待机(固定)"],
  177. "到战斗开始的位置" => [ 0, 54, 0, 1, 0, 0, "前进"],
  178. "一步向前移动" => [ 3, -32, 0, 18, -1, 0, "前进"],
  179. "一步向后移动" => [ 0, 32, 0, 8, -1, 0, "前进"],
  180. "四人攻击移动1" => [ 2, 444, 96, 18, -1, 0, "前进"],
  181. "四人攻击移动2" => [ 2, 444, 212, 18, -1, 0, "前进"],
  182. "四人攻击移动3" => [ 2, 384, 64, 18, -1, 0, "前进"],
  183. "四人攻击移动4" => [ 2, 384, 244, 18, -1, 0, "前进"],
  184. "被伤害" => [ 0, 32, 0, 4, -1, 0, "伤害"],
  185. "推动" => [ 0, 12, 0, 1, 1, 0, "伤害"],
  186. "我方逃走" => [ 0, 300, 0,300, 1, 0, "后退"],
  187. "逃走失败" => [ 0, 48, 0, 16, 1, 0, "后退"],
  188. "胜利的跳跃" => [ 0, 0, 0, 20, 0, -5, "前进"],
  189. "目标移动" => [ 1, 0, 0, 18, -1, 0, "前进"],
  190. "目标高速移动" => [ 1, 0, -12, 8, 0, -2, "前进"],
  191. "目标向前移动" => [ 1, 24, 0, 12, -1, 0, "前进"],
  192. "目标向前高速移动" => [ 1, 24, 0, 1, 0, 0, "前进"],
  193. "目标右前移动" => [ 1, 96, 32, 16, -1, 0, "前进"],
  194. "目标左前移动" => [ 1, 96, -32, 16, -1, 0, "前进"],
  195. "一步向前跳跃" => [ 0, -32, 0, 8, -1, -4, "前进"],
  196. "一步向后跳跃" => [ 0, 32, 0, 8, -1, -4, "后退"],
  197. "跳跃到目标" => [ 1, 12, -12, 12, -1, -6, "前进"],
  198. "投掷我方" => [ 0, -24, 0, 16, 0, -2, "前进"],
  199. "强力踩踏" => [ 1, 12, -32, 12, -1, -6, "头上显示"],
  200. "一步向前跳跃敲击" => [ 0, -32, 0, 12, -1, -2, "武器挥动攻击"],
  201. "向前跳跃敲击" => [ 1, 12, 0, 12, -1, -5, "武器挥动攻击缓"],
  202. "对后方给予提高" => [ 1, 12, 0, 16, 0, -3, "武器挥动攻击"],
  203. "原地跳跃敲击" => [ 1, 0, 0, 16, 0, -5, "武器挥动攻击"],
  204. "拔出" => [ 1, -96, 0, 16, 2, 0, "武器挥动攻击"],
  205. "右拔出" => [ 1, -96, 32, 16, 2, 0, "武器挥动攻击"],
  206. "左拔出" => [ 1, -96, -32, 16, 2, 0, "武器挥动攻击"],
  207. "右拔出2" => [ 1,-128, 48, 16, 2, 0, "武器挥动攻击"],
  208. "左拔出2" => [ 1,-128, -48, 16, 2, 0, "武器挥动攻击"],

  210. #--------------------------------------------------------------------------
  211. # ● 角色漂浮 角色与影子脱离
  212. #--------------------------------------------------------------------------
  213. # 判別…用来判别的、请全部统一填入"float"。
  214. # 始高…开始漂浮的高度。负数情况是在影子之上、正数是在影子下方。
  215. # 终高…漂浮完毕的高度。因为动作系需要使用这个数值，请不要变动。
  216. # 时间…漂浮过程所用时间。
  217. # 动画…漂浮时候所用的角色动画名。

  219. # 　 判別 始高 终高 时间 动画
  220. "低空漂浮中" => ["float", -22, -20, 2, "待机(固定)"],
  221. "低空漂浮中2" => ["float", -20, -18, 2, "待机(固定)"],
  222. "低空漂浮中3" => ["float", -18, -20, 2, "待机(固定)"],
  223. "低空漂浮中4" => ["float", -20, -22, 2, "待机(固定)"],
  224. "跳跃停止" => ["float", 0, -80, 4, "待机(固定)"],
  225. "跳跃着地" => ["float", -80, 0, 4, "待机(固定)"],
  226. "抬起" => ["float", 0, -30, 4, "待机(固定)"],

  228. #--------------------------------------------------------------------------
  229. # ● 坐标初始化　返回到原始位置的移动设置
  230. #--------------------------------------------------------------------------
  231. # 判別…用来判别的、请全部统一填入"reset"。
  232. # 时间…返回过程所用时间。即使是同样的时间如果距离远的情况下移动速度也会发生变化。
  233. # 加速…正数为加速、负数为减速。这里是每格行动的加速或减速。
  234. # 跳跃…跳跃轨道。正数为向下跳、负数为向上跳。0是不跳。
  235. # 动画…这里移动时使用的角色动画名。

  237. # 　 判別 时间 加速 跳跃 动画
  238. "坐标初始化" => ["reset", 16, 0, 0, "前进"],
  239. "后退初始化" => ["reset", 16, 0, 0, "后退"],

  241. #--------------------------------------------------------------------------
  242. # ● 强制动作　被动形成的目标动作
  243. #--------------------------------------------------------------------------
  244. # 识别…被动形成的动作是单独还是连贯。"单独"时直接填入单独即可。
  245. # "连贯"时请填入连贯。
  246. #
  247. # 对象…获取是指动作的对象。0是目标、除他以外的处于那个状态No
  248. # 的全部角色视为对象。
  249. # 数值前有负号的就会习得此数字绝对值的数字对应的技能ID上的技能
  250. # 除自身以外的主人公作为对象(主人公限定)
  251. # 指定引取的情况(成员位置)、引取值填入1000。
  252. # 指定的引取是自身不在的情况(无法战斗或是逃走时)
  253. # 从零号开始顺次参照、所有角色界不在为时，行动中段。
  254. #
  255. # 恢复…动作后返回原始坐标的目标动作名。
  256. # 不返回的情况以这样""不填任何东西即可。
  257. # 动作名…强制动作的动作名。识别是单独的话、使用单独动作名。
  258. # 连贯的话就用连贯动作名（组合动作）。

  260. # 识别 对象 恢复 动作名
  261. "轻微吹动" => ["单独", 0, "坐标初始化", "推动"],
  262. "右旋转" => ["单独", 0, "坐标初始化", "右旋转一周"],
  263. "纵向压扁" => ["单独", 0, "坐标初始化", "纵向缩小"],
  264. "中弹1" => ["单独", 0, "坐标初始化", "从对象到自身1"],
  265. "举起我方" => ["单独", 0, "", "抬起"],
  266. "吴莉嘉连同攻击" => ["连贯", 18, "坐标初始化", "吴莉嘉合体攻击1"],
  267. "四人攻击1" => ["连贯", -101, "坐标初始化", "四人合体攻击1"],
  268. "四人攻击2" => ["连贯", -102, "坐标初始化", "四人合体攻击2"],
  269. "四人攻击3" => ["连贯", -103, "坐标初始化", "四人合体攻击3"],
  270. "将我方投掷飞出" => ["连贯", 1000, "坐标初始化", "可以投掷"],

  272. #--------------------------------------------------------------------------
  273. # ● 目标变更 改变现在角色作为目标对象的
  274. #--------------------------------------------------------------------------
  275. # ※只是改变战斗动作上的目标、战斗的目标不改变。
  276. # 只能是实行战斗中的角色执行。
  277. # 判別…因为使用于判别、请全部统一填入"target"。
  278. #
  279. # 对象…被变更目标的对象。0是目标、改变这个目标以外处于那个状态No中
  280. # 角色的全部对象。
  281. # 数值前有负号的就会习得此数字绝对值的数字对应的技能ID上的技能（我方队员为对象）。
  282. # 指定引取的情况(成员位置)、引取值填入1000。
  283. # 指定的引取是自身不在的情况(无法战斗或是逃走时)
  284. # 从零号开始顺次参照。
  285. #
  286. # 变更处…变更处内容 0=自身 1=自身的目标　
  287. # 2=成为自身的目标后、再将自己的目标变为变更对象
  288. # 3=将已变更为自身的目标返还(必须是在实行过2的情况下下)

  290. # 目标変更名 判別 对象 変更先
  291. "以自身为目标" => ["target", 0, 0],
  292. "二人攻击目标统一" => ["target", 18, 1],
  293. "四人攻击目标统一" => ["target", 19, 1],
  294. "选择投掷角色" => ["target", 1000, 2],
  295. "投掷目标组合" => ["target", 1000, 3],

  297. #--------------------------------------------------------------------------
  298. # ● 技能连发 中断动作后、其他技能被连发出来
  299. #--------------------------------------------------------------------------
  300. # 判別…用于判别、请全部统一填入"der"。
  301. # 确率…连发的成功率、0～100之间。如果没有被连发、剩下的动作继续执行。
  302. # 习得…如果连发的技能没有被习得也可以实行的话是true
  303. # 技能ID…连发的技能的ID

  305. # 连发名 判別 确率 习得 技能ID
  306. "回复连发" => ["der", 100, true, 91],
  307. "适当连发" => ["der", 100, true, 92],

  309. #--------------------------------------------------------------------------
  310. # ● 动作条件 设定条件、满足条件以后将停止所有行动
  311. #--------------------------------------------------------------------------
  312. # 判別…用于判别、请全部统一填入"nece"。
  313. # 对象…用于条件参照的对象。[0=自分] [1=目标] [2=敌全体] [3=我方全体]
  314. # 内容… [0=状态] [1=参数] [2=开关] [3=变量] [4=习得技能]
  315. #
  316. # 条件…填入符合上边内容确定的项目的数值。
  317. # [0]状态…状态ID
  318. # [1]参数…[0=现HP] [1=现MP] [2=攻击力] [3=防御力] [4=精神力] [5=敏捷性]
  319. # [2]开关…游戏中的开关No
  320. # [3]变量…游戏中的变量No
  321. # [4]习得技能…习得特定技能的条件、将那个技能的ID编号填入。
  322. #
  323. # 补足…补足上边的条件。
  324. # [0]状态…成为条件的被施加状态的人数。
  325. # 符号为正号时是需要此号码对应条件，负号时为不需要。
  326. # [1]参数…参数的数值。对象为复数时，将取平均值。
  327. # 符号为正的数值以上、以及负的数值以下作为条件。
  328. # [2]开关…开关ON为条件是 true、OFF为条件是 false
  329. # [3]变量…符号为正的数值以上、以及负的数值以下作为条件。
  330. # [4]习得技能…作为条件的技能所习得的人数。

  332. # 连发名 判別 对象 内容 条件 补足
  333. "二人攻击条件确认" => ["nece", 3, 0, 18, 1],
  334. "四人攻击条件确认" => ["nece", 3, 0, 19, 3],
  335. "漂浮状态确认" => ["nece", 0, 0, 17, 1],
  336. "是否已变身成猫"=> ["nece", 0, 0, 20, 1],
  337. "死亡确认" => ["nece", 1, 0, 1, 1],

  339. #--------------------------------------------------------------------------
  340. # ● 角色旋转　画像旋转。与反转不同、武器动作不能被反映
  341. #--------------------------------------------------------------------------
  342. # 判別…用于判别、请全部统一填入"angle"。
  343. # 时间…旋转过程所需时间。
  344. # 初始角度…旋转开始时的角度。指定于0～360度之间。正数为正半圆、负数为反半圆。
  345. # 完毕角度…旋转完毕时的角度。指定于0～360度之间。跟上边所记相同，但敌人的设定是与其相反的。
  346. # 回复…true是在完毕的同时恢复到通常角度。false是保持最后着动作。

  348. # 　 判別 时间 初始角度 完毕角度 回复
  349. "倒下" => ["angle", 1, -90, -90,false],
  350. "右旋转一周" => ["angle", 48, 0,-360,false],
  351. "左高速旋转" => ["angle", 6, 0, 360,false],

  353. #--------------------------------------------------------------------------
  354. # ● 角色放大缩小　武器动作不能被反映
  355. #--------------------------------------------------------------------------
  356. # 判別…用于判别、请全部统一填入"zoom"。
  357. # 时间…放大缩小过程所需时间。
  358. # X扩…横向的放大率。1.0是等倍、0.5是原有的一半。
  359. # Y扩…纵向的放大率。1.0是等倍、0.5是原有的一半。
  360. # 回复…true是在完毕的同时还原成等倍。false是保持完毕时的样子。
  361. # 放大缩小时会一时变更当前对象的原点、在恢复的时候复原。

  363. # 　 判別 时间 X拡 Y拡 回复
  364. "横向缩小" => ["zoom", 16, 0.5, 1.0, true],
  365. "纵向缩小" => ["zoom", 16, 1.0, 0.5, true],

  367. #--------------------------------------------------------------------------
  368. # ● 战斗动画　显示数据库的战斗动画
  369. #--------------------------------------------------------------------------
  370. # 判別…用于判别、请全部统一填入"anime"。
  371. # ID…动画ID。-1时将显示武器或者技能上设定的动画的伤害。
  372. # -2时技能也变成武器上所带的动画。
  373. # 对象… [0=自身] [1=目标]
  374. # 反转…true时动画地画像将被反转。
  375. # 等待…一直在动画显示完毕都存在的话是true。
  376. # 二刀用…true时将实行二刀流的动画。动画ID为-1时通常攻击的情况
  377. # 设定成显示为左手武器的动画。技能是技能动画的在实行。

  379. # 判別 ID 对象 反转 等待 二刀用
  380. "对象动画" => ["anime", -1, 1, false,false, false],
  381. "对象动画等待" => ["anime", -1, 1, false, true, false],
  382. "对象动画武器" => ["anime", -2, 1, false,false, false],
  383. "对象动画L" => ["anime", -1, 1, false,false, true],
  384. "打击动画" => ["anime", 1, 1, false,false, false],
  385. "斩击/必杀技1" => ["anime", 11, 1, false,false, false],

  387. #--------------------------------------------------------------------------
  388. # ● 动画飞出　让战斗动画飞出去。飞行道具、远距离攻击用
  389. #--------------------------------------------------------------------------
  390. # ID…数据库里设定的动画ID。0是不显示动画。
  391. # 对象…飞出的对象 [0=目标] [1=敌全体的中心] [2=我方全体的中心] [4=自身]
  392. # 类型…[0=碰撞时消失] [1=直线贯穿]
  393. # 时间…动画飞出去时候的移动时间。数值越大速度越缓慢。
  394. # 轨道…动画飞出去时候的轨道。填入数值的话是走抛物线。正数为向下的抛物线、负数为向上。
  395. # 调X…略微调整X轴。改变飞出时的初期X坐标。敌方的情况是自动的反向运算。
  396. # 调Y…略微调整Y轴。改变飞出时的初期Y坐标。
  397. # 始…动画飞出时的开始位置。[0=自身] [1=对象] [2=不能移动]
  398. # Z坐标…动画或者武器在角色面前显示的话是true
  399. # 武器…填入下面贴附的武器、技能动作名。如果不是用为""

  401. # 判別 ID 对象 类型 时间 轨道 调X 调Y 始 Z坐标 武器
  402. "魔法发动动画" => ["m_a", 44, 4, 0, 52, 0, 0, 0, 2,false,""],
  403. "从对象到自身1" => ["m_a", 4, 0, 0, 24, 0, 0, 0, 1,false,""],
  404. "开始武器投掷" => ["m_a", 0, 0, 0, 18, -24, 0, 0, 0,false,"旋转投掷"],
  405. "放弃武器投掷" => ["m_a", 0, 0, 0, 18, 24, 0, 0, 1,false,"旋转投掷"],
  406. "全体动画单体化"=> ["m_a", 80, 1, 0, 64, 0, 0, 0, 2, true,""],

  408. #--------------------------------------------------------------------------
  409. # ● 动画飞出时贴附的武器图像动画　专用于上面的武器飞出
  410. #--------------------------------------------------------------------------
  411. # 让贴附的武器图片动。这个画像可以和和武器动作的画像区分使用。
  412. # 那样的情况贴附的图像请去武器设定。
  413. # 初始角度…动作前的最初角度。前半圆0～360度。
  414. # 完毕角度…动作后的角度。前半圆0～360度。
  415. # 时间…旋转过程需要的时间。越小越快。动作到消失前持续保持旋转。

  417. # 武器动作名　　 初始角度 完毕角度 时间
  418. "旋转投掷" => [ 0, 360, 8],

  420. #--------------------------------------------------------------------------
  421. # ● 动画飞出时贴附的技能画像动画　专用于上边的动画飞出
  422. #--------------------------------------------------------------------------
  423. # 让贴附的技能图片动。能够贴附的图像在技能设定上。
  424. # 初始角度…动作前的最初角度。前半圆0～360度。
  425. # 完毕角度…动作后的角度。前半圆0～360度。
  426. # 时间…旋转过程所需要的时间。越小越快。动作到消失前持续保持旋转。
  427. # 判別…用于判别、请全部统一填入"skill"。

  429. # 武器动作名　　 初始角度 完毕角度 时间 判別
  430. "石投掷" => [ 0, 360, 8, "skill"],

  432. #--------------------------------------------------------------------------
  433. # ● 状态动画　显示事件使用的状态ICON
  434. #--------------------------------------------------------------------------
  435. # 判別…用于判别、请全部统一填入"balloon"。
  436. # 种类…状态的种类(纵位置)在0～9之间。
  437. # 形式…动画更新方法、在完毕时消失。[0=单线] [1=往返]

  439. # 状态名　　 判別 种类 形式
  440. "异常状态/通用" => ["balloon", 6, 1],
  441. "异常状态/危急" => ["balloon", 5, 1],
  442. "异常状态/睡眠" => ["balloon", 9, 1],

  444. #--------------------------------------------------------------------------
  445. # ● 声效
  446. #--------------------------------------------------------------------------
  447. # 判別…用于判别、请全部统一填入"sound"。
  448. # 种别…効果音为"se" BGM为"bgm" BGS为"bgs"
  449. # 音调…音调、50～150之间。音量…音量　不管哪个都要默认为100。
  450. # 文件名…播放的文件名。""时不改变任何BGM和BGS的设定。

  452. # SE名 判別 种别 速度 音量 SE文件名
  453. "absorb1" => ["sound", "se", 80, 100, "absorb1"],

  455. #--------------------------------------------------------------------------
  456. # ● 变更游戏整体速度 动作的慢放化
  457. #--------------------------------------------------------------------------
  458. # 判別…用于判别、请全部统一填入"fps"。
  459. # 游戏速度…60是默认的数值、比这个值低的时候就会放慢。　
  460. # ※这个指令也可以直接变更FPS。请注意处理。

  462. # 変更名 判別 游戏速度
  463. "缓慢再生" => ["fps", 20],
  464. "通常再生" => ["fps", 60],

  466. #--------------------------------------------------------------------------
  467. # ● 赋予状态
  468. #--------------------------------------------------------------------------
  469. # 判別…用于判别、请全部统一填入"sta+"。
  470. # 对象…[0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=除自身以外的我方全体]
  471. # 状态ID…赋予的状态ID编号。「不能抵抗」状态以外为抵抗。

  473. # 赋予的状态名 判別 对象 状态ID
  474. "赋予二人攻击状态" => ["sta+", 0, 18],
  475. "赋予四人攻击状态" => ["sta+", 0, 19],
  476. "猫" => ["sta+", 0, 20],

  478. #--------------------------------------------------------------------------
  479. # ● 状态解除
  480. #--------------------------------------------------------------------------
  481. # 判別…用于判别、请全部统一填入"sta-"。
  482. # 对象…[0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=除自身以外的我方全体]
  483. # 状态ID…解除的状态ID编号

  485. # 赋予的状态名 判別 对象 状态ID
  486. "解除二人攻击状态" => ["sta-", 3, 18],
  487. "解除四人攻击状态" => ["sta-", 3, 19],

  489. #--------------------------------------------------------------------------
  490. # ● 角色画像文件変更 只能使用于主人公们
  491. #--------------------------------------------------------------------------
  492. # 判別…用于判别、请全部统一填入"change"。
  493. # 复原…战斗后也显示为变化的是false。行走图也将变化。
  494. # 文件名…变更为的文件名。因为要改变识别处，请不要用文件名加"_1"后缀的方式。

  496. # 変更名 判別 复原 文件名
  497. "变身成猫" => ["change", true,"$cat"],
  498. "解除变身" => ["change", true,"$ylva"],

  500. #--------------------------------------------------------------------------
  501. # ● 图片显示 一名角色对应显示一枚图片
  502. #--------------------------------------------------------------------------
  503. # 始X…移动开始位置。从画面所看的X坐标。图片是以左上为原点。
  504. # 始Y…移动开始位置。从画面所看的Y坐标。
  505. # 終X…移动完毕X坐标。
  506. # 終Y…移动完毕Y坐标。
  507. # 时间…移动时间。数值越大越缓慢。这里是用距离除以时间所得每格行动距离。
  508. # Z轴…相较HP窗口靠前显示的话为true
  509. # 图片文件名…图片文件夹内的文件名。

  511. # 判別 始X 始Y 终X 终Y 时间 Z轴 图片文件名
  512. "特写1开始" => ["pic",-280, 48, 0, 64, 14,false,"Actor2-3"],
  513. "特写1完毕" => ["pic", 0, 48, 550, 64, 12,false,"Actor2-3"],

  515. #--------------------------------------------------------------------------
  516. # ● 游戏开关的设置
  517. #--------------------------------------------------------------------------
  518. # 判別…用于判别、请全部统一填入"switch"。
  519. # 开关No…设置哪个开关
  520. # ON/OFF…将开关ON时是true、OFF时是false
  521. #
  522. # 开关设置名 判別 开关No ON/OFF
  523. "开关No1/ON" => ["switch", 1, true],

  525. #--------------------------------------------------------------------------
  526. # ● 游戏变量的设置
  527. #--------------------------------------------------------------------------
  528. # 判別…用于判别、请全部统一填入"variable"。
  529. # 变量No…设置哪个开关
  530. # 设置…[0=代入] [1=加法] [2=减法] [3=乘法] [4=除法] [5=剩余]
  531. # 设置数值…指定成为演算对象的数值。
  532. #
  533. # 变量设置名 　　 判別 变量No 设置 设置数值
  534. "变量No1/+1" => ["variable", 1, 1, 1],

  536. #--------------------------------------------------------------------------
  537. # ● 脚本运行的设置
  538. #--------------------------------------------------------------------------
  539. # 判別…用于判别、请全部统一填入"script"。
  540. #
  541. # 使动作被添加到建议的脚本中。样品p = 1可以添加任何自己想要设置的脚本。
  542. # 功能中、不能处理文字列。
  543. #
  544. # 　　设置名 　　 判別
  545. "检测程序" => ["script", "

  547. p = 1

  549. "],

  551. #--------------------------------------------------------------------------
  552. # ● 其他　 没有设定项目。这里所使用的名称请不要改动。
  553. #--------------------------------------------------------------------------
  554. # 消去图片…消除显示的图片。
  555. # 残像ON…留下角色轨迹中的残像。持续连贯动作中的残像。
  556. # 残像OFF…消除残像。
  557. # 反转…反转画像。是再次被反转回去，还是坐标不复原保持着反转后的样子。
  558. # 待机不能移动…行动后、不做待机动作。
  559. # 击倒许可…目标的HP变成0时、在这个时机可以被击倒。
  560. # 如果这段没有的话，怪会在所有动作完成时被击倒。
  561. # 限定于二刀…只是这个下面的单独动作、限定于二刀来处理。
  562. # 如果不是二刀的话将会跳过、直接执行下一个单独动作。
  563. # 非限定于二刀…与上边相反，只有在不是二刀的情况下个动作才会有效。
  564. # 单独处理开始…在全体攻击处理成单独时、是播放行动的开始记号。
  565. # 单独处理完毕…在全体攻击处理成单独时、是播放行动的完毕记号。
  566. # 变更初期位置…原坐标(初期位置)变成现在的位置。
  567. # 解除变更初期位置…将变更初期位置还原。
  568. # 解除主动…当作战斗行动完毕、下一个角色开始行动。
  569. # 击倒许可设置也被含在其中、在这之后的所有动作都不会再对对象做出伤害。
  570. # 完毕…行动完毕。就算没有这里，在所有动作完毕后也会自动识别成完毕。

  572. "消去图片" => ["消去图片"],
  573. "残像ON" => ["残像ON"],
  574. "残像OFF" => ["残像OFF"],
  575. "反转" => ["反转"],
  576. "待机不能移动"=> ["待机不能移动"],
  577. "击倒许可" => ["击倒许可"],
  578. "限定于二刀" => ["限定于二刀"],
  579. "非限定于二刀" => ["非限定于二刀"],
  580. "单独处理开始" => ["单独处理开始"],
  581. "单独处理完毕" => ["单独处理完毕"],
  582. "变更初期位置" => ["变更初期位置"],
  583. "解除变更初期位置"=> ["解除变更初期位置"],
  584. "解除主动" => ["解除主动"],
  585. "完毕" => ["完毕"]

  587. #--------------------------------------------------------------------------
  588. # ● 等待相关
  589. #--------------------------------------------------------------------------
  590. # 单独动作上只有数值时、将会直接判定为等待时间。
  591. # 总之，请不要用只有数字的单独动作名。
  592. # 等待是到下一个动作执行前的等待时间、角色动画的更新不会被停止

  594. }
  595. #==============================================================================
  596. # ■ 连贯动作
  597. #------------------------------------------------------------------------------
  598. # 　将上边的单独动作组合起来、这里是实际做出的动作。
  599. #==============================================================================
  600. # 这里的连贯动作名将是下面主人公或者敌方所指定用的。
  601. # 行动会从左到右依次进行。
  602. ACTION = {
  603. #------------------------------- 待机系 -----------------------------------------
  604. # 连贯动作名 行动

  606. "战斗开始" => ["到战斗开始的位置","坐标初始化"],

  608. "待机" => ["待机"],

  610. "危急待机" => ["不能移动","待机(固定)","异常状态/危急","22"],

  612. "异常状态待机" => ["不能移动","待机(固定)","异常状态/通用","22"],

  614. "睡眠待机" => ["不能移动","待机(固定)","异常状态/睡眠","22"],

  616. "漂浮待机" => ["待机(固定)","6","低空漂浮中","4",
  617. "低空漂浮中2","4","低空漂浮中3","4",
  618. "低空漂浮中4","4"],

  620. "气绝" => ["倒下","无法战斗"],

  622. "伤害" => ["被伤害","坐标初始化"],

  624. "逃走" => ["我方逃走"],

  626. "敌方逃走" => ["我方逃走","坐标初始化"],

  628. "逃走失败" => ["逃走失败","待机(固定)","8","坐标初始化"],

  630. "选择指令" => ["一步向前移动"],

  632. "选择指令后" => ["坐标初始化"],

  634. "防御" => ["待机(固定)","4","漂浮状态确认","低空漂浮中",
  635. "2","低空漂浮中2","2","低空漂浮中3","2",
  636. "低空漂浮中4","2"],

  638. "回避" => ["一步向后跳跃","一步向后跳跃","待机(固定)","16",
  639. "坐标初始化"],

  641. "敌方回避" => ["一步向后跳跃","待机(固定)","16","坐标初始化"],

  643. "胜利" => ["待机(固定)","16","向右(固定)","胜利的跳跃",
  644. "待机(固定)","待机不能移动","是否已变身成猫",
  645. "魔法发动动画","解除变身","待机(固定)","待机不能移动",],

  647. "坐标复原" => ["坐标初始化"],

  649. #------------------------------- 強制系 ----------------------------------------

  651. "吴莉嘉合体攻击1" => ["2","目标左前移动","待机(固定)",
  652. "魔法发动动画","武器下旋转","举起武器",
  653. "48","右拔出","64","后退初始化"],

  655. "四人合体攻击1" => ["2","四人攻击移动2","待机(固定)","魔法发动动画",
  656. "武器下旋转","举起武器","90",
  657. "左拔出","96","后退初始化"],

  659. "四人合体攻击2" => ["2","四人攻击移动3","待机(固定)","魔法发动动画",
  660. "武器下旋转","举起武器","60","右拔出2","右旋转",
  661. "对象动画","128","后退初始化"],

  663. "四人合体攻击3" => ["2","四人攻击移动4","待机(固定)","魔法发动动画",
  664. "武器下旋转","举起武器","34","左拔出2","右旋转",
  665. "对象动画","144","后退初始化"],

  667. "可以投掷" => ["右旋转一周","4","目标高速移动","一步向后跳跃","4",
  668. "待机(固定)","一步向后跳跃","待机(固定)","32"],

  670. #--------------------------- 基本动作系 ----------------------------------

  672. "通常攻击" => ["目标向前移动","武器挥动攻击","对象动画等待",
  673. "12","武器挥动攻击L","对象动画L","限定于二刀","16",
  674. "击倒许可","后退初始化"],

  676. "敌方无武器的攻击" => ["目标向前移动","武器挥动攻击","对象动画等待",
  677. "击倒许可","后退初始化"],

  679. "使用通用技能" => ["一步向前移动","待机(固定)","魔法发动动画",
  680. "武器下旋转","举起武器","武器挥动攻击",
  681. "对象动画等待","击倒许可","24","坐标初始化"],

  683. "通用技能单独处理"=> ["一步向前移动","魔法发动动画","武器下旋转","举起武器",
  684. "单独处理开始","武器挥动攻击","对象动画","24",
  685. "单独处理完毕","击倒许可","坐标初始化"],

  687. "使用物品" => ["目标向前移动","待机(固定)","24","对象动画等待",
  688. "击倒许可","坐标初始化"],

  690. #------------------------------ 技能系 ---------------------------------------

  692. "多段攻击" => ["残像ON","向前跳跃敲击","武器挥动攻击L","对象动画武器",
  693. "待机(固定)","16","对象动画武器","武器下旋转",
  694. "武器上旋转","4","原地跳跃敲击","武器挥动攻击L",
  695. "对象动画武器","待机(固定)","16","对象动画武器",
  696. "反转","武器挥动攻击","武器挥动攻击L","12","反转",
  697. "原地跳跃敲击","武器挥动攻击L","对象动画武器",
  698. "一步向后跳跃","一步向后跳跃","待机(固定)",
  699. "对象动画武器","拔出","武器挥动攻击L","击倒许可",
  700. "残像OFF","16","后退初始化"],

  702. "多段随机攻击"=> ["向前跳跃敲击","武器挥动攻击L","对象动画武器","待机(固定)","16",
  703. "向前跳跃敲击","武器挥动攻击L","对象动画武器","待机(固定)","16",
  704. "向前跳跃敲击","武器挥动攻击L","对象动画武器","待机(固定)","16",
  705. "向前跳跃敲击","武器挥动攻击L","对象动画武器","击倒许可","坐标初始化"],

  707. "高速多段攻击" => ["目标向前移动","武器挥动攻击","轻微吹动","对象动画武器",
  708. "目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对象动画武器",
  709. "目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对象动画武器",
  710. "目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对象动画武器",
  711. "目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对象动画武器",
  712. "目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对象动画武器",
  713. "击倒许可","12","坐标初始化"],

  715. "二人同時攻击" => ["二人攻击条件确认","二人攻击目标统一","吴莉嘉连同攻击",
  716. "目标右前移动","待机(固定)","魔法发动动画","武器下旋转",
  717. "举起武器","48","斩击/必杀技1","左拔出","64","对象动画",
  718. "击倒许可","后退初始化","解除二人攻击状态"],

  720. "二人同時攻击准备" => ["赋予二人攻击状态"],

  722. "四人同時攻击" => ["四人攻击条件确认","四人攻击目标统一","四人攻击1",
  723. "四人攻击2","四人攻击3","四人攻击移动1","待机(固定)",
  724. "魔法发动动画","武器下旋转","举起武器","90",
  725. "斩击/必杀技1","右拔出","64","对象动画等待",
  726. "击倒许可","后退初始化","合体攻击解除"],

  728. "四人同時攻击准备" => ["赋予四人攻击状态"],

  730. "武器投掷" => ["一步向前移动","武器挥动攻击","absorb1","待机(固定)",
  731. "开始武器投掷","12","对象动画武器","击倒许可",
  732. "放弃武器投掷","坐标初始化"],

  734. "单独全体远距离攻击"=> ["一步向前跳跃","跳跃停止","单独处理开始",
  735. "以自身为目标","武器挥动攻击","中弹1","8",
  736. "对象动画武器","单独处理完毕","击倒许可",
  737. "跳跃着地","坐标初始化"],

  739. "全体远距离攻击" => ["以自身为目标","武器挥动攻击","中弹1","20",
  740. "对象动画等待","击倒许可"],

  742. "回复连发" => ["目标向前移动","对象动画","武器挥动攻击",
  743. "16","死亡确认","回复连发","坐标初始化"],

  745. "适当连发" => ["逃走失败","魔法发动动画","武器下旋转","举起武器",
  746. "8","对象动画","适当连发","坐标初始化"],

  748. "特写" => ["待机(固定)","魔法发动动画","特写1开始",
  749. "75","特写1完毕","8","目标向前移动",
  750. "武器挥动攻击","对象动画等待","击倒许可",
  751. "消去图片","后退初始化"],

  753. "踩踏攻击" => ["跳跃到目标","打击动画","纵向压扁","一步向后跳跃",
  754. "强力踩踏","打击动画","纵向压扁","一步向后跳跃",
  755. "强力踩踏","对象动画","纵向压扁","一步向后跳跃",
  756. "一步向后跳跃","击倒许可","待机(固定)","8","后退初始化"],

  758. "全体攻击1" => ["一步向前移动","待机(固定)","魔法发动动画","武器下旋转",
  759. "举起武器","全体动画单体化","武器挥动攻击","48",
  760. "对象动画等待","击倒许可","坐标初始化"],

  762. "变身成猫" => ["一步向前跳跃","待机(固定)","魔法发动动画","32",
  763. "变身成猫","待机(固定)","猫","32","一步向后跳跃"],

  765. "人体投掷" => ["选择投掷角色","目标移动","举起我方","4",
  766. "absorb1","投掷目标组合","将我方投掷飞出",
  767. "投掷我方","待机(固定)","对象动画","坐标初始化",
  768. "待机(固定)","32"],



  772. #-------------------------------------------------------------------------------
  773. "完毕" => ["完毕"]}
  774. end
  775. #==============================================================================
  776. # ■ Game_Actor
  777. #------------------------------------------------------------------------------
  778. # 　设定主人公的基本动作类
  779. #==============================================================================
  780. class Game_Actor < Game_Battler
  781. #--------------------------------------------------------------------------
  782. # ● 从主人公ID中确定空手时的动作（无武器时）
  783. #--------------------------------------------------------------------------
  784. # when 1 ←这个数字是主人公ID
  785. # return "通常攻击" ←填入对应的连贯动作名
  786. def non_weapon
  787. case @actor_id
  788. when 1
  789. return "通常攻击"
  790. end
  791. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  792. return "通常攻击"
  793. end
  794. #--------------------------------------------------------------------------
  795. # ● 通常待机
  796. #--------------------------------------------------------------------------
  797. def normal
  798. case @actor_id
  799. when 1
  800. return "待机"
  801. end
  802. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  803. return "待机"
  804. end
  805. #--------------------------------------------------------------------------
  806. # ● 危急（HP1/4以下）
  807. #--------------------------------------------------------------------------
  808. def pinch
  809. case @actor_id
  810. when 1
  811. return "危急待机"
  812. end
  813. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  814. return "危急待机"
  815. end
  816. #--------------------------------------------------------------------------
  817. # ● 防御
  818. #--------------------------------------------------------------------------
  819. def defence
  820. case @actor_id
  821. when 1
  822. return "防御"
  823. end
  824. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  825. return "防御"
  826. end
  827. #--------------------------------------------------------------------------
  828. # ● 伤害　对象动画時、取得命中时的动作
  829. #--------------------------------------------------------------------------
  830. def damage_hit
  831. case @actor_id
  832. when 1
  833. return "伤害"
  834. end
  835. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  836. return "伤害"
  837. end
  838. #--------------------------------------------------------------------------
  839. # ● 回避　对象动画時、取得沒命中时的动作
  840. #--------------------------------------------------------------------------
  841. def evasion
  842. case @actor_id
  843. when 1
  844. return "回避"
  845. end
  846. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  847. return "回避"
  848. end
  849. #--------------------------------------------------------------------------
  850. # ● 选择指令前动作
  851. #--------------------------------------------------------------------------
  852. def command_b
  853. case @actor_id
  854. when 1
  855. return "选择指令"
  856. end
  857. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  858. return "选择指令"
  859. end
  860. #--------------------------------------------------------------------------
  861. # ● 选择指令后动作
  862. #--------------------------------------------------------------------------
  863. def command_a
  864. case @actor_id
  865. when 1
  866. return "选择指令后"
  867. end
  868. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  869. return "选择指令后"
  870. end
  871. #--------------------------------------------------------------------------
  872. # ● 逃走成功
  873. #--------------------------------------------------------------------------
  874. def run_success
  875. case @actor_id
  876. when 1
  877. return "逃走"
  878. end
  879. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  880. return "逃走"
  881. end
  882. #--------------------------------------------------------------------------
  883. # ● 逃走失败
  884. #--------------------------------------------------------------------------
  885. def run_ng
  886. case @actor_id
  887. when 1
  888. return "逃走失败"
  889. end
  890. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  891. return "逃走失败"
  892. end
  893. #--------------------------------------------------------------------------
  894. # ● 胜利
  895. #--------------------------------------------------------------------------
  896. def win
  897. case @actor_id
  898. when 1
  899. return "胜利"
  900. end
  901. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  902. return "胜利"
  903. end
  904. #--------------------------------------------------------------------------
  905. # ● 进入战斗时的动作
  906. #--------------------------------------------------------------------------
  907. def first_action
  908. case @actor_id
  909. when 1
  910. return "战斗开始"
  911. end
  912. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  913. return "战斗开始"
  914. end
  915. #--------------------------------------------------------------------------
  916. # ● 动作被中断时的恢复动作
  917. #--------------------------------------------------------------------------
  918. def recover_action
  919. case @actor_id
  920. when 1
  921. return "坐标复原"
  922. end
  923. # 上述主人公ID以外的其他主人公全部使用的连贯动作名
  924. return "坐标复原"
  925. end
  926. #--------------------------------------------------------------------------
  927. # ● 影图像 在人物行走图文件夹中读取
  928. #--------------------------------------------------------------------------
  929. # return "shadow00" ←在这里填入想要设定的话像文件名
  930. def shadow
  931. case @actor_id
  932. when 1
  933. return "shadow00"
  934. end
  935. # 上述主人公ID以外的其他主人公全部使用的影图像
  936. return "shadow00"
  937. end
  938. #--------------------------------------------------------------------------
  939. # ● 略微调整影图像的位置
  940. #--------------------------------------------------------------------------
  941. # return [横坐标, 縦坐标]
  942. def shadow_plus
  943. case @actor_id
  944. when 1
  945. return [ 0, 4]
  946. end
  947. # 上述主人公ID以外的其他主人公全部使用的位置
  948. return [ 0, 4]
  949. end
  950. end
  951. #==============================================================================
  952. # ■ Game_Enemy
  953. #------------------------------------------------------------------------------
  954. # 　敌方的基本动作设定
  955. #==============================================================================
  956. class Game_Enemy < Game_Battler
  957. #--------------------------------------------------------------------------
  958. # ● 从敌方ID来确定未装备武器时的通常攻击动作
  959. #--------------------------------------------------------------------------
  960. # when 1 ←这里的数字是敌方ID编号
  961. # return "敌方无武器的攻击" ←请填入对应的连贯动作名
  962. def base_action
  963. case @enemy_id
  964. when 1
  965. return "敌方无武器的攻击"
  966. end
  967. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  968. return "敌方无武器的攻击"
  969. end
  970. #--------------------------------------------------------------------------
  971. # ● 通常待机
  972. #--------------------------------------------------------------------------
  973. def normal
  974. case @enemy_id
  975. when 1
  976. return "待机"
  977. end
  978. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  979. return "待机"
  980. end
  981. #--------------------------------------------------------------------------
  982. # ● 危急（HP1/4以下）
  983. #--------------------------------------------------------------------------
  984. def pinch
  985. case @enemy_id
  986. when 1
  987. return "待机"
  988. end
  989. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  990. return "待机"
  991. end
  992. #--------------------------------------------------------------------------
  993. # ● 防御
  994. #--------------------------------------------------------------------------
  995. def defence
  996. case @enemy_id
  997. when 1
  998. return "防御"
  999. end
  1000. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  1001. return "防御"
  1002. end
  1003. #--------------------------------------------------------------------------
  1004. # ● 伤害　对象动画時、取得命中时的动作
  1005. #--------------------------------------------------------------------------
  1006. def damage_hit
  1007. case @enemy_id
  1008. when 1
  1009. return "伤害"
  1010. end
  1011. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  1012. return "伤害"
  1013. end
  1014. #--------------------------------------------------------------------------
  1015. # ● 回避　对象动画時、取得未命中时的动作
  1016. #--------------------------------------------------------------------------
  1017. def evasion
  1018. case @enemy_id
  1019. when 1
  1020. return "敌方回避"
  1021. end
  1022. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  1023. return "敌方回避"
  1024. end
  1025. #--------------------------------------------------------------------------
  1026. # ● 逃走
  1027. #--------------------------------------------------------------------------
  1028. def run_success
  1029. case @enemy_id
  1030. when 1
  1031. return "敌方逃走"
  1032. end
  1033. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  1034. return "敌方逃走"
  1035. end
  1036. #--------------------------------------------------------------------------
  1037. # ● 进入战斗时的动作
  1038. #--------------------------------------------------------------------------
  1039. def first_action
  1040. case @enemy_id
  1041. when 1
  1042. return "战斗开始"
  1043. end
  1044. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  1045. return "战斗开始"
  1046. end
  1047. #--------------------------------------------------------------------------
  1048. # ● 动作被中断时的恢复动作
  1049. #--------------------------------------------------------------------------
  1050. def recover_action
  1051. case @enemy_id
  1052. when 1
  1053. return "坐标复原"
  1054. end
  1055. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
  1056. return "坐标复原"
  1057. end
  1058. #--------------------------------------------------------------------------
  1059. # ● 影图像 在人物行走图文件夹中读取
  1060. #--------------------------------------------------------------------------
  1061. # return "shadow01" ←在这里填入想要设定的话像文件名。
  1062. def shadow
  1063. case @enemy_id
  1064. when 1
  1065. return "shadow01"
  1066. when 30
  1067. return ""
  1068. end
  1069. # 上述敌方ID以外的其他敌方队员全部使用的武器ID影图像
  1070. return "shadow01"
  1071. end
  1072. #--------------------------------------------------------------------------
  1073. # ● 略微调整影图像的位置
  1074. #--------------------------------------------------------------------------
  1075. # return [横坐标, 縦坐标]
  1076. def shadow_plus
  1077. case @enemy_id
  1078. when 1
  1079. return [ 0, -8]
  1080. end
  1081. # 上述敌方ID以外的其他敌方队员全部使用的武器ID位置
  1082. return [ 0, 0]
  1083. end
  1084. #--------------------------------------------------------------------------
  1085. # ● 敌方武器设定 在动作和动画时，武器也被显示。
  1086. #--------------------------------------------------------------------------
  1087. # return 1 ←这个数字是武器ID。0的话将被判别为空手。
  1088. # 只有在敌方动画NO的时候画像才被显示。
  1089. def weapon
  1090. case @enemy_id
  1091. when 1
  1092. return 30
  1093. end
  1094. # 上述敌方ID以外的其他敌方队员全部使用的武器ID
  1095. return 0
  1096. end
  1097. #--------------------------------------------------------------------------
  1098. # ● 战斗配置的略微调整 在这里可以设置数据库中所不能设置的广范围坐标
  1099. #--------------------------------------------------------------------------
  1100. # return [ 0, 0] => [X坐标、Y坐标] 这个数值从数据库上的配置上变化
  1101. def position_plus
  1102. case @enemy_id
  1103. when 1
  1104. return [0, 0]
  1105. end
  1106. # 上述敌方ID以外的其他敌方队员全部使用的武器ID坐标调整
  1107. return [ 0, 0]
  1108. end
  1109. #--------------------------------------------------------------------------
  1110. # ● 敌方击倒(击破时的退场)方式
  1111. #--------------------------------------------------------------------------
  1112. # 被击倒画像残留的为1、普通为2、BOSS型为3
  1113. def collapse_type
  1114. case @enemy_id
  1115. when 1
  1116. return 2
  1117. when 30
  1118. return 3
  1119. end
  1120. # 上述敌方ID以外的其他敌方队员全部使用的武器ID击倒方式
  1121. return 2
  1122. end
  1123. #--------------------------------------------------------------------------
  1124. # ● 敌方行动回数 1回合做几次行动
  1125. #--------------------------------------------------------------------------
  1126. # 回数 确率 补正
  1127. # return [ 2, 100, 50]
  1128. #
  1129. # 回数…最大的行动回数
  1130. # 确率…下次行动能否成功的成功率。数值为％
  1131. # 补正…速度修正。行动的每次数值％后得出的值
  1132. def action_time
  1133. case @enemy_id
  1134. when 1
  1135. return [ 1, 100, 100]
  1136. end
  1137. # 上述敌方ID以外的其他敌方队员全部使用的武器ID行动回数
  1138. return [ 1, 100, 100]
  1139. end
  1140. #--------------------------------------------------------------------------
  1141. # ● 敌方动画
  1142. #--------------------------------------------------------------------------
  1143. # 敌方被作成动画？　true是是跟主人公同等对待。
  1144. # [设定方法]
  1145. # 1.敌方的动画画像变成行走图
  1146. # 2.数据库的敌方角色名、参照着行走图文件名填写
  1147. def anime_on
  1148. case @enemy_id
  1149. when 1
  1150. return true
  1151. end
  1152. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动画设定
  1153. return false
  1154. end
  1155. #--------------------------------------------------------------------------
  1156. # ● 敌方动画時的自动反转
  1157. #--------------------------------------------------------------------------
  1158. # 如果想自动反转上面设定为NO的敌方画像和武器动画时为true
  1159. def action_mirror
  1160. case @enemy_id
  1161. when 1
  1162. return true
  1163. end
  1164. # 上述敌方ID以外的其他敌方队员全部使用的武器ID动画设定
  1165. return false
  1166. end
  1167. end
  1168. module RPG
  1169. #==============================================================================
  1170. # ■ module RPG
  1171. #------------------------------------------------------------------------------
  1172. # 　设定状态动作。
  1173. #==============================================================================
  1174. class State
  1175. #--------------------------------------------------------------------------
  1176. # ● 指定ID　根据状态改变通常待机、危急时的动作。
  1177. #--------------------------------------------------------------------------
  1178. # when 1 ←这个数字是状态ID
  1179. # return "气绝" ←填入对应的连贯动作名
  1180. def base_action
  1181. case @id
  1182. when 1 # 无法战斗（HP0）时。最优先。
  1183. return "气绝"
  1184. when 2,3,4,5,7
  1185. return "异常状态待机"
  1186. when 6
  1187. return "睡眠待机"
  1188. when 17
  1189. return "漂浮待机"
  1190. end
  1191. # 上述状态ID以外的其他状态全部使用的连贯动作
  1192. return "待机"
  1193. end
  1194. #--------------------------------------------------------------------------
  1195. # ● 扩张设定　从状态ID确定扩张设定。可以重复。
  1196. #--------------------------------------------------------------------------
  1197. # "自动复活/50"…无法战斗时自动复活。不要解除无法战斗。
  1198. # /后的数字是回复时的HP(最大值的比例％)回复后状态会自动解除
  1199. # "魔法反弹/39"…反弹魔法(物理攻击以外)技能。/后填入反射时显示的动画ID编号
  1200. # "物理反弹/39"…反弹物理攻击(包含物理技能)。/后填入反射时显示的动画ID编号
  1201. # "魔法无效/39"…魔法(物理攻击以外)技能无效化。/后填入无效时显示的动画ID编号
  1202. # "物理无效/39"…物理攻击(包含物理技能)无效化。/后填入无效时显示的动画ID编号
  1203. # "成本吸収"…受到技能时将他的成本还原到自身。数值不显示。
  1204. # "0回合解除"…按照行动顺序的回合数解除状态。
  1205. # "敌方除外"…让敌方不显示这个状态
  1206. # "无POP"…附加这个状态時、伤害窗口上不显示状态名
  1207. # "不显示ICON"…在状态窗口上不显示状态ICON
  1208. # "禁止状态动作"…附加这个状态时不会改变人物待机状态
  1209. # "连续伤害"…调用下面的连续伤害
  1210. # "无"…无扩张
  1211. def extension
  1212. case @id
  1213. when 1 # 无法战斗
  1214. return ["无POP","敌方除外"]
  1215. when 2 # 毒
  1216. return ["连续伤害"]
  1217. when 18
  1218. return ["0回合解除","不显示ICON"]
  1219. when 19
  1220. return ["0回合解除","不显示ICON"]
  1221. when 20
  1222. return ["不显示ICON","禁止状态动作"]
  1223. end
  1224. # 上述ID以外所有的使用的扩张设定
  1225. return ["无"]
  1226. end
  1227. #--------------------------------------------------------------------------
  1228. # ● 连续伤害扩张设置　包含连续回复
  1229. #--------------------------------------------------------------------------
  1230. # when 1 ←这个数字是状态ID。上面的只有填写了"连续伤害"的扩张才会有这个效果
  1231. # 　　　　 可以多数设置。例)[["hp",0,5,true],["mp",0,5,true]]
  1232. #
  1233. # 　 对象 定数 比例 POP 无法战斗许可
  1234. # return [["hp", 0, 10, true, true]]
  1235. #
  1236. # 对象…比例伤害对象是 HP的话为"hp" MP为"mp"
  1237. # 定数…这个数值直接是伤害值。如果是负数时便成为回復。数值上多少会有些误差
  1238. # 比例…对象的最大值的比例伤害。数值以％计算。数值上多少会有些误差
  1239. # POP…在战斗画面上显示数值是true
  1240. # 无法战斗许可…许可HP0的情况是true
  1241. def slip_extension
  1242. case @id
  1243. when 2 # 毒
  1244. return [["hp", 0, 10, true, true]]
  1245. end
  1246. return []
  1247. end
  1248. end
  1249. #==============================================================================
  1250. # ■ module RPG
  1251. #------------------------------------------------------------------------------
  1252. # 　设置武器动作
  1253. #==============================================================================
  1254. class Weapon
  1255. #--------------------------------------------------------------------------
  1256. # ● 动作指定　从装备着的武器ID来决定通常攻击的动作。
  1257. #--------------------------------------------------------------------------
  1258. # when 1 ←这个数字是武器ID
  1259. # return "通常攻击" ←请填入对应的连贯动作名
  1260. def base_action
  1261. case @id
  1262. when 1
  1263. return "通常攻击"
  1264. end
  1265. # 上述ID以外的其他全部使用的动作
  1266. return "通常攻击"
  1267. end
  1268. #--------------------------------------------------------------------------
  1269. # ● 图像指定　从装备着的武器ID来决定通常攻击的动作。
  1270. #--------------------------------------------------------------------------
  1271. # return "001-Weapon01" ←请填入对应的武器图像的文件名
  1272. # 武器图像请放入人物行走图文件夹中
  1273. # 使用ICON时、在ID上没有的全部使用ICON来表示
  1274. # 特定的武器想要让他们不显示的话请用空白的图像。
  1275. def graphic
  1276. case @id
  1277. when 1
  1278. return ""
  1279. end
  1280. # 使用上述ID以外的全ICON画像
  1281. return ""
  1282. end
  1283. #--------------------------------------------------------------------------
  1284. # ● 飞出动画中贴附武器图像　自人物行走图文件夹中读取
  1285. #--------------------------------------------------------------------------
  1286. # 飞出动画用武器画像另行设定。显示弓和箭之类的。
  1287. # 在这里没有被设置的武器会和上面的图像作相同处理。
  1288. def flying_graphic
  1289. case @id
  1290. when 1
  1291. return ""
  1292. end
  1293. # 上述ID以外一律使用的图像
  1294. return ""
  1295. end
  1296. end
  1297. #==============================================================================
  1298. # ■ module RPG
  1299. #------------------------------------------------------------------------------
  1300. # 　技能动作设定。
  1301. #==============================================================================
  1302. class Skill
  1303. #--------------------------------------------------------------------------
  1304. # ● 从技能ID决定动作。
  1305. #--------------------------------------------------------------------------
  1306. def base_action
  1307. case @id
  1308. when 84
  1309. return "武器投掷"
  1310. when 85
  1311. return "多段攻击"
  1312. when 86
  1313. return "高速多段攻击"
  1314. when 87
  1315. return "单独全体远距离攻击"
  1316. when 88
  1317. return "全体远距离攻击"
  1318. when 89
  1319. return "多段随机攻击"
  1320. when 90
  1321. return "回复连发"
  1322. when 91
  1323. return "适当连发"
  1324. when 92
  1325. return "通常攻击"
  1326. when 93
  1327. return "特写"
  1328. when 94
  1329. return "踩踏攻击"
  1330. when 95
  1331. return "全体攻击1"
  1332. when 96
  1333. return "通用技能单独处理"
  1334. when 97
  1335. return "变身成猫"
  1336. when 98
  1337. return "二人同時攻击"
  1338. when 99
  1339. return "二人同時攻击准备"
  1340. when 100
  1341. return "四人同時攻击"
  1342. when 101
  1343. return "四人同時攻击准备"
  1344. when 102
  1345. return "四人同時攻击准备"
  1346. when 103
  1347. return "四人同時攻击准备"
  1348. when 104
  1349. return "人体投掷"
  1350. end
  1351. # 上述ID以外的其他全部使用的动作
  1352. return "使用通用技能"
  1353. end
  1354. #--------------------------------------------------------------------------
  1355. # ● 扩张设定　从技能ID决定扩张设定。可以重复。
  1356. #--------------------------------------------------------------------------
  1357. # "必中"…攻击绝对不会被回避
  1358. # "HP消費"…将MP消费改为HP消费
  1359. # "%成本MAX"…技能成本变为以最大MP(HP)的比例取值。例)MAXMP500的成本10是消费MP50
  1360. # "%成本NOW"…技能成本变为以现在MP(HP)的比例取值。例)现MP100的成本10是消费MP10
  1361. # "无视反射"…无视魔法、物理技能反射和无效化状态
  1362. # "%伤害MAX/30"…伤害计算变为以对象的最大HP(MP)的比例取值。/后的数值为%值伤害
  1363. # "%伤害NOW/30"…伤害计算变为以对象的现在HP(MP)的比例取值。/后的数值为%值伤害
  1364. # "成本威力"…根据使用者的最大MP(HP)判别消費MP(HP)的比例威力。MAX消費是原本威力、MAX10%是原有威力的1/10
  1365. # "现HP威力"…根据使用者的最大HP改变现在HP的比例威力。MAX是原本威力、MAX10%是原有威力的1/10
  1366. # "现MP威力"…根据使用者的最大MP改变现在MP的比例威力。MAX是原本威力、MAX10%是原有威力的1/10
  1367. # "MP消耗减半无效"…防具上的定义「MP消耗减半」被无效化
  1368. # "不显示HELP"…动作时、帮助窗口上不显示技能名
  1369. # "全区域"…目标范围为敌我方全体
  1370. # "随机目标"…目标内随机选择一个对象
  1371. # "自身以外"…在目标内将自己排除
  1372. # "伤害动作禁止"…不显示伤害命中时的动作
  1373. # "行动前无闪光"…行动时角色不发光
  1374. # "无"…无扩张
  1375. def extension
  1376. case @id
  1377. when 86
  1378. return ["伤害动作禁止"]
  1379. when 89
  1380. return ["随机目标"]
  1381. when 94
  1382. return ["伤害动作禁止"]
  1383. when 96
  1384. return ["全区域"]
  1385. when 98
  1386. return ["伤害动作禁止"]
  1387. when 99
  1388. return ["不显示HELP","行动前无闪光"]
  1389. when 100
  1390. return ["伤害动作禁止"]
  1391. when 101
  1392. return ["不显示HELP","行动前无闪光"]
  1393. when 102
  1394. return ["不显示HELP","行动前无闪光"]
  1395. when 103
  1396. return ["不显示HELP","行动前无闪光"]
  1397. end
  1398. # 上述ID以外的其他全部使用的拡張設定
  1399. return ["无"]
  1400. end
  1401. #--------------------------------------------------------------------------
  1402. # ● 飞出动画上贴附的画像　自人物行走图文件夹中读取
  1403. #--------------------------------------------------------------------------
  1404. # 指定技能ID的画像
  1405. def flying_graphic
  1406. case @id
  1407. when 1
  1408. return ""
  1409. end
  1410. # 上述ID以外为画像未使用
  1411. return ""
  1412. end
  1413. end
  1414. #==============================================================================
  1415. # ■ module RPG
  1416. #------------------------------------------------------------------------------
  1417. # 　物品动作设定。
  1418. #==============================================================================
  1419. class Item
  1420. #--------------------------------------------------------------------------
  1421. # ● 根据物品ID决定动作。
  1422. #--------------------------------------------------------------------------
  1423. def base_action
  1424. case @id
  1425. when 1
  1426. return "使用物品"
  1427. end
  1428. # 上述ID以外的其他全部使用的动作
  1429. return "使用物品"
  1430. end
  1431. #--------------------------------------------------------------------------
  1432. # ● 扩张设定　根据物品ID决定扩张设定。可以重复。
  1433. #--------------------------------------------------------------------------
  1434. # "必中"…攻击绝对不会被回避
  1435. # "反射无视"…无视魔法、物理反射和无效化状态
  1436. # "不显示HELP"…帮助窗口上不显示物品名
  1437. # "全区域"…目标范围为敌我全体
  1438. # "随机目标"…目标内中随机选择一个对象
  1439. # "自身以外"…目标内中将自身排除
  1440. # "伤害动作禁止"…不显示伤害命中时的动作
  1441. # "行动前无闪光"…行动时角色不发光
  1442. # "无"…无扩张
  1443. def extension
  1444. case @id
  1445. when 1
  1446. return ["无"]
  1447. end
  1448. # 上述ID以外的其他全部使用的拡張設定
  1449. return ["无"]
  1450. end
  1451. end
  1452. end
复制代码







然后后面还有两个脚本，放到它后面。

第一个：Sideview 1

  1. #==============================================================================
  2. # ■ Sprite_Battler Ver2.6
  3. #------------------------------------------------------------------------------
  4. # 　角色用于现实的战斗动作。
  5. #==============================================================================
  6. class Sprite_Battler < Sprite_Base
  7.   #--------------------------------------------------------------------------
  8.   # ● 初期化
  9.   #--------------------------------------------------------------------------
  10.   def initialize(viewport, battler = nil)
  11.     super(viewport)
  12.     @battler = battler
  13.     @battler_visible = false
  14.     @effect_type = 0                   # 效果的种类
  15.     @effect_duration = 0               # 效果的残留时间
  16.     @move_x = 0                        # 已变化的X坐标的累计
  17.     @move_y = 0                        # 已变化的Y坐标的累计
  18.     @move_z = 0                        # 已变化的Z坐标的累计
  19.     @distanse_x = 0                    # X坐标的移动距离
  20.     @distanse_y = 0                    # Y坐标的移动距离
  21.     @moving_x = 0                      #１单位所相当的X坐标移动距离
  22.     @moving_y = 0                      #１单位所相当的Y坐标移动距离
  23.     @move_speed_x = 0                  # X坐标的移动速度
  24.     @move_speed_y = 0                  # Y坐标的移动速度
  25.     @move_speed_plus_x = 0             # X坐标在加减速时的补充移动速度
  26.     @move_speed_plus_y = 0             # Y坐标在加减速时的补充移动速度
  27.     @move_boost_x = 0                  # X坐标加速度
  28.     @move_boost_y = 0                  # Y坐标加速度
  29.     @jump_time = 0                     # 跳跃时间
  30.     @jump_time_plus = 0                # 跳跃时间补充
  31.     @jump_up = 0                       # 跳跃上升
  32.     @jump_down = 0                     # 跳跃下降
  33.     @jump_size = 0                     # 跳跃高度
  34.     @float_time = 0                    # 漂浮时间
  35.     @float_up = 0                      # 1单位所相当于的浮遊高度
  36.     @jump_plus = 0                     # 根据跳跃补充影位置
  37.     @angle = 0                         # 旋转角度
  38.     @angling = 0                       # 1单位所相当于的旋转角度
  39.     @angle_time = 0                    # 旋转时间
  40.     @angle_reset = 0                   # 是否初始化角度
  41.     @zoom_x = 0                        # 横向放大率
  42.     @zoom_y = 0                        # 纵向放大率
  43.     @zooming_x = 0                     # 1单位所相当于的横向放大率
  44.     @zooming_y = 0                     # 1单位所相当于的纵向放大率
  45.     @zoom_time = 0                     # 放大时间
  46.     @zoom_reset = 0                    # 是否初始化放大
  47.     @target_battler = []               # 目标角色情报
  48.     @now_targets = []                  # 目标角色记忆
  49.     @pattern = 0                       # 横图片位置（更新位置）
  50.     @pattern_back = false              # 循环标志
  51.     @wait = 0                          # 到下个动作的等待时间
  52.     @unloop_wait = 0                   # 非循环系动画完毕时的等待时间
  53.     @action = []                       # 行动
  54.     @anime_kind = 0                    # 纵图片位置（动画种类位置）
  55.     @anime_speed = 0                   # 图片更新速度
  56.     @frame = 0                         # 被消费图片更新时间
  57.     @anime_loop = 0                    # 循环方式
  58.     @anime_end = false                 # 角色的动画是否完毕
  59.     @anime_freeze = false              # 是否是固定动画
  60.     @anime_freeze_kind = false         # 固定图案位置
  61.     @anime_moving = false              # 是否在飞出动画中
  62.     @base_width = N01::ANIME_PATTERN   # 图片的横分割数
  63.     @base_height = N01::ANIME_KIND     # 图片的纵分割数
  64.     @width = 0                         # 横矩形
  65.     @height = 0                        # 纵矩形
  66.     @picture_time = 0                  # 图片显示时间
  67.     @individual_targets = []           # 单独处理的保持目标
  68.     @balloon_duration = 65             # 飞出动画时间
  69.     @reverse = false                   # 动画的反向再生标志
  70.     # 角色不存在的时候将中断处理
  71.     return @battler_visible = false if @battler == nil
  72.     # 角色是主人公时、或者敌方动画为NO时
  73.     @anime_flug = true if @battler.actor?
  74.     @anime_flug = true if [email protected]? && @battler.anime_on
  75.     # 角色作成
  76.     make_battler
  77.   end
  78.   #--------------------------------------------------------------------------
  79.   # ● 角色作成
  80.   #--------------------------------------------------------------------------
  81.   def make_battler
  82.     # 初期配置的取得
  83.     @battler.base_position
  84.     # 色相通过角色认别
  85.     @battler_hue = @battler.battler_hue
  86.     # 角色是主人公时、或者敌方动画为NO时
  87.     if @anime_flug
  88.       # 准备武器
  89.       @weapon_R = Sprite_Weapon.new(viewport,@battler)
  90.       # 取得我方人物名、敌人角色名
  91.       @battler_name = @battler.character_name if @battler.actor?
  92.       @battler_name = @battler.battler_name unless @battler.actor?
  93.       # 敌方反转为NO的时候 画像被反转
  94.       self.mirror = true if [email protected]? && @battler.action_mirror
  95.       # 是不是利用行图片图来改变转送前的矩形尺寸的认识处
  96.       self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
  97.       self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
  98.       # 获取转送前的矩形
  99.       @width = self.bitmap.width / @base_width
  100.       @height = self.bitmap.height / @base_height
  101.       # 矩形设定
  102.       @sx = @pattern * @width
  103.       @sy = @anime_kind * @height
  104.       # 角色本体的描绘
  105.       self.src_rect.set(@sx, @sy, @width, @height)
  106.     # 不作动画的角色时
  107.     else
  108.       # bitmap的获取、设定
  109.       @battler_name = @battler.battler_name
  110.       self.bitmap = Cache.battler(@battler_name, @battler_hue)
  111.       @width = bitmap.width
  112.       @height = bitmap.height
  113.     end
  114.     # 偷袭时画像反转
  115.     self.mirror = false if self.mirror && $back_attack && N01::BACK_ATTACK
  116.     self.mirror = true if $back_attack && !self.mirror && N01::BACK_ATTACK
  117.     # 位置初期化
  118.     @battler.reset_coordinate
  119.     # 决定原点
  120.     self.ox = @width / 2
  121.     self.oy = @height * 2 / 3
  122.     # 设定偷袭时的坐标
  123.     update_move
  124.     # 准备飞出动画的精灵
  125.     @move_anime = Sprite_MoveAnime.new(viewport,battler)
  126.     # 准备图片用精灵
  127.     @picture = Sprite.new
  128.     # 准备影子精灵
  129.     make_shadow if N01::SHADOW
  130.     # 作成伤害精灵
  131.     @damage = Sprite_Damage.new(viewport,battler)
  132.   end
  133.   #--------------------------------------------------------------------------
  134.   # ● 影作成
  135.   #--------------------------------------------------------------------------
  136.   def make_shadow
  137.     @shadow.dispose if @shadow != nil
  138.     @battler_hue = @battler.battler_hue
  139.     @shadow = Sprite.new(viewport)
  140.     @shadow.z = 200
  141.     @shadow.visible = false
  142.     # 准备角色的影子精灵
  143.     @shadow.bitmap = Cache.character(@battler.shadow)
  144.     @shadow_height = @shadow.bitmap.height
  145.     # 影位置的稍微调整
  146.     @shadow_plus_x = @battler.shadow_plus[0] - @width / 2
  147.     @shadow_plus_y = @battler.shadow_plus[1]
  148.     # 配合角色画像的大小使用影画像
  149.     @shadow.zoom_x = @width * 1.0 / @shadow.bitmap.width
  150.     # 更新
  151.     update_shadow
  152.     # fade中影子就像没有关联一样放置
  153.     @skip_shadow = true
  154.   end
  155.   #--------------------------------------------------------------------------
  156.   # ● 解放
  157.   #--------------------------------------------------------------------------
  158.   def dispose
  159.     self.bitmap.dispose if self.bitmap != nil
  160.     @weapon_R.dispose if @weapon_R != nil
  161.     @move_anime.dispose if @move_anime != nil
  162.     @picture.dispose if @picture != nil
  163.     @shadow.dispose if @shadow != nil
  164.     @damage.dispose if @damage != nil
  165.     @balloon.dispose if @balloon != nil
  166.     mirage_off
  167.     super
  168.   end  
  169.   #--------------------------------------------------------------------------
  170.   # ● 伤害动作  action = [动画ID,反转标志,反方向许可]
  171.   #--------------------------------------------------------------------------
  172.   def damage_action(action)
  173.     damage = @battler.hp_damage
  174.     damage = @battler.mp_damage if @battler.mp_damage != 0
  175.     # 如果HP和MP两个同时做出伤害
  176.     if @battler.hp_damage != 0 && @battler.mp_damage != 0
  177.       @battler.double_damage = true
  178.       damage = @battler.hp_damage
  179.     end  
  180.     # 吸收攻击使HP为0的处理
  181.     if action[0] == "absorb"
  182.       absorb = true
  183.       action[0] = nil
  184.     end
  185.     # 只有在命中时动画才被执行
  186.     unless @battler.evaded or @battler.missed or action[0] == nil
  187.       @battler.animation_id = action[0]
  188.       @battler.animation_mirror = action[1]
  189.     end
  190.     # 执行伤害动画
  191.     start_action(@battler.damage_hit) if damage > 0 && action[2]
  192.     # 攻击没有命中时执行回避动画
  193.     if @battler.evaded or @battler.missed
  194.       start_action(@battler.evasion) if action[2]
  195.       Sound.play_evasion
  196.     end
  197.     @damage.damage_pop unless absorb or action[3] != nil
  198.   end
  199.   #--------------------------------------------------------------------------
  200.   # ● 伤害数值POP
  201.   #--------------------------------------------------------------------------
  202.   def damage_pop(damage)
  203.     @damage.damage_pop(damage)
  204.   end  
  205.   #--------------------------------------------------------------------------
  206.   # ● 战斗开始行动
  207.   #--------------------------------------------------------------------------
  208.   def first_action
  209.     # 检查能否行动、只有在不能的情况下那个状态的动作开始
  210.     action = @battler.first_action unless @battler.restriction == 4
  211.     action = $data_states[@battler.state_id].base_action if @battler.states[0] != nil && @battler.restriction == 4
  212.     start_action(action)
  213.     @skip_shadow = false
  214.   end
  215.   #--------------------------------------------------------------------------
  216.   # ● 动作开始
  217.   #--------------------------------------------------------------------------
  218.   def start_action(kind)
  219.     # 初期化各种动作
  220.     reset
  221.     #记录现在取得的待机动作
  222.     stand_by
  223.     # 决定新的动作内容
  224.     @action = N01::ACTION[kind].dup
  225.     # 从行动配列的前头开始移动
  226.     active = @action.shift
  227.     # 自动完毕
  228.     @action.push("完毕")
  229.     # 确定现在的动作
  230.     @active_action = N01::ANIME[active]
  231.     # 等待设定
  232.     @wait = active.to_i if @active_action == nil
  233.     # 单独动作开始
  234.     action
  235.   end
  236.   #--------------------------------------------------------------------------
  237.   # ● 强制单独动作开始
  238.   #--------------------------------------------------------------------------
  239.   def start_one_action(kind,back)
  240.     # 初期化各种动作
  241.     reset
  242.     # 记录现在取得的待机动作
  243.     stand_by
  244.     # 设置坐标初始化动作
  245.     @action = [back]
  246.     # 自动完毕
  247.     @action.push("完毕")
  248.     # 确定现在的动作
  249.     @active_action = N01::ANIME[kind]
  250.     # 单独动作开始
  251.     action
  252.   end
  253.   #--------------------------------------------------------------------------
  254.   # ● 到下一个动作
  255.   #--------------------------------------------------------------------------
  256.   def next_action
  257.     # 等待中时取消
  258.     return @wait -= 1 if @wait > 0
  259.     # 或者全部图片动画没有被完成时取消
  260.     return if @anime_end == false
  261.     # 最后的图片显示等待
  262.     return @unloop_wait -= 1 if @unloop_wait > 0
  263.     # 从行动配列的前头开始移动
  264.     active = @action.shift
  265.     # 确定现在的动作
  266.     @active_action = N01::ANIME[active]
  267.     # 等待设定
  268.     @wait = active.to_i if @active_action == nil
  269.     # 单独动作开始
  270.     action
  271.   end
  272.   #--------------------------------------------------------------------------
  273.   # ● 待机动作
  274.   #--------------------------------------------------------------------------
  275.   def stand_by
  276.     # 到通常待机
  277.     @repeat_action = @battler.normal
  278.     # HP为1/4时显示危急表情
  279.     @repeat_action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
  280.     # 防御中
  281.     @repeat_action = @battler.defence if @battler.guarding?
  282.     # 如果什么状态都没有时完毕
  283.     return if @battler.state_id == nil
  284.     for state in @battler.states.reverse
  285.       # 动作禁止的状态时跳过处理
  286.       next if state.extension.include?("禁止状态动作")
  287.       # 敌方被动作禁止状态时跳过处理
  288.       next if @battler.is_a?(Game_Enemy) && state.extension.include?("敌方除外")
  289.       # 状态的表情
  290.       @repeat_action = state.base_action
  291.     end
  292.   end
  293.   #--------------------------------------------------------------------------
  294.   # ● 待机动作的插入
  295.   #--------------------------------------------------------------------------
  296.   def push_stand_by
  297.     action = @battler.normal
  298.     action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
  299.     action = @battler.defence if @battler.guarding?
  300.     for state in @battler.states.reverse
  301.       # 动作禁止的状态时跳过处理
  302.       next if state.extension.include?("禁止状态动作")
  303.       # 敌方被动作禁止状态时跳过处理
  304.       next if @battler.is_a?(Game_Enemy) && state.extension.include?("敌方除外")
  305.       # 状态的表情
  306.       action = state.base_action
  307.     end
  308.     @repeat_action = action
  309.     # 插入
  310.     @action.delete("完毕")
  311.     act = N01::ACTION[action].dup
  312.     for i in 0...act.size
  313.       @action.push(act[i])
  314.     end  
  315.     @action.push("完毕")
  316.     @anime_end = true
  317.   end
  318.   #--------------------------------------------------------------------------
  319.   # ● 各种变化的初期化
  320.   #--------------------------------------------------------------------------
  321.   def reset
  322.     self.zoom_x = self.zoom_y = 1
  323.     self.oy = @height * 2 / 3
  324.     @angle = self.angle = 0
  325.     @anime_end = true
  326.     @non_repeat = false
  327.     @anime_freeze = false
  328.     @unloop_wait = 0
  329.   end  
  330.   #--------------------------------------------------------------------------
  331.   # ● 跳跃的初期化
  332.   #--------------------------------------------------------------------------
  333.   def jump_reset
  334.     @battler.jump = @jump_time = @jump_time_plus = @jump_up = @jump_down = 0
  335.     @jump_size = @jump_plus = @float_time = @float_up = 0
  336.   end
  337.   #--------------------------------------------------------------------------
  338.   # ● 受取目标情报
  339.   #--------------------------------------------------------------------------
  340.   def get_target(target)
  341.     # 单独处理中是中止(全区域中自身被卷入时目标情报是不是正常的样子)
  342.     return if @battler.individual
  343.     @target_battler = target
  344.   end
  345.   #--------------------------------------------------------------------------
  346.   # ● 动作情报在角色中收藏
  347.   #--------------------------------------------------------------------------
  348.   def send_action(action)
  349.     @battler.play = 0
  350.     @battler.play = action if @battler.active
  351.   end
  352.   #--------------------------------------------------------------------------
  353.   # ● 角色追加
  354.   #--------------------------------------------------------------------------
  355.   def battler_join
  356.     if @battler.exist? && !@battler_visible
  357.       # 从战斗不能的復活时的处理被跳过
  358.       if @battler.revival && @anime_flug
  359.         return @battler.revival = false
  360.       elsif @battler.revival && !@anime_flug
  361.         @battler.revival = false
  362.         self.visible = true
  363.         return
  364.       end  
  365.       @anime_flug = true if @battler.actor?
  366.       @anime_flug = true if [email protected]? && @battler.anime_on
  367.       make_battler
  368.       @damage = Sprite_Damage.new(viewport,battler)
  369.       @join = true
  370.       first_action
  371.     end
  372.   end
  373.   #--------------------------------------------------------------------------
  374.   # ● 图片更新　※再定义
  375.   #--------------------------------------------------------------------------
  376.   def update
  377.     super
  378.     # 角色不存在时跳过
  379.     return self.bitmap = nil if @battler == nil
  380.     # 追加角色
  381.     battler_join
  382.     # 到下一个动作
  383.     next_action
  384.     # 动画图像更新
  385.     update_anime_pattern
  386.     # 目标更新
  387.     update_target
  388.     # 强制动作更新
  389.     update_force_action
  390.     # 坐标更新
  391.     update_move
  392.     # 影更新
  393.     update_shadow if @shadow != nil
  394.     # 武器更新
  395.     @weapon_R.update if @weapon_action
  396.     # 漂浮更新
  397.     update_float if @float_time > 0
  398.     # 旋转更新
  399.     update_angle if @angle_time > 0
  400.     # 放大缩小更新
  401.     update_zoom if @zoom_time > 0
  402.     # 残像更新
  403.     update_mirage if @mirage_flug
  404.     # 图片更新
  405.     update_picture if @picture_time > 0
  406.     # 飞出动画更新
  407.     update_move_anime if @anime_moving
  408.     # 飞出动画更新（图片动画）
  409.     update_balloon if @balloon_duration <= 64
  410.     # 伤害精灵更新
  411.     @damage.update if @damage != nil
  412.     setup_new_effect
  413.     update_effect
  414.     update_battler_bitmap
  415.   end
  416.   #--------------------------------------------------------------------------
  417.   # ● 动画图像更新
  418.   #--------------------------------------------------------------------------
  419.   def update_anime_pattern
  420.     # 更新时间在到之前跳过
  421.     return @frame -= 1 if @frame != 0
  422.     # 只有在必要的时候更新武器动画
  423.     @weapon_R.action if @weapon_action && @weapon_R != nil
  424.     # 动画到最后是检查是否是循环
  425.     if @pattern_back
  426.       # 往返循环
  427.       if @anime_loop == 0
  428.         # 反向再生
  429.         if @reverse
  430.           @pattern += 1
  431.           if @pattern == @base_width - 1
  432.             @pattern_back = false
  433.             @anime_end = true
  434.           end
  435.         # 通常再生
  436.         else  
  437.           @pattern -= 1
  438.           if @pattern == 0
  439.             @pattern_back = false
  440.             @anime_end = true
  441.           end  
  442.         end  
  443.       # 单程或者是不循环时
  444.       else
  445.         @anime_end = true
  446.         if @anime_loop == 1
  447.           @pattern = 0 if !@reverse
  448.           @pattern = @base_width - 1 if @reverse
  449.           @pattern_back = false
  450.         end  
  451.       end  
  452.     # 推进动画   
  453.     else
  454.       if @reverse
  455.         @pattern -= 1
  456.         @pattern_back = true if @pattern == 0
  457.       else  
  458.         @pattern += 1
  459.         @pattern_back = true if @pattern == @base_width - 1
  460.       end  
  461.     end
  462.     # 初期化更新时间
  463.     @frame = @anime_speed
  464.     # 动画固定时，固定横矩形
  465.     return if @anime_freeze
  466.     # 设定转送处的矩形
  467.     return unless @anime_flug
  468.     @sx = @pattern * @width
  469.     @sy = @anime_kind * @height
  470.     self.src_rect.set(@sx, @sy, @width, @height)
  471.   end
  472.   #--------------------------------------------------------------------------
  473.   # ● 目标更新 action = ["N01target_change",目标情报]
  474.   #--------------------------------------------------------------------------
  475.   def update_target
  476.     # 目标确认
  477.     return if @battler.force_target == 0
  478.     # 单独处理中中止(全区域中自身被卷入时目标情报是不是)
  479.     return if @battler.individual
  480.     @target_battler = @battler.force_target[1]
  481.     @battler.force_target = 0
  482.   end  
  483.   #--------------------------------------------------------------------------
  484.   # ● 強制动作更新 action = [识别,复原,实行动作]
  485.   #--------------------------------------------------------------------------
  486.   def update_force_action
  487.     # 确认強制动作
  488.     action = @battler.force_action
  489.     return if action == 0
  490.     @battler.force_action = 0
  491.     # 主动中不能插入
  492.     return if @battler.active
  493.     # 击倒时就那样直接连接行动
  494.     return collapse_action if action[0] == "N01collapse"
  495.     # 单独时就那样直接连接
  496.     return start_one_action(action[2],action[1]) if action[0] == "单独"
  497.     # 通用作为动作对待
  498.     start_action(action[2])
  499.     # 有无坐标复原
  500.     return if action[1] == ""
  501.     # 完毕位置替换成重复动作
  502.     @action.delete("完毕")
  503.     @action.push(action[1])
  504.     @action.push("完毕")
  505.   end   
  506.   #--------------------------------------------------------------------------
  507.   # ● 坐标更新
  508.   #--------------------------------------------------------------------------
  509.   def update_move
  510.     # 补完加减速中距离的增减
  511.     if @move_speed_plus_x > 0
  512.       # 计算移动
  513.       @move_x += @moving_x
  514.       # 实行移动
  515.       @battler.move_x = @move_x
  516.       @move_speed_plus_x -= 1
  517.     elsif @move_speed_x > 0
  518.       # 加速时
  519.       if @move_boost_x != 0
  520.         @moving_x += @move_boost_x
  521.       end  
  522.       # 计算移动
  523.       @move_x += @moving_x
  524.       # 实行移动
  525.       @battler.move_x = @move_x
  526.       @move_speed_x -= 1
  527.     end
  528.     # 补完加减速中距离的增减
  529.     if @move_speed_plus_y > 0
  530.       # 计算移动
  531.       @move_y += @moving_y
  532.       # 实行移动
  533.       @battler.move_y = @move_y
  534.       @move_speed_plus_y -= 1
  535.     elsif @move_speed_y > 0
  536.       # 加速时
  537.       if @move_boost_y != 0
  538.         @moving_y += @move_boost_y
  539.       end  
  540.       # 计算移动
  541.       @move_y += @moving_y
  542.       # 实行移动
  543.       @battler.move_y = @move_y
  544.       @move_speed_y -= 1
  545.     end
  546.     # 跳跃上升
  547.     if @jump_up != 0
  548.       # 计算移动
  549.       @jump_plus += @jump_up
  550.       # 实行移动
  551.       @battler.jump = @jump_plus
  552.       @jump_up = @jump_up / 2
  553.       @jump_time -= 1
  554.       # 如果跳跃到了顶点时
  555.       if @jump_time == 0 or @jump_up == @jump_sign
  556.         @jump_down = @jump_up * 2 * @jump_sign * @jump_sign2
  557.         @jump_time_plus += @jump_time * 2
  558.         @jump_up = 0
  559.         return
  560.       end  
  561.     end  
  562.     # 跳跃下降
  563.     if @jump_down != 0
  564.       if @jump_time_plus != 0
  565.         @jump_time_plus -= 1
  566.       elsif @jump_down != @jump_size
  567.         # 计算移动
  568.         @jump_plus += @jump_down
  569.         # 实行移动
  570.         @battler.jump = @jump_plus
  571.         @jump_down = @jump_down * 2
  572.         if @jump_down == @jump_size
  573.           if @jump_flug
  574.             @jump_flug = false
  575.           else
  576.             # 计算移动
  577.             @jump_plus += @jump_down
  578.             # 实行移动
  579.             @battler.jump = @jump_plus
  580.             @jump_down = @jump_size = 0
  581.           end
  582.         end  
  583.       end
  584.     end
  585.     # 设定精灵的坐标
  586.     self.x = @battler.position_x
  587.     self.y = @battler.position_y
  588.     self.z = @battler.position_z
  589.   end
  590.   #--------------------------------------------------------------------------
  591.   # ● 影更新
  592.   #--------------------------------------------------------------------------
  593.   def update_shadow
  594.     @shadow.opacity = self.opacity
  595.     @shadow.x = self.x + @shadow_plus_x
  596.     @shadow.y = self.y + @shadow_plus_y - @jump_plus
  597.   end
  598.   #--------------------------------------------------------------------------
  599.   # ● 漂浮更新
  600.   #--------------------------------------------------------------------------
  601.   def update_float
  602.     @float_time -= 1
  603.     @jump_plus += @float_up
  604.     @battler.jump = @jump_plus
  605.   end   
  606.   #--------------------------------------------------------------------------
  607.   # ● 旋转更新
  608.   #--------------------------------------------------------------------------
  609.   def update_angle
  610.     # 实行旋转
  611.     @angle += @angling
  612.     self.angle = @angle
  613.     @angle_time -= 1
  614.     # 旋转时间结束时项目初始化
  615.     return @angle = 0 if @angle_time == 0
  616.     # 如果有复原标志时角度返回0
  617.     self.angle = 0 if @angle_reset
  618.   end  
  619.   #--------------------------------------------------------------------------
  620.   # ● 扩大缩小更新
  621.   #--------------------------------------------------------------------------
  622.   def update_zoom
  623.     # 实行扩大缩小
  624.     @zoom_x += @zooming_x
  625.     @zoom_y += @zooming_y
  626.     self.zoom_x = @zoom_x
  627.     self.zoom_y = @zoom_y
  628.     @zoom_time -= 1
  629.     # 扩大缩小时间结束时项目初始化
  630.     return if @zoom_time != 0
  631.     @zoom_x = @zoom_y = 0
  632.     self.oy = @height * 2 / 3
  633.     # 如果有复原标志时还原
  634.     self.zoom_x = self.zoom_y = 1 if @zoom_reset
  635.   end  
  636.   #--------------------------------------------------------------------------
  637.   # ● 残像更新
  638.   #--------------------------------------------------------------------------
  639.   def update_mirage
  640.     # 残像最大能显示3个、2格图片中更新
  641.     mirage(@mirage0) if @mirage_count == 1
  642.     mirage(@mirage1) if @mirage_count == 3
  643.     mirage(@mirage2) if @mirage_count == 5
  644.     @mirage_count += 1
  645.     @mirage_count = 0 if @mirage_count == 6
  646.   end
  647.   #--------------------------------------------------------------------------
  648.   # ● 图片更新
  649.   #--------------------------------------------------------------------------
  650.   def update_picture
  651.     @picture_time -= 1
  652.     @picture.x += @moving_pic_x
  653.     @picture.y += @moving_pic_y
  654.   end  
  655.   #--------------------------------------------------------------------------
  656.   # ● 飞出动画 更新
  657.   #--------------------------------------------------------------------------
  658.   def update_move_anime
  659.     @move_anime.update
  660.     @anime_moving = false if @move_anime.finish?
  661.     @move_anime.action_reset if @move_anime.finish?
  662.   end  
  663.   #--------------------------------------------------------------------------
  664.   # ● 崩坏效果的更新　※再定义
  665.   #--------------------------------------------------------------------------
  666.   def update_collapse
  667.     normal_collapse if @collapse_type == 2
  668.     boss_collapse1 if @collapse_type == 3
  669.   end
  670.   #--------------------------------------------------------------------------
  671.   # ● 飞出动画更新 （图片动画）
  672.   #--------------------------------------------------------------------------
  673.   def update_balloon
  674.     @balloon_duration -= 1 if @balloon_duration > 0 && !@balloon_back
  675.     @balloon_duration += 1 if @balloon_back
  676.     if @balloon_duration == 64
  677.       @balloon_back = false
  678.       @balloon.visible = false
  679.     elsif @balloon_duration == 0
  680.       @balloon.visible = false if @balloon_loop == 0
  681.       @balloon_back = true if @balloon_loop == 1
  682.     end   
  683.     @balloon.x = self.x
  684.     @balloon.y = self.y
  685.     @balloon.z = 10
  686.     @balloon.opacity = self.opacity
  687.     sx = 7 * 32 if @balloon_duration < 12
  688.     sx = (7 - (@balloon_duration - 12) / 8) * 32 unless @balloon_duration < 12
  689.     @balloon.src_rect.set(sx, @balloon_id * 32, 32, 32)
  690.   end
  691.   #--------------------------------------------------------------------------
  692.   # ● 转送处bitmap的更新 ※再定义
  693.   #--------------------------------------------------------------------------
  694.   def update_battler_bitmap
  695.     return if @battler.actor?
  696.     if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
  697.       @battler_name = @battler.battler_name
  698.       @battler_hue = @battler.battler_hue
  699.       make_battler
  700.       self.opacity = 0 if @battler.dead? or @battler.hidden
  701.     end
  702.   end
  703.   #--------------------------------------------------------------------------
  704.   # ● 实行动作
  705.   #--------------------------------------------------------------------------
  706.   def action
  707.     return if @active_action == nil
  708.     action = @active_action[0]
  709.     # 反转时
  710.     return mirroring if action == "反转"
  711.     # 旋转时  
  712.     return angling if action == "angle"
  713.     # 扩大缩小时  
  714.     return zooming if action == "zoom"
  715.     # 残像ON时
  716.     return mirage_on if action == "残像ON"
  717.     # 残像OFF时
  718.     return mirage_off if action == "残像OFF"
  719.     # 图片表示时
  720.     return picture if action == "pic"
  721.     # 图片消去时
  722.     return @picture.visible = false && @picture_time = 0 if action == "消去图片"
  723.     # 图片文件变更时  
  724.     return graphics_change if action == "change"
  725.     # 战斗动画表示时  
  726.     return battle_anime if action == "anime"
  727.     # 飞出动画表示时 （图片动画）
  728.     return balloon_anime if action == "balloon"
  729.     # BGM/BGS/SE演奏时  
  730.     return sound if action == "sound"
  731.     # 游戏开关操作时  
  732.     return $game_switches[@active_action[1]] = @active_action[2] if action == "switch"
  733.     # 游戏变量操作时  
  734.     return variable if action == "variable"
  735.     # 二刀限定时
  736.     return two_swords if action == "二刀限定"
  737.     # 非二刀限定时
  738.     return non_two_swords if action == "非二刀限定"
  739.     # 动作条件时
  740.     return necessary if action == "nece"
  741.     # 技能连发时  
  742.     return derivating if action == "der"
  743.     # 单独处理开始时
  744.     return individual_action if action == "个别处理开始"
  745.     # 单独处理完毕时
  746.     return individual_action_end if action == "个别处理完毕"
  747.     # 待机不能移动时
  748.     return non_repeat if action == "待机不能移动"
  749.     # 变更初期位置时
  750.     return @battler.change_base_position(self.x, self.y) if action == "变更初期位置"
  751.     # 解除变更初期位置
  752.     return @battler.base_position if action == "解除变更初期位置"
  753.     # 变更目标时  
  754.     return change_target if action == "target"
  755.     # 目标的击倒许可
  756.     return send_action(action) if action == "击倒许可"
  757.     # 解除主动
  758.     return send_action(action) if action == "解除主动"
  759.     # 赋予状态时  
  760.     return state_on if action == "sta+"
  761.     # 解除状态时  
  762.     return state_off if action == "sta-"
  763.     # 变更游戏整体的行进速度时
  764.     return Graphics.frame_rate = @active_action[1] if action == "fps"
  765.     # 漂浮时  
  766.     return floating if action == "float"
  767.     # 脚本操作时   
  768.     return eval(@active_action[1]) if action == "script"
  769.     # 强制动作时  
  770.     return force_action if @active_action.size == 4
  771.     # 坐标初始化时  
  772.     return reseting if @active_action.size == 5
  773.     # 移动时
  774.     return moving if @active_action.size == 7
  775.     # 角色动画时
  776.     return battler_anime if @active_action.size == 9
  777.     # 动画飛ばし时
  778.     return moving_anime if @active_action.size == 11
  779.     # 完毕时
  780.     return anime_finish if action == "完毕"
  781.   end
  782.   #--------------------------------------------------------------------------
  783.   # ● 实行反转
  784.   #--------------------------------------------------------------------------
  785.   def mirroring  
  786.     # 如果已经反转就还原
  787.     if self.mirror
  788.       self.mirror = false
  789.       # 武器动画也反映
  790.       @weapon_R.mirroring if @anime_flug
  791.     else
  792.       self.mirror = true
  793.       # 武器动画也反映
  794.       @weapon_R.mirroring if @anime_flug
  795.     end
  796.   end  
  797.   #--------------------------------------------------------------------------
  798.   # ● 实行旋转
  799.   #--------------------------------------------------------------------------
  800.   def angling  
  801.     # 初期化跳跃
  802.     jump_reset
  803.     # 情报确认
  804.     @angle_time = @active_action[1]
  805.     start_angle = @active_action[2]
  806.     end_angle = @active_action[3]
  807.     @angle_reset = @active_action[4]
  808.     # 袭击時时逆转
  809.     start_angle *= -1 if $back_attack
  810.     end_angle *= -1 if $back_attack
  811.     # 敌方被逆转
  812.     start_angle *= -1 if @battler.is_a?(Game_Enemy)
  813.     end_angle *= -1 if @battler.is_a?(Game_Enemy)
  814.     # 时间要是0以下时立即到最后角度
  815.     if @angle_time <= 0
  816.       self.angle = end_angle
  817.       return  @angle_time = 0
  818.     end  
  819.     # 从旋转时间计算一格相当于的角度
  820.     @angling = (end_angle - start_angle) / @angle_time
  821.     # 不能整除的剩余到初期角度
  822.     @angle = (end_angle - start_angle) % @angle_time + start_angle
  823.   end
  824.   #--------------------------------------------------------------------------
  825.   # ● 实行放大缩小
  826.   #--------------------------------------------------------------------------
  827.   def zooming  
  828.     # 初期化跳跃
  829.     jump_reset
  830.     # 情报确认
  831.     @zoom_time = @active_action[1]
  832.     zoom_x = @active_action[2] - 1
  833.     zoom_y = @active_action[3] - 1
  834.     @zoom_reset = @active_action[4]
  835.     @zoom_x = @zoom_y = 1
  836.     # 时间是0以下时跳过
  837.     return @zoom_time = 0 if @zoom_time <= 0
  838.     # 从放大时间中计算一格相当于的放大率
  839.     @zooming_x = zoom_x / @zoom_time
  840.     @zooming_y = zoom_y / @zoom_time
  841.   end  
  842.   #--------------------------------------------------------------------------
  843.   # ● 残像开始
  844.   #--------------------------------------------------------------------------
  845.   def mirage_on
  846.     # 战斗不能時不表现残像
  847.     return if @battler.dead?
  848.     @mirage0 = Sprite.new(self.viewport)
  849.     @mirage1 = Sprite.new(self.viewport)
  850.     @mirage2 = Sprite.new(self.viewport)
  851.     @mirage_flug = true
  852.     @mirage_count = 0
  853.   end  
  854.   #--------------------------------------------------------------------------
  855.   # ● 残像表示
  856.   #--------------------------------------------------------------------------
  857.   def mirage(body)
  858.     body.bitmap = self.bitmap.dup
  859.     body.x = self.x
  860.     body.y = self.y
  861.     body.ox = self.ox
  862.     body.oy = self.oy
  863.     body.z = self.z
  864.     body.mirror = self.mirror
  865.     body.angle = @angle
  866.     body.opacity = 160
  867.     body.zoom_x = self.zoom_x
  868.     body.zoom_y = self.zoom_y   
  869.     body.src_rect.set(@sx, @sy, @width, @height) if @anime_flug
  870.     body.src_rect.set(0, 0, @width, @height) unless @anime_flug
  871.   end   
  872.   #--------------------------------------------------------------------------
  873.   # ● 残像完毕
  874.   #--------------------------------------------------------------------------
  875.   def mirage_off
  876.     @mirage_flug = false
  877.     @mirage0.dispose if @mirage0 != nil
  878.     @mirage1.dispose if @mirage1 != nil
  879.     @mirage2.dispose if @mirage2 != nil
  880.   end   
  881.   #--------------------------------------------------------------------------
  882.   # ● 图片表示
  883.   #--------------------------------------------------------------------------
  884.   def picture
  885.     # 确认移动开始位置
  886.     pic_x = @active_action[1]
  887.     pic_y = @active_action[2]
  888.     # 确认移动完毕位置
  889.     pic_end_x = @active_action[3]
  890.     pic_end_y = @active_action[4]
  891.     @picture_time = @active_action[5]
  892.     # 用时间除、计算一个相当于的移动速度
  893.     @moving_pic_x = (pic_end_x - pic_x)/ @picture_time
  894.     @moving_pic_y = (pic_end_y - pic_y)/ @picture_time
  895.     # 不能整除时到最初上加算
  896.     plus_x = (pic_end_x - pic_x)% @picture_time
  897.     plus_y = (pic_end_y - pic_y)% @picture_time
  898.     # 图片表示
  899.     @picture.bitmap = Cache.picture(@active_action[7])
  900.     @picture.x = pic_x + plus_x
  901.     @picture.y = pic_y + plus_y
  902.     # Z坐标调整
  903.     @picture.z = 1
  904.     @picture.z = 1000 if @active_action[6]
  905.     @picture.visible = true
  906.   end
  907.   #--------------------------------------------------------------------------
  908.   # ● 图像文件变更
  909.   #--------------------------------------------------------------------------
  910.   def graphics_change  
  911.     # 主人公限定
  912.     return if @battler.is_a?(Game_Enemy)
  913.     # 图像变更
  914.     @battler_name = @active_action[2]
  915.     # 是否使用歩行图像中改变转送处的矩形大小的辨别处
  916.     self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
  917.     self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
  918.     # 获取转送处的矩形
  919.     @width = self.bitmap.width / @base_width
  920.     @height = self.bitmap.height / @base_height
  921.     # 如果想让战斗后的人物图也显示为变更后的化在这里修改
  922.     @battler.graphic_change(@active_action[2]) unless @active_action[1]
  923.   end  
  924.   #--------------------------------------------------------------------------
  925.   # ● 显示战斗动画 [判別,ID,对象,反转,等待,二刀标志]
  926.   #--------------------------------------------------------------------------
  927.   def battle_anime
  928.     # 取消敌人的二刀标志动画处理
  929.     return if @active_action[5] && [email protected]?
  930.     # 不是二刀的角色，取消二刀标志动画处理
  931.     return if @active_action[5] && @battler.weapons[1] == nil
  932.     # 如果二刀为右手（上面设置过）无武器只有左手(下面设置)持有时
  933.     if @battler.actor?
  934.       return if !@active_action[5] && @battler.weapons[0] == nil && @battler.weapons[1] != nil
  935.     end
  936.     anime_id = @active_action[1]
  937.     # 偷袭时动画画像被反转
  938.     if $back_attack
  939.       mirror = true if @active_action[3] == false
  940.       mirror = false if @active_action[3]
  941.     end
  942.     # 武器和技能动画时
  943.     if anime_id < 0
  944.       # 用行动的种类分歧动画处
  945.       if @battler.action.skill? && anime_id != -2
  946.         anime_id = @battler.action.skill.animation_id
  947.       elsif @battler.action.item? && anime_id != -2
  948.         anime_id = @battler.action.item.animation_id
  949.       else
  950.         # 没有武器时使用空手动画
  951.         anime_id = N01::NO_WEAPON
  952.         if @battler.actor?
  953.           weapon_id = @battler.weapon_id
  954.           anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
  955.           # 二刀动画时
  956.           anime_id = @battler.atk_animation_id2 if @active_action[5]
  957.         else
  958.           weapon_id = @battler.weapon
  959.           anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
  960.         end
  961.       end
  962.       # 等待設定
  963.       @wait = $data_animations[anime_id].frame_max * 4 if $data_animations[anime_id] != nil && @active_action[4]
  964.       waitflug = true
  965.       # 显示伤害动画时、为了先计算出伤害計算而中断处理
  966.       damage_action = [anime_id, mirror, true]
  967.       return @battler.play = ["对象动画",damage_action] if @battler.active
  968.     end
  969.     # 实行动画
  970.     if @active_action[2] == 0 && $data_animations[anime_id] != nil
  971.       @battler.animation_id = anime_id
  972.       @battler.animation_mirror = mirror
  973.     elsif $data_animations[anime_id] != nil
  974.       for target in @target_battler
  975.         target.animation_id = anime_id
  976.         target.animation_mirror = mirror
  977.       end  
  978.     end
  979.     # 等待设定
  980.     @wait = $data_animations[anime_id].frame_max * 4 if $data_animations[anime_id] != nil && @active_action[4] && !waitflug
  981.   end
  982.   #--------------------------------------------------------------------------
  983.   # ● 显示飞出动画 （图片动画）
  984.   #--------------------------------------------------------------------------
  985.   def balloon_anime
  986.     return if self.opacity == 0
  987.     if @balloon == nil
  988.       @balloon = Sprite.new
  989.       @balloon.bitmap = Cache.system("Balloon")
  990.       @balloon.ox = @width / 16
  991.       @balloon.oy = @balloon.height / 10 + @height / 3
  992.     end
  993.     @balloon_id = @active_action[1]
  994.     @balloon_loop = @active_action[2]
  995.     @balloon_duration = 64
  996.     @balloon_back = false
  997.     update_balloon
  998.     @balloon.visible = true
  999.   end  
  1000.   #--------------------------------------------------------------------------
  1001.   # ● BGM/BGS/SE演奏
  1002.   #--------------------------------------------------------------------------
  1003.   def sound   
  1004.     # 获取情报
  1005.     pitch = @active_action[2]
  1006.     vol =  @active_action[3]
  1007.     name = @active_action[4]
  1008.     # 实行
  1009.     case @active_action[1]
  1010.     when "se"
  1011.       Audio.se_play("Audio/SE/" + name, vol, pitch)
  1012.     when "bgm"
  1013.       # 没有指定名字时、不改变现在的BGM
  1014.       if @active_action[4] == ""
  1015.         now_bgm = RPG::BGM.last
  1016.         name = now_bgm.name
  1017.       end
  1018.       Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
  1019.     when "bgs"
  1020.       # 没有指定名字时、不改变现在的BGS
  1021.       if @active_action[4] == ""
  1022.         now_bgs = RPG::BGS.last
  1023.         name = now_bgs.name
  1024.       end
  1025.       Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
  1026.     end
  1027.   end
  1028.   #--------------------------------------------------------------------------
  1029.   # ● 游戏变量操作
  1030.   #--------------------------------------------------------------------------
  1031.   def variable
  1032.     # 检查操作
  1033.     operand = @active_action[3]
  1034.     # 变数操作的分歧
  1035.     case @active_action[2]
  1036.     when 0 # 代入
  1037.       $game_variables[@active_action[1]] = operand
  1038.     when 1 # 加算
  1039.       $game_variables[@active_action[1]] += operand
  1040.     when 2 # 減算
  1041.       $game_variables[@active_action[1]] -= operand
  1042.     when 3 # 乗算
  1043.       $game_variables[@active_action[1]] *= operand
  1044.     when 4 # 除算
  1045.       $game_variables[@active_action[1]] /= operand
  1046.     when 5 # 剰余
  1047.       $game_variables[@active_action[1]] %= operand
  1048.     end
  1049.   end  
  1050.   #--------------------------------------------------------------------------
  1051.   # ● 二刀限定
  1052.   #--------------------------------------------------------------------------
  1053.   def two_swords
  1054.     # 敌方不被处理
  1055.     return @action.shift unless @battler.actor?
  1056.     # 左手(下部显示)没有武器就会消除下面的动作
  1057.     return @action.shift if @battler.weapons[1] == nil
  1058.     # 从行动配类的前面移动
  1059.     active = @action.shift
  1060.     # 确定现在的动作
  1061.     @active_action = N01::ANIME[active]
  1062.     # 等待设定
  1063.     @wait = active.to_i if @active_action == nil
  1064.     # 单独动作开始
  1065.     action
  1066.   end
  1067.   #--------------------------------------------------------------------------
  1068.   # ● 非二刀限定
  1069.   #--------------------------------------------------------------------------
  1070.   def non_two_swords
  1071.     # 敌方不被处理
  1072.     return unless @battler.actor?
  1073.     # 左手(下部显示)没有武器就会消除下面的动作
  1074.     return @action.shift if @battler.weapons[1] != nil
  1075.     # 从行动配类的前面移动
  1076.     active = @action.shift
  1077.     # 确定现在的动作
  1078.     @active_action = N01::ANIME[active]
  1079.     # 等待设定
  1080.     @wait = active.to_i if @active_action == nil
  1081.     # 单独动作开始
  1082.     action
  1083.   end
  1084.   #--------------------------------------------------------------------------
  1085.   # ● 动作条件
  1086.   #--------------------------------------------------------------------------
  1087.   def necessary
  1088.     nece1 = @active_action[3]
  1089.     nece2 = @active_action[4]
  1090.     # 目标确认
  1091.     case @active_action[1]
  1092.     # 0自身 1目标 2敌全体 3我方全体
  1093.     when 0
  1094.       target = [$game_party.members[@battler.index]] if @battler.is_a?(Game_Actor)
  1095.       target = [$game_troop.members[@battler.index]] if @battler.is_a?(Game_Enemy)
  1096.     when 1
  1097.       target = @target_battler
  1098.     when 2
  1099.       target = $game_troop.members
  1100.     when 3
  1101.       target = $game_party.members
  1102.     end
  1103.     # 目标为空出时看作失败
  1104.     return start_action(@battler.recover_action) if target.size == 0
  1105.     # 内容确认
  1106.     case @active_action[2]
  1107.     # 指定了状态ID时
  1108.     when 0
  1109.       # 补充正号为「正在此状态」、负号为「不在此状态」的条件
  1110.       state_on = true if nece2 > 0
  1111.       # 获取条件人数
  1112.       state_member = nece2.abs
  1113.       # 0从队友数中获取
  1114.       if nece2 == 0
  1115.         state_member = $game_party.members.size if @battler.is_a?(Game_Actor)
  1116.         state_member = $game_troop.members.size if @battler.is_a?(Game_Enemy)
  1117.       end  
  1118.       # 目标的状态确认后清点人数
  1119.       for member in target
  1120.         state_member -= 1 if member.state?(nece1)
  1121.       end
  1122.       # 条件全部满足后执行动作
  1123.       if state_member == 0 && state_on
  1124.         return
  1125.       elsif state_member == nece2.abs
  1126.         return if state_on == nil
  1127.       end  
  1128.     # 指定了参数时
  1129.     when 1  
  1130.       # 补充了正号为「数值以上」、负号为「数值以下」的条件
  1131.       num_over = true if nece2 > 0
  1132.       # 参照数值
  1133.       num = 0
  1134.       # 确认目标的参数
  1135.       for member in target
  1136.         # 参照参数来分歧
  1137.         case  nece1
  1138.         when 0 # 现HP
  1139.           num += member.hp
  1140.         when 1 # 现MP
  1141.           num += member.mp
  1142.         when 2 # 攻击力
  1143.           num += member.atk
  1144.         when 3 # 防御力
  1145.           num += member.def
  1146.         when 4 # 精神力
  1147.           num += member.spi
  1148.         when 5 # 敏捷性
  1149.           num += member.agi
  1150.         end
  1151.       end
  1152.       # 平均
  1153.       num = num / target.size
  1154.       # 条件全部满足时执行动作
  1155.       if num > nece2.abs && num_over
  1156.         return
  1157.       elsif num < nece2.abs
  1158.         return if num_over == nil
  1159.       end
  1160.     # 指定了开关时
  1161.     when 2
  1162.       # 条件全部满足时执行动作
  1163.       if $game_switches[nece1]
  1164.         # 补充为true时「开关ON」、false时「开关OFF」的条件
  1165.         return if nece2
  1166.       # 开关为OFF时与ON时是相反的
  1167.       else
  1168.         return unless nece2
  1169.       end  
  1170.     # 指定了变量时
  1171.     when 3
  1172.       # 补充为正号时「数值以上」、负号时「数値以下」的条件
  1173.       if nece2 > 0
  1174.         return if $game_variables[nece1] > nece2
  1175.       else
  1176.         return unless $game_variables[nece1] > nece2.abs
  1177.       end
  1178.     # 指定了习得技能时
  1179.     when 4
  1180.       # 获取技能条件人数
  1181.       skill_member = nece2.abs
  1182.       for member in target
  1183.         skill_member -= 1 if member.skill_learn?(nece1)
  1184.         # 条件确认
  1185.         return if skill_member == 0
  1186.       end  
  1187.     end
  1188.     # 条件没有被满足时动作中断
  1189.     return @action = ["完毕"] if @non_repeat
  1190.     # 不让防御中看起来不自然，坐标不被还原
  1191.     action = @battler.recover_action
  1192.     action = @battler.defence if @battler.guarding?
  1193.     return start_action(action)
  1194.   end  
  1195.   #--------------------------------------------------------------------------
  1196.   # ● 技能连发
  1197.   #--------------------------------------------------------------------------
  1198.   def derivating
  1199.     # 如果让没学的的技能不能连发时
  1200.     return if !@active_action[2] && [email protected]_id_learn?(@active_action[3])
  1201.     # 确率分歧
  1202.     return if rand(100) > @active_action[1]
  1203.     # 连发成功
  1204.     @battler.derivation = @active_action[3]
  1205.     # 之后的动作被中断
  1206.     @action = ["完毕"]
  1207.   end
  1208.   #--------------------------------------------------------------------------
  1209.   # ● 个别处理开始
  1210.   #--------------------------------------------------------------------------
  1211.   def individual_action
  1212.     # 反复标志ON
  1213.     @battler.individual = true
  1214.     # 保持反复动作
  1215.     @individual_act = @action.dup
  1216.     # 保持目标、一个一个的发出行动目标
  1217.     send_action(["个别处理"])
  1218.     @individual_targets = @target_battler.dup
  1219.     @target_battler = [@individual_targets.shift]
  1220.   end
  1221.   #--------------------------------------------------------------------------
  1222.   # ● 个别处理完毕
  1223.   #--------------------------------------------------------------------------
  1224.   def individual_action_end
  1225.     # 目标没有残留时行动完毕
  1226.     return @battler.individual = false if @individual_targets.size == 0
  1227.     @action = @individual_act.dup
  1228.     @target_battler = [@individual_targets.shift]
  1229.   end  
  1230.   #--------------------------------------------------------------------------
  1231.   # ● 待机不能移动
  1232.   #--------------------------------------------------------------------------
  1233.   def non_repeat
  1234.     @repeat_action = []
  1235.     @non_repeat = true
  1236.     anime_finish
  1237.   end  
  1238.   #--------------------------------------------------------------------------
  1239.   # ● 目标变更 action = [判別, 变更对象, 变更处]
  1240.   #--------------------------------------------------------------------------
  1241.   def change_target
  1242.     # 还原自身变更了的目标
  1243.     return @target_battler = @now_targets.dup if @active_action[2] == 3
  1244.     # 发送目标情报
  1245.     target = [@battler] if @active_action[2] == 0
  1246.     target = @target_battler.dup if @active_action[2] != 0
  1247.     # 自身的目标发送到对方时、记录现在的目标
  1248.     if @active_action[2] == 2
  1249.       @now_targets = @target_battler.dup
  1250.       @target_battler = []
  1251.     end  
  1252.     # 发送目标指定目录时
  1253.     if @active_action[1] >= 1000
  1254.       members = $game_party.members if @battler.actor?
  1255.       members = $game_troop.members unless @battler.actor?
  1256.       index = @active_action[1] - 1000
  1257.       if index < members.size
  1258.         if members[index].exist? && @battler.index != index
  1259.           # 目标变更
  1260.           members[index].force_target = ["N01target_change", target]
  1261.           # 自身的目标发送到相手时
  1262.           @target_battler = [members[index]] if @active_action[2] == 2
  1263.           change = true
  1264.         else
  1265.           for member in members
  1266.             next if @battler.index == member.index
  1267.             next unless member.exist?
  1268.             member.force_target = ["N01target_change", target]
  1269.             @target_battler = [member] if @active_action[2] == 2
  1270.             break change = true
  1271.           end
  1272.         end
  1273.       end
  1274.     # 指定了发送目标的状态ID时
  1275.     elsif @active_action[1] > 0
  1276.       for member in $game_party.members + $game_troop.members
  1277.         if member.state?(@active_action[1])
  1278.           member.force_target = ["N01target_change", target]
  1279.           @target_battler.push(member) if @active_action[2] == 2
  1280.           change = true
  1281.         end  
  1282.       end  
  1283.     # 指定了发送目标学的的技能时
  1284.     elsif @active_action[1] < 0
  1285.       skill_id = @active_action[1].abs
  1286.       for actor in $game_party.members
  1287.         if actor.skill_learn?(skill_id)
  1288.           actor.force_target = ["N01target_change", target]
  1289.           @target_battler.push(target) if @active_action[2] == 2
  1290.           change = true
  1291.         end  
  1292.       end
  1293.     # 发送目标是目标时
  1294.     else
  1295.       for member in @target_battler
  1296.         member.force_target = ["N01target_change", target]
  1297.         @target_battler.push(member) if @active_action[2] == 2
  1298.         change = true
  1299.       end
  1300.     end
  1301.     # 条件未满足时之后的动作被中断
  1302.     return if change
  1303.     return @action = ["完毕"] if @non_repeat
  1304.     return start_action(@battler.recover_action)
  1305.   end   
  1306.   #--------------------------------------------------------------------------
  1307.   # ● 状态付与
  1308.   #--------------------------------------------------------------------------
  1309.   def state_on  
  1310.     state_id = @active_action[2]
  1311.     # 分歧对象
  1312.     case @active_action[1]
  1313.     when 0
  1314.       @battler.add_state(state_id)
  1315.     when 1
  1316.       if @target_battler != nil
  1317.         for target in @target_battler
  1318.           target.add_state(state_id)
  1319.         end
  1320.       end
  1321.     when 2
  1322.       for target in $game_troop.members
  1323.         target.add_state(state_id)
  1324.       end
  1325.     when 3
  1326.       for target in $game_party.members
  1327.         target.add_state(state_id)
  1328.       end
  1329.     when 4
  1330.       for target in $game_party.members
  1331.         if target.index != @battler.index
  1332.           target.add_state(state_id)
  1333.         end  
  1334.       end
  1335.     end
  1336.   end
  1337.   #--------------------------------------------------------------------------
  1338.   # ● 状态解除
  1339.   #--------------------------------------------------------------------------
  1340.   def state_off  
  1341.     state_id = @active_action[2]
  1342.     # 分歧对象
  1343.     case @active_action[1]
  1344.     when 0
  1345.       @battler.remove_state(state_id)
  1346.     when 1
  1347.       if @target_battler != nil
  1348.         for target in @target_battler
  1349.           target.remove_state(state_id)
  1350.         end
  1351.       end
  1352.     when 2
  1353.       for target in $game_troop.members
  1354.         target.remove_state(state_id)
  1355.       end
  1356.     when 3
  1357.       for target in $game_party.members
  1358.         target.remove_state(state_id)
  1359.       end
  1360.     when 4
  1361.       for target in $game_party.members
  1362.         if target.index != @battler.index
  1363.           target.remove_state(state_id)
  1364.         end  
  1365.       end
  1366.     end
  1367.   end  
  1368.   #--------------------------------------------------------------------------
  1369.   # ● 实行漂浮
  1370.   #--------------------------------------------------------------------------
  1371.   def floating  
  1372.     # 初期化跳跃
  1373.     jump_reset
  1374.     # 情报确认
  1375.     @jump_plus = @active_action[1]
  1376.     float_end = @active_action[2]
  1377.     @float_time = @active_action[3]
  1378.     # 计算一格相当的移动高度
  1379.     @float_up = (float_end - @jump_plus)/ @float_time
  1380.     # 漂浮结束前不执行下个动作
  1381.     @wait = @float_time
  1382.     # 反映漂浮动画的设定
  1383.     if @anime_flug
  1384.       move_anime = N01::ANIME[@active_action[4]]
  1385.       # 没有指定图片时跳过处理
  1386.       if move_anime != nil
  1387.         # 写下现在的动作
  1388.         @active_action = move_anime
  1389.         # 角色动画开始
  1390.         battler_anime
  1391.         # 漂浮完毕时即动画完毕
  1392.         @anime_end = true
  1393.       end
  1394.     end
  1395.     # 漂浮到初期高度
  1396.     @battler.jump = @jump_plus
  1397.   end      
  1398.   #--------------------------------------------------------------------------
  1399.   # ● 强制动作
  1400.   #--------------------------------------------------------------------------
  1401.   def force_action
  1402.     # 动作是单独还是通用的判别
  1403.     kind = @active_action[0]
  1404.     # 确认有无复原
  1405.     rebirth = @active_action[2]
  1406.     # 获取强制动作的内容
  1407.     play = @active_action[3]
  1408.     # 归纳上面3个情报
  1409.     action = [kind,rebirth,play]
  1410.     # 目标指定目录时
  1411.     if @active_action[1] >= 1000
  1412.       members = $game_party.members if @battler.actor?
  1413.       members = $game_troop.members unless @battler.actor?
  1414.       index = @active_action[1] - 1000
  1415.       if index < members.size
  1416.         if members[index].exist? && @battler.index != index
  1417.           # 交付角色情报
  1418.           return members[index].force_action = action
  1419.         else
  1420.           for target in members
  1421.             next if @battler.index == target.index
  1422.             next unless target.exist?
  1423.             force = true
  1424.             break target.force_action = action
  1425.           end
  1426.         end
  1427.       end
  1428.       # 条件未满足时之后的动作全部中断
  1429.       return if force
  1430.       return @action = ["完毕"] if @non_repeat
  1431.       return start_action(@battler.recover_action)
  1432.     # 指定目标时  
  1433.     elsif @active_action[1] == 0
  1434.       for target in @target_battler
  1435.         target.force_action = action if target != nil
  1436.       end
  1437.     # 指定状态ID时  
  1438.     elsif @active_action[1] > 0
  1439.       for target in $game_party.members + $game_troop.members
  1440.         target.force_action = action if target.state?(@active_action[1])
  1441.       end
  1442.     # 指定习得技能时  
  1443.     elsif @active_action[1] < 0  
  1444.       # 敌方不被处理时
  1445.       return if @battler.is_a?(Game_Enemy)
  1446.       for actor in $game_party.members
  1447.         # 自身除外
  1448.         unless actor.id == @battler.id
  1449.           # 交付角色情报
  1450.           actor.force_action = action if actor.skill_id_learn?(@active_action[1].abs)
  1451.         end
  1452.       end
  1453.     end
  1454.   end
  1455.   #--------------------------------------------------------------------------
  1456.   # ● 实行坐标初始化
  1457.   #--------------------------------------------------------------------------
  1458.   def reseting
  1459.     # 初始化跳跃
  1460.     jump_reset
  1461.     # 还原旋转
  1462.     self.angle = 0
  1463.     # 情报确认
  1464.     @distanse_x   = @move_x * -1
  1465.     @distanse_y   = @move_y * -1
  1466.     @move_speed_x = @active_action[1]
  1467.     @move_speed_y = @move_speed_x
  1468.     @move_boost_x = @active_action[2]
  1469.     @move_boost_y = @move_boost_x
  1470.     @jump         = @active_action[3]
  1471.     # 计算移动
  1472.     move_distance
  1473.     # 反映移动画面的设定
  1474.     if @anime_flug
  1475.       move_anime = N01::ANIME[@active_action[4]]
  1476.       # 没有指定图片时跳过处理
  1477.       if move_anime != nil
  1478.         # 写下现在的动作
  1479.         @active_action = move_anime
  1480.         # 角色动画开始
  1481.         battler_anime
  1482.       end
  1483.       # 移动完毕时即动画也完毕
  1484.       @anime_end = true
  1485.     end
  1486.   end
  1487.   #--------------------------------------------------------------------------
  1488.   # ● 实行移动
  1489.   #--------------------------------------------------------------------------
  1490.   def moving  
  1491.     # 初期化跳跃
  1492.     jump_reset
  1493.     # 方便调出X轴的移动
  1494.     xx = @active_action[1]
  1495.     # 袭击时X轴逆转
  1496.     xx *= -1 if $back_attack
  1497.     # 确认移动目标的目标
  1498.     case @active_action[0]
  1499.     when 0 # 自身
  1500.       @distanse_x = xx
  1501.       @distanse_y = @active_action[2]
  1502.     when 1 # 目标
  1503.       # 目标没有决定时、变换成自身
  1504.       if @target_battler == nil
  1505.         @distanse_x = xx
  1506.         @distanse_y = @active_action[2]
  1507.       else
  1508.         # 一个一个的确认目标对象
  1509.         target_x = 0
  1510.         target_y = 0
  1511.         time = 0
  1512.         for i in 0...@target_battler.size
  1513.           if @target_battler[i] != nil
  1514.             time += 1
  1515.             target_x += @target_battler[i].position_x
  1516.             target_y += @target_battler[i].position_y
  1517.           end  
  1518.         end
  1519.         # 目标空出时、变换成自身
  1520.         if time == 0
  1521.           @distanse_x = xx
  1522.           @distanse_y = @active_action[2]
  1523.         else  
  1524.           # 计算出复数目标的中心位置
  1525.           target_x = target_x / time
  1526.           target_y = target_y / time
  1527.           # 算出最终的移动距离
  1528.           @distanse_y = target_y - self.y + @active_action[2]
  1529.           # X坐标是角色和敌人的逆向计算
  1530.           if @battler.is_a?(Game_Actor)
  1531.             @distanse_x = target_x - self.x + xx
  1532.           else
  1533.             @distanse_x = self.x - target_x + xx
  1534.           end  
  1535.         end  
  1536.       end  
  1537.     when 2 # 画面
  1538.       # X坐标是角色和敌人的逆向计算
  1539.       if @battler.is_a?(Game_Actor)
  1540.         @distanse_x = xx - self.x
  1541.         @distanse_x = Graphics.width + xx - self.x if $back_attack
  1542.       else
  1543.         @distanse_x = self.x - xx
  1544.         @distanse_x = self.x - (Graphics.width + xx) if $back_attack
  1545.       end
  1546.       @distanse_y = @active_action[2] - self.y
  1547.     when 3 # 初期位置
  1548.       # X坐标是角色和敌人的逆向计算
  1549.       if @battler.is_a?(Game_Actor)
  1550.         @distanse_x = xx + @battler.base_position_x - self.x
  1551.       else
  1552.         @distanse_x = xx + self.x - @battler.base_position_x
  1553.       end
  1554.       @distanse_y = @active_action[2] + @battler.base_position_y - @battler.position_y
  1555.     end
  1556.     @move_speed_x = @active_action[3]
  1557.     @move_speed_y = @active_action[3]
  1558.     @move_boost_x = @active_action[4]
  1559.     @move_boost_y = @active_action[4]
  1560.     @jump         = @active_action[5]
  1561.     @jump_plus = 0
  1562.     # 计算移动
  1563.     move_distance
  1564.     # 反映移动动画的设定
  1565.     if @anime_flug
  1566.       move_anime = N01::ANIME[@active_action[6]]
  1567.       # 没有指定图片时跳过处理
  1568.       if move_anime != nil
  1569.         # 写下现在的动作
  1570.         @active_action = move_anime
  1571.         # 角色动画开始
  1572.         battler_anime
  1573.       end  
  1574.       # 移动完毕时即动画也完毕
  1575.       @anime_end = true
  1576.     end
  1577.   end
  1578.   #--------------------------------------------------------------------------
  1579.   # ● 计算移动
  1580.   #--------------------------------------------------------------------------
  1581.   def move_distance
  1582.     # 速度为0时、停留在那个地方
  1583.     if @move_speed_x == 0
  1584.       @moving_x = 0
  1585.       @moving_y = 0
  1586.     else  
  1587.       # 计算一格相当的移动距离
  1588.       @moving_x = @distanse_x / @move_speed_x
  1589.       @moving_y = @distanse_y / @move_speed_y
  1590.       # 剩余的距离在这时移动消化
  1591.       over_x = @distanse_x % @move_speed_x
  1592.       over_y = @distanse_y % @move_speed_y
  1593.       @move_x += over_x
  1594.       @move_y += over_y
  1595.       @battler.move_x = @move_x
  1596.       @battler.move_y = @move_y
  1597.       @distanse_x -= over_x
  1598.       @distanse_y -= over_y
  1599.     end  
  1600.     # 判定是否移动
  1601.     if @distanse_x == 0
  1602.       @move_speed_x = 0
  1603.     end
  1604.     if @distanse_y == 0
  1605.       @move_speed_y = 0
  1606.     end
  1607.     # 计算X坐标移动
  1608.     # 根据加减速修正移动格数
  1609.     boost_x = @moving_x
  1610.     move_x = 0
  1611.     # 加速时
  1612.     if @move_boost_x > 0 && @distanse_x != 0
  1613.       # 加减速的正负调整成左右移动
  1614.       if @distanse_x == 0
  1615.         @move_boost_x = 0
  1616.       elsif @distanse_x < 0
  1617.         @move_boost_x *= -1
  1618.       end
  1619.       # 事先计算距离的变化
  1620.       for i in 0...@move_speed_x
  1621.         boost_x += @move_boost_x
  1622.         move_x += boost_x
  1623.         # 记录超过距离
  1624.         over_distance = @distanse_x - move_x
  1625.         # 记录右移动时距离超越的时第几格
  1626.         if @distanse_x > 0 && over_distance < 0
  1627.           @move_speed_x = i
  1628.           break
  1629.         # 记录右移动时距离超越的时第几格
  1630.         elsif @distanse_x < 0 && over_distance > 0
  1631.           @move_speed_x = i
  1632.           break
  1633.         end
  1634.       end
  1635.       # 将超越距离还原到前一次
  1636.       before = over_distance + boost_x
  1637.       # 剩余的距离加算到等速移动的格数中
  1638.       @move_speed_plus_x = (before / @moving_x).abs
  1639.       # 即使这样剩余的距离也在这时移动消化
  1640.       @move_x += before % @moving_x
  1641.       @battler.move_x = @move_x
  1642.     # 减速时  
  1643.     elsif @move_boost_x < 0 && @distanse_x != 0
  1644.       # 加减速的正负调整成左右移动
  1645.       if @distanse_x == 0
  1646.         @move_boost_x = 0
  1647.       elsif @distanse_x < 0
  1648.         @move_boost_x *= -1
  1649.       end
  1650.       # 事先计算距离的变化
  1651.       for i in 0...@move_speed_x
  1652.         boost_x += @move_boost_x
  1653.         move_x += boost_x
  1654.         # 记录不足的距离
  1655.         lost_distance = @distanse_x - move_x
  1656.         before = lost_distance
  1657.         # 记录右移动速度到0时是第几格
  1658.         if @distanse_x > 0 && boost_x < 0
  1659.           @move_speed_x = i - 1
  1660.           # 不足的距离还原到前一次
  1661.           before = lost_distance + boost_x
  1662.           break
  1663.         # 记录左移动速度到0时是第几格
  1664.         elsif @distanse_x < 0 && boost_x > 0
  1665.           @move_speed_x= i - 1
  1666.           # 不足的距离还原到前一次
  1667.           before = lost_distance + boost_x
  1668.           break
  1669.         end
  1670.       end
  1671.       # 不足的距离加算到等速移动的格数中
  1672.       plus = before / @moving_x
  1673.       @move_speed_plus_x = plus.abs
  1674.       # 即是如此剩余的距离也在这时移动消化
  1675.       @move_x += before % @moving_x
  1676.       @battler.move_x = @move_x
  1677.     end
  1678.     # 计算Y坐标移动
  1679.     # 根据加减速修正移动格数
  1680.     boost_y = @moving_y
  1681.     move_y = 0
  1682.     # 加速时
  1683.     if @move_boost_y > 0 && @distanse_y != 0
  1684.       # 加减速的正负调整成左右移动
  1685.       if @distanse_y == 0
  1686.         @move_boost_y = 0
  1687.       elsif @distanse_y < 0
  1688.         @move_boost_y *= -1
  1689.       end
  1690.       # 事先计算距离的变化
  1691.       for i in 0...@move_speed_y
  1692.         boost_y += @move_boost_y
  1693.         move_y += boost_y
  1694.         # 记录超越的距离
  1695.         over_distance = @distanse_y - move_y
  1696.         # 记录右移动时距离超越的时第几格
  1697.         if @distanse_y > 0 && over_distance < 0
  1698.           @move_speed_y = i
  1699.           break
  1700.         # 记录左移动时距离超越的时第几格
  1701.         elsif @distanse_y < 0 && over_distance > 0
  1702.           @move_speed_y = i
  1703.           break
  1704.         end
  1705.       end
  1706.       # 超越的距离还原到前一次
  1707.       before = over_distance + boost_y
  1708.       # 剩余的距离加算到等速移动的格数中
  1709.       @move_speed_plus_y = (before / @moving_y).abs
  1710.       # 即使这样剩余的距离也在这时移动消化
  1711.       @move_y += before % @moving_y
  1712.       @battler.move_y = @move_y
  1713.     # 減速时  
  1714.     elsif @move_boost_y < 0 && @distanse_y != 0
  1715.       # 加减速的正负调整成左右移动
  1716.       if @distanse_y == 0
  1717.         @move_boost_y = 0
  1718.       elsif @distanse_y < 0
  1719.         @move_boost_y *= -1
  1720.       end
  1721.       # 事先计算距离的变化
  1722.       for i in 0...@move_speed_y
  1723.         boost_y += @move_boost_y
  1724.         move_y += boost_y
  1725.         # 记录不足的距离
  1726.         lost_distance = @distanse_y - move_y
  1727.         before = lost_distance
  1728.         # 记录右移动速度到0时是第几格
  1729.         if @distanse_y > 0 && boost_y < 0
  1730.           @move_speed_y = i
  1731.           # 不足的距离还原到前一次
  1732.           before = lost_distance + boost_y
  1733.           break
  1734.         # 记录左移动速度到0时是第几格
  1735.         elsif @distanse_y < 0 && boost_y > 0
  1736.           @move_speed_y = i
  1737.           # 不足的距离还原到前一次
  1738.           before = lost_distance + boost_y
  1739.           break
  1740.         end
  1741.       end
  1742.       # 不足的距离加算到等速移动的格数中
  1743.       plus = before / @moving_y
  1744.       @move_speed_plus_y = plus.abs
  1745.       # 即是如此剩余的距离也在这时移动消化
  1746.       @move_y += before % @moving_y
  1747.       @battler.move_y = @move_y
  1748.     end
  1749.     # 算出移动完毕的时间
  1750.     x = @move_speed_plus_x + @move_speed_x
  1751.     y = @move_speed_plus_y + @move_speed_y
  1752.     if x > y
  1753.       end_time = x
  1754.     else
  1755.       end_time = y
  1756.     end
  1757.     # 移动完毕前不进行下个动作
  1758.     @wait = end_time
  1759.     # 计算跳跃
  1760.     if @jump != 0
  1761.       # 没有移动只跳跃时
  1762.       if @wait == 0
  1763.         # 时间记入
  1764.         @wait = @active_action[3]
  1765.       end  
  1766.       # 从移动完毕时间算出跳跃时间
  1767.       @jump_time = @wait / 2
  1768.       # 不能插入时的剩余时间
  1769.       @jump_time_plus = @wait % 2
  1770.       # 判别跳跃是正还是负
  1771.       @jump_sign = 0
  1772.       @jump_sign2 = 0
  1773.       if @jump < 0
  1774.         @jump_sign = -1
  1775.         @jump_sign2 = 1
  1776.         @jump = @jump * -1
  1777.       else
  1778.         @jump_sign = 1
  1779.         @jump_sign2 = -1
  1780.       end
  1781.       # 决定跳跃初始速度
  1782.       @jump_up = 2 ** @jump * @jump_sign
  1783.       # 略微调整条约时间的尾数
  1784.       if @jump_time == 0
  1785.         @jump_up = 0
  1786.       elsif @jump_time != 1
  1787.         @jump_size = @jump_up * @jump_sign * @jump_sign2
  1788.       else
  1789.         @jump_size = @jump_up * 2 * @jump_sign * @jump_sign2
  1790.         @jump_flug = true
  1791.       end  
  1792.     end
  1793.   end
  1794.   #--------------------------------------------------------------------------
  1795.   # ● 角色动画开始
  1796.   #--------------------------------------------------------------------------
  1797.   def battler_anime
  1798.     # 反映动画设定
  1799.     @anime_kind  = @active_action[1]
  1800.     @anime_speed = @active_action[2]
  1801.     @anime_loop  = @active_action[3]
  1802.     # 如果有等待时间时加算
  1803.     @unloop_wait = @active_action[4]
  1804.     @anime_end = true
  1805.     @reverse = false
  1806.     # 只有有武器动作时进行更新
  1807.     if @weapon_R != nil && @active_action[8] != ""
  1808.       # 确认武器的设定
  1809.       weapon_kind = N01::ANIME[@active_action[8]]
  1810.       # 敌方和不使用二刀角色的取消二刀标志动画处理
  1811.       two_swords_flug = weapon_kind[11]
  1812.       return if two_swords_flug && [email protected]?
  1813.       return if two_swords_flug && @battler.weapons[1] == nil && @battler.actor?
  1814.       if @battler.actor? && @battler.weapons[0] == nil && !two_swords_flug
  1815.         @weapon_R.action_reset
  1816.       elsif @battler.actor? && @battler.weapons[1] == nil && two_swords_flug
  1817.         @weapon_R.action_reset
  1818.       elsif [email protected]? && @battler.weapon == 0
  1819.         @weapon_R.action_reset
  1820.       else
  1821.         # 初期化
  1822.         @weapon_R.action_reset
  1823.         # 动画图像是固定时的获取武器位置
  1824.         if @active_action[5] != -1
  1825.           @weapon_R.freeze(@active_action[5])
  1826.         end
  1827.         # 设定武器画像
  1828.         @weapon_R.weapon_graphics unless two_swords_flug
  1829.         @weapon_R.weapon_graphics(true) if two_swords_flug
  1830.         # 交付武器动作
  1831.         @weapon_R.weapon_action(@active_action[8],@anime_loop)
  1832.         @weapon_action = true
  1833.         # 更新最初的武器动作
  1834.         @weapon_R.action
  1835.       end
  1836.     elsif @weapon_R != nil
  1837.       @weapon_R.action_reset
  1838.     end  
  1839.     @anime_end = false
  1840.     # 动画图片是固定时
  1841.     if @active_action[5] != -1 && @active_action[5] != -2
  1842.       # 标志ON
  1843.       @anime_freeze = true
  1844.       # 看作动画是通常的完毕了
  1845.       @anime_end = true
  1846.     # 单程逆转再生时
  1847.     elsif @active_action[5] == -2
  1848.       @anime_freeze = false
  1849.       # 标志ON
  1850.       @reverse = true
  1851.       # 更新最初的动画图像
  1852.       @pattern = @base_width - 1
  1853.       # 只有在有武器动画时更新
  1854.       if @weapon_action && @weapon_R != nil
  1855.         @weapon_R.action
  1856.         @weapon_R.update
  1857.       end
  1858.     # 更新通常动画时  
  1859.     else  
  1860.       @anime_freeze = false
  1861.       # 更新最初动画图像
  1862.       @pattern = 0
  1863.       # 只有在有武器动画时更新
  1864.       if @weapon_action && @weapon_R != nil
  1865.         @weapon_R.action
  1866.         @weapon_R.update
  1867.       end
  1868.     end  
  1869.     @pattern_back = false
  1870.     @frame = @anime_speed
  1871.     # 设定Z坐标
  1872.     @battler.move_z = @active_action[6]
  1873.     # 是否有影
  1874.     if @shadow != nil
  1875.       @shadow.visible = true if @active_action[7]
  1876.       @shadow.visible = false unless @active_action[7]
  1877.       @shadow.visible = false if @skip_shadow
  1878.     end
  1879.     # 分期从编号读取文件名
  1880.     if @active_action[0] == 0
  1881.       file_name = @battler_name
  1882.     else
  1883.       file_name = @battler_name + "_" + @active_action[0].to_s
  1884.     end  
  1885.     # 无动画角色时处理完毕
  1886.     return unless @anime_flug
  1887.     self.bitmap = Cache.character(file_name)
  1888.     # 设定转送前的矩形
  1889.     @sx = @pattern * @width
  1890.     @sy = @anime_kind * @height
  1891.     @sx = @active_action[5] * @width if @anime_freeze
  1892.     self.src_rect.set(@sx, @sy, @width, @height)
  1893.   end
  1894.   #--------------------------------------------------------------------------
  1895.   # ● 动画飞出
  1896.   #--------------------------------------------------------------------------
  1897.   def moving_anime
  1898.     # 如果前个飞出动画还有残留时初期化
  1899.     @move_anime.action_reset if @anime_moving
  1900.     @anime_moving = true
  1901.     # 袭击中动画、武器画像反转
  1902.     mirror = false
  1903.     mirror = true if $back_attack
  1904.     # 动画ID
  1905.     id = @active_action[1]
  1906.     # 对象
  1907.     target = @active_action[2]
  1908.     x = y = mem = 0
  1909.     # 对象为单体时
  1910.     if target == 0
  1911.       # 没有决定目标时、变换为自身
  1912.       if @target_battler == nil
  1913.         x = self.x
  1914.         y = self.y
  1915.       else
  1916.         # 目标空出时、变换为自身
  1917.         if @target_battler[0] == nil
  1918.           x = self.x
  1919.           y = self.y
  1920.         else  
  1921.           # 决定最初进入的目标为对象
  1922.           x = @target_battler[0].position_x
  1923.           y = @target_battler[0].position_y
  1924.         end  
  1925.       end  
  1926.     # 对象在敌方中心时  
  1927.     elsif target == 1
  1928.       # 自身是主人公时计算敌方的中心
  1929.       if @battler.is_a?(Game_Actor)
  1930.         for target in $game_troop.members
  1931.           x += target.position_x
  1932.           y += target.position_y
  1933.           mem += 1
  1934.         end
  1935.         x = x / mem
  1936.         y = y / mem
  1937.       # 自身是敌方时计算主人公的中心
  1938.       else
  1939.         for target in $game_party.members
  1940.           x += target.position_x
  1941.           y += target.position_y
  1942.           mem += 1
  1943.         end
  1944.         x = x / mem
  1945.         y = y / mem
  1946.       end
  1947.     # 对象在我方中心时  
  1948.     elsif target == 2
  1949.       # 自身是主人公时计算主人公的中心
  1950.       if @battler.is_a?(Game_Actor)
  1951.         for target in $game_party.members
  1952.           x += target.position_x
  1953.           y += target.position_y
  1954.           mem += 1
  1955.         end
  1956.         x = x / mem
  1957.         y = y / mem
  1958.       # 自身是敌方时计算敌方的中心
  1959.       else
  1960.         for target in $game_troop.members
  1961.           x += target.position_x
  1962.           y += target.position_y
  1963.           mem += 1
  1964.         end
  1965.         x = x / mem
  1966.         y = y / mem
  1967.       end
  1968.     # 对象是自身时  
  1969.     else
  1970.       x = self.x
  1971.       y = self.y
  1972.     end  
  1973.     # 开始位置的略微调整
  1974.     plus_x = @active_action[6]
  1975.     plus_y = @active_action[7]
  1976.     # 敌方是X轴逆转
  1977.     plus_x *= -1 if @battler.is_a?(Game_Enemy)
  1978.     # 算出最終的移动距离
  1979.     distanse_x = x - self.x - plus_x
  1980.     distanse_y = y - self.y - plus_y
  1981.     # 飞出类型
  1982.     type = @active_action[3]
  1983.     # 速度
  1984.     speed = @active_action[4]
  1985.     # 轨道
  1986.     orbit = @active_action[5]
  1987.     # 如果自身在开始位置时
  1988.     if @active_action[8] == 0
  1989.       @move_anime.base_x = self.x + plus_x
  1990.       @move_anime.base_y = self.y + plus_y
  1991.     # 对象在开始位置时
  1992.     elsif @active_action[8] == 1
  1993.       @move_anime.base_x = x + plus_x
  1994.       @move_anime.base_y = y + plus_y
  1995.       # 把距离作为反面
  1996.       distanse_y = distanse_y * -1
  1997.       distanse_x = distanse_x * -1
  1998.     # 如果不能动
  1999.     else
  2000.       @move_anime.base_x = x
  2001.       @move_anime.base_y = y
  2002.       distanse_x = distanse_y = 0
  2003.     end
  2004.     # 无武器动作时不显示武器
  2005.     if @active_action[10] == ""
  2006.       weapon = ""  
  2007.     # 无动画的敌方不显示武器
  2008.     elsif @anime_flug != true
  2009.       weapon = ""  
  2010.     # 武器动作时
  2011.     else
  2012.       # 确认是否指定了飞出武器图片
  2013.       if @battler.is_a?(Game_Actor)
  2014.         battler = $game_party.members[@battler.index]
  2015.         weapon_id = battler.weapon_id
  2016.       else  
  2017.         battler = $game_troop.members[@battler.index]
  2018.         weapon_id = battler.weapon
  2019.       end  
  2020.       # 判别是使用技能画像还是使用武器画像
  2021.       weapon_act = N01::ANIME[@active_action[10]].dup if @active_action[10] != ""
  2022.       # 如果利用武器画像时并不是空手
  2023.       if weapon_id != 0 && weapon_act.size == 3
  2024.         weapon_file = $data_weapons[weapon_id].flying_graphic
  2025.         # 如果没有指定别的画像时获取既存的武器图片
  2026.         if weapon_file == ""
  2027.           weapon_name = $data_weapons[weapon_id].graphic
  2028.           icon_weapon = false
  2029.           # 然后没有指定时使用ICON图片
  2030.           if weapon_name == ""
  2031.             weapon_name = $data_weapons[weapon_id].icon_index
  2032.             icon_weapon = true
  2033.           end  
  2034.         # 指定时获取那个图片名  
  2035.         else
  2036.           icon_weapon = false
  2037.           weapon_name = weapon_file
  2038.         end
  2039.         # 武器动作情报を取得
  2040.         weapon = @active_action[10]
  2041.       # 指定了武器画像时不显示空手
  2042.       elsif weapon_act.size == 3
  2043.         weapon = ""
  2044.       # 使用技能画像
  2045.       elsif weapon_act != nil && @battler.action.skill != nil
  2046.         icon_weapon = false
  2047.         weapon_name = $data_skills[@battler.action.skill.id].flying_graphic
  2048.         weapon = @active_action[10]
  2049.       end
  2050.     end
  2051.     # 决定Z坐标
  2052.     @move_anime.z = 1
  2053.     @move_anime.z = 1000 if @active_action[9]
  2054.     # 已上的全部情报都已飞出动画送到精灵
  2055.     @move_anime.anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,weapon_name,icon_weapon)
  2056.   end  
  2057.   #--------------------------------------------------------------------------
  2058.   # ● 动作完毕
  2059.   #--------------------------------------------------------------------------
  2060.   def anime_finish
  2061.     # 单独处理完毕省略时做反复
  2062.     return individual_action_end if @individual_targets.size != 0
  2063.     # 主动向角色归纳动作情报
  2064.     send_action(@active_action[0]) if @battler.active
  2065.     # 如果有残像时开放
  2066.     mirage_off if @mirage_flug
  2067.     # 重复待机动作
  2068.     start_action(@repeat_action) unless @non_repeat
  2069.   end   
  2070.   #--------------------------------------------------------------------------
  2071.   # ● 击倒动作
  2072.   #--------------------------------------------------------------------------
  2073.   def collapse_action
  2074.     @non_repeat = true
  2075.     @effect_type = COLLAPSE
  2076.     @collapse_type = @battler.collapse_type unless @battler.actor?
  2077.     @battler_visible = false unless @battler.actor?
  2078.     @effect_duration = N01::COLLAPSE_WAIT + 48 if @collapse_type == 2
  2079.     @effect_duration = 401 if @collapse_type == 3
  2080.   end  
  2081.   #--------------------------------------------------------------------------
  2082.   # ● 普通击倒
  2083.   #--------------------------------------------------------------------------
  2084.   def normal_collapse
  2085.     if @effect_duration == 47
  2086.       Sound.play_enemy_collapse
  2087.       self.blend_type = 1
  2088.       self.color.set(255, 128, 128, 128)
  2089.     end
  2090.     self.opacity = 256 - (48 - @effect_duration) * 6 if @effect_duration <= 47
  2091.   end  
  2092.   #--------------------------------------------------------------------------
  2093.   # ● BOSS击倒
  2094.   #--------------------------------------------------------------------------
  2095.   def boss_collapse1
  2096.     if @effect_duration == 320
  2097.       Audio.se_play("Audio/SE/Absorb1", 100, 80)
  2098.       self.flash(Color.new(255, 255, 255), 60)
  2099.       viewport.flash(Color.new(255, 255, 255), 20)
  2100.     end
  2101.     if @effect_duration == 280
  2102.       Audio.se_play("Audio/SE/Absorb1", 100, 80)
  2103.       self.flash(Color.new(255, 255, 255), 60)
  2104.       viewport.flash(Color.new(255, 255, 255), 20)
  2105.     end
  2106.     if @effect_duration == 220
  2107.       Audio.se_play("Audio/SE/Earth4", 100, 80)
  2108.       reset
  2109.       self.blend_type = 1
  2110.       self.color.set(255, 128, 128, 128)
  2111.       self.wave_amp = 6
  2112.     end
  2113.     if @effect_duration < 220
  2114.       self.src_rect.set(0, @effect_duration / 2 - 110, @width, @height)
  2115.       self.x += 8 if @effect_duration % 4 == 0
  2116.       self.x -= 8 if @effect_duration % 4 == 2
  2117.       self.wave_amp += 1 if @effect_duration % 10 == 0
  2118.       self.opacity = @effect_duration
  2119.       return if @effect_duration < 50
  2120.       Audio.se_play("Audio/SE/Earth4", 100, 50) if @effect_duration % 50 == 0
  2121.     end
  2122.   end
  2123. end
复制代码




第二个：            Sideview 2
==============================================================================
# ■ Scene_Battle Ver2.7
#------------------------------------------------------------------------------
# 　战斗画面的处理的类。
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● 完毕处理
  #--------------------------------------------------------------------------
  alias terminate_n01 terminate
  def terminate
    terminate_n01
    # 返还二刀流的替换处理
    for member in $game_party.members
      if member.two_swords_change
        member.change_equip_by_id(1, member.weapon_id)
        member.change_equip_by_id(0, 0)
        member.two_swords_change = false
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● 战斗开始的处理
  #--------------------------------------------------------------------------
  alias process_battle_start_n01 process_battle_start
  def process_battle_start
    process_battle_start_n01
    # 如果二刀流让左(下部显示)手武器像右(上部表示)手武器那样没有持有时
    # 在这里强制替换他
    for member in $game_party.members
      if member.weapons[0] == nil and member.weapons[1] != nil
        member.change_equip_by_id(0, member.armor1_id)
        member.change_equip_by_id(1, 0)
        member.two_swords_change = true
      end
    end  
  end
  #--------------------------------------------------------------------------
  # ● 更新
  #--------------------------------------------------------------------------
  alias update_n01 update
  def update
    reset_stand_by_action
    super
    update_n01
  end
  #--------------------------------------------------------------------------
  # ● 根据事件操作的HP变动再设置角色动画
  #--------------------------------------------------------------------------
  def reset_stand_by_action
    if $game_temp.status_window_refresh
      $game_temp.status_window_refresh = false
      for member in $game_party.members + $game_troop.members
        @spriteset.set_stand_by_action(member.actor?, member.index)
        # 确认自动复活
        resurrection(member) if member.hp == 0
      end  
      @status_window.refresh
    end
  end  
  #--------------------------------------------------------------------------
  # ● 战败的处理
  #--------------------------------------------------------------------------
  alias process_defeat_n01 process_defeat
  def process_defeat
    for member in $game_party.members
      @spriteset.set_stand_by_action(member.actor?, member.index)
    end
    process_defeat_n01
  end
  #--------------------------------------------------------------------------
  # ● 帮助窗口的显示
  #--------------------------------------------------------------------------
  def pop_help(obj)
    return if obj.extension.include?("不显示HELP")
    @help_window = Window_Help.new if @help_window == nil
    @help_window.set_text(obj.name, 1)
    @help_window.visible = true
  end
  #--------------------------------------------------------------------------
  # ● 显示情报窗口的移动
  #--------------------------------------------------------------------------
  def move1_info_viewport
    @info_viewport.ox = 128
    loop do
      update_basic
      @info_viewport.ox -= 8
      @party_command_window.x -= 8
      @actor_command_window.x += 8
      break if @info_viewport.ox == 64
    end  
  end
  #--------------------------------------------------------------------------
  # ● 显示情报窗口的移动
  #--------------------------------------------------------------------------
  def move2_info_viewport
    @info_viewport.ox = 64
    loop do
      update_basic
      @info_viewport.ox -= 8
      @party_command_window.x += 8
      @actor_command_window.x -= 8
      break if @info_viewport.ox == 0
    end  
  end
  #--------------------------------------------------------------------------
  # ● 到下个主人公的指令选择
  #--------------------------------------------------------------------------
  alias next_actor_n01 next_actor
  def next_actor
    # 只有能动的角色显示指令动作
    if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
      @spriteset.set_action(true, @actor_index,@active_battler.command_a)
    end
    # 最后的角色时、动作结束前等待
    @wait_count = 32 if @actor_index == $game_party.members.size-1
    next_actor_n01
    # 只有能动的角色现实指令动作
    if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
      @spriteset.set_action(true, @actor_index,@active_battler.command_b)
    end
  end
  #--------------------------------------------------------------------------
  # ● 到前一个角色的指令选择
  #--------------------------------------------------------------------------
  alias prior_actor_n01 prior_actor
  def prior_actor
    # 只有能动的角色显示指令动作
    if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
      @active_battler.action.clear
      @spriteset.set_action(true, @actor_index,@active_battler.command_a)
    end
    prior_actor_n01
    # 只有能动的角色显示指令动作
    if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
      @active_battler.action.clear
      @spriteset.set_action(true, @actor_index,@active_battler.command_b)
    end
  end  
  #--------------------------------------------------------------------------
  # ● 目标选择的开始  ※再定义
  #--------------------------------------------------------------------------
  def start_target_enemy_selection
    start_target_selection
  end
  #--------------------------------------------------------------------------
  # ● 目标选择的开始  ※再定义
  #--------------------------------------------------------------------------
  def start_target_actor_selection
    start_target_selection(true)
  end
  #--------------------------------------------------------------------------
  # ● 目标选择的开始
  #--------------------------------------------------------------------------
  def start_target_selection(actor = false)
    members = $game_party.members if actor
    members = $game_troop.members unless actor
    # 光标精灵的作成
    @cursor = Sprite.new
    @cursor.bitmap = Cache.character("cursor")
    @cursor.src_rect.set(0, 0, 32, 32)
    @cursor_flame = 0
    @cursor.x = -200
    @cursor.y = -200
    @cursor.ox = @cursor.width
    @cursor.oy = @cursor.height
    # 作成显示目标名的帮助窗口
    @help_window.visible = false if @help_window != nil
    @help_window2 = Window_Help.new if @help_window2 == nil
    # 消除不要的窗口
    @actor_command_window.active = false
    @skill_window.visible = false if @skill_window != nil
    @item_window.visible = false if @item_window != nil
    # 存在的目标为最底号码的对象也想最初那样
    @index = 0
    @max_index = members.size - 1
    # 主人公为站都不能者也可以作为目标来与敌方区分
    unless actor
      members.size.times do
        break if members[@index].exist?
        @index += 1
      end
    end  
    @help_window2.set_text(members[@index].name, 1)
    select_member(actor)
  end
  #--------------------------------------------------------------------------
  # ● 目标选择
  #--------------------------------------------------------------------------
  def select_member(actor = false)
    members = $game_party.members if actor
    members = $game_troop.members unless actor
    loop do
      update_basic
      @cursor_flame = 0 if @cursor_flame == 30
      @cursor.src_rect.set(0,  0, 32, 32) if @cursor_flame == 29
      @cursor.src_rect.set(0, 32, 32, 32) if @cursor_flame == 15
      point = @spriteset.set_cursor(actor, @index)
      @cursor.x = point[0]
      @cursor.y = point[1]
      @cursor_flame += 1
      if Input.trigger?(Input::B)
        Sound.play_cancel
        end_target_selection
        break
      elsif Input.trigger?(Input::C)
        Sound.play_decision
        @active_battler.action.target_index = @index
        end_target_selection
        end_skill_selection
        end_item_selection
        next_actor
        break
      end
      if Input.repeat?(Input::LEFT)
        if actor
          cursor_down(members, actor) if $back_attack
          cursor_up(members, actor) unless $back_attack
        else
          cursor_up(members, actor) if $back_attack
          cursor_down(members, actor) unless $back_attack
        end  
      end
      if Input.repeat?(Input::RIGHT)
        if actor
          cursor_up(members, actor) if $back_attack
          cursor_down(members, actor) unless $back_attack
        else
          cursor_down(members, actor) if $back_attack
          cursor_up(members, actor) unless $back_attack
        end
      end
      cursor_up(members, actor) if Input.repeat?(Input::UP)
      cursor_down(members, actor) if Input.repeat?(Input::DOWN)
    end
  end
  #--------------------------------------------------------------------------
  # ● 向前移动光标
  #--------------------------------------------------------------------------
  def cursor_up(members, actor)
    Sound.play_cursor
    members.size.times do
      @index += members.size - 1
      @index %= members.size
      break if actor
      break if members[@index].exist?
    end
    @help_window2.set_text(members[@index].name, 1)
  end
  #--------------------------------------------------------------------------
  # ● 向后移动光标
  #--------------------------------------------------------------------------
  def cursor_down(members, actor)
    Sound.play_cursor
    members.size.times do
      @index += 1
      @index %= members.size
      break if actor
      break if members[@index].exist? && !actor
    end
    @help_window2.set_text(members[@index].name, 1)
  end
  #--------------------------------------------------------------------------
  # ● 目标选择的完毕
  #--------------------------------------------------------------------------
  def end_target_selection
    @actor_command_window.active = true if @actor_command_window.index == 0
    @skill_window.visible = true if @skill_window != nil
    @item_window.visible = true if @item_window != nil
    @cursor.dispose
    @cursor = nil
    if @help_window2 != nil  
      @help_window2.dispose
      @help_window2 = nil
    end
    @help_window.visible = true if @help_window != nil
  end
  #--------------------------------------------------------------------------
  # ● 逃走的处理  ※再定义
  #--------------------------------------------------------------------------
  def process_escape
    @info_viewport.visible = false
    @message_window.visible = true
    text = sprintf(Vocab::EscapeStart, $game_party.name)
    $game_message.texts.push(text)
    if $game_troop.preemptive
      success = true
    else
      success = (rand(100) < @escape_ratio)
    end
    Sound.play_escape
    # 不能动的主人公除外逃走成功动作
    if success
      for actor in $game_party.members
        unless actor.restriction == 4
          @spriteset.set_action(true, actor.index,actor.run_success)
        end
      end  
      wait_for_message
      battle_end(1)
    # 不能动主人公除外逃走失败动作
    else
      for actor in $game_party.members
        unless actor.restriction == 4
          @spriteset.set_action(true, actor.index,actor.run_ng)
        end
      end
      @escape_ratio += 10
      $game_message.texts.push('\.' + Vocab::EscapeFailure)
      wait_for_message
      $game_party.clear_actions
      start_main
    end
  end  
  #--------------------------------------------------------------------------
  # ● 胜利的处理
  #--------------------------------------------------------------------------
  alias process_victory_n01 process_victory
  def process_victory
    @status_window.visible = true
    @message_window.visible = false
    # BOSS击倒为等待加长
    for enemy in $game_troop.members
      break boss_wait = true if enemy.collapse_type == 3
    end
    wait(440) if boss_wait
    wait(N01::WIN_WAIT) unless boss_wait
    # 不能动的主人公除外胜利动作
    for actor in $game_party.members
      unless actor.restriction == 4
        @spriteset.set_action(true, actor.index,actor.win)
      end
    end
    process_victory_n01
  end
  #--------------------------------------------------------------------------
  # ● 战斗处理的实行开始  ※再定义
  #--------------------------------------------------------------------------
  def start_main
    $game_troop.increase_turn
    @info_viewport.visible = true
    @info_viewport.ox = 0
    @party_command_window.active = false
    @actor_command_window.active = false
    @status_window.index = @actor_index = -1
    @active_battler = nil
    @message_window.clear
    $game_troop.make_actions
    make_action_orders
    # 情报表示窗口的移动
    move1_info_viewport
    # 作成显示技能名的帮助窗口
    @help_window = Window_Help.new
    @help_window.visible = false
    process_battle_event
  end
  #--------------------------------------------------------------------------
  # ● 战斗事件的处理  ※再定义
  #--------------------------------------------------------------------------
  def process_battle_event
    loop do
      return if judge_win_loss
      return if $game_temp.next_scene != nil
      $game_troop.interpreter.update
      $game_troop.setup_battle_event
      @message_window.update
      if $game_message.visible
        @message_window.visible = true
        @status_window.visible = false
      end
      wait_for_message
      @message_window.visible = false
      @status_window.visible = true
      process_action if $game_troop.forcing_battler != nil
      return unless $game_troop.interpreter.running?
      update_basic
    end
  end
  #--------------------------------------------------------------------------
  # ● 作成行动顺序
  #--------------------------------------------------------------------------
  alias make_action_orders_n01 make_action_orders
  def make_action_orders
    make_action_orders_n01
    # 确认敌方的行动回数
    for enemy in $game_troop.members
      enemy.act_time = 0
      if enemy.action_time[0] != 1
        action_time = 0
        # 获得确认的回数
        for i in 1...enemy.action_time[0]
          action_time += 1 if rand(100) < enemy.action_time[1]
        end
        enemy.act_time = action_time
        action_time.times do
          enemy_order_time(enemy)
          action_time -= 1
          break if action_time == 0
        end  
        enemy.adj_speed = nil
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 作成敌方的行动回数
  #--------------------------------------------------------------------------
  def enemy_order_time(enemy)
    enemy.make_action_speed2(enemy.action_time[2])
    select_time = 0
    for member in @action_battlers
      select_time += 1
      break @action_battlers.push(enemy) if member.action.speed < enemy.adj_speed
      break @action_battlers.push(enemy) if select_time == @action_battlers.size
    end
  end
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行
  #--------------------------------------------------------------------------
  alias execute_action_n01 execute_action
  def execute_action
    # 技能、物品扩张时如果设定了行动前不清空
    if @active_battler.action.kind != 0
      obj = @active_battler.action.skill if @active_battler.action.kind == 1
      obj = @active_battler.action.item if @active_battler.action.kind == 2
      if obj.extension.include?("行动前不闪光")
        @active_battler.white_flash = false
      end  
    end
    # 角色主动化
    @active_battler.active = true
    execute_action_n01
    # 有技能连发时、行动继续
    if @active_battler.derivation != 0
      @active_battler.action.kind = 1
      @active_battler.action.skill_id = @active_battler.derivation
      @action_battlers.unshift(@active_battler)
    end
    # 有复数行动的敌方时、决定下个行动
    if !@active_battler.actor? && @active_battler.act_time != 0
      @active_battler.make_action
      @active_battler.act_time -= 1
    end
  end
  #--------------------------------------------------------------------------
  # ● 回合完毕  ※再定义
  #--------------------------------------------------------------------------
  def turn_end
    for member in $game_party.members + $game_troop.members
      member.clear_action_results
      next unless member.exist?
      member.slip_damage = false
      actor = member.actor?
      damage = 0
      # 确认是否有0回合解除的状态
      for state in member.states
        member.remove_state(state.id) if state.extension.include?("0回合解除")
        # 实行连续伤害　state = [ 对象, 定数, 比例, POP, 战斗不能许可]
        next unless state.extension.include?("连续伤害")
        for ext in state.slip_extension
          if ext[0] == "hp"
            base_damage = ext[1] + member.maxhp * ext[2] / 100
            damage += base_damage + base_damage * (rand(5) - rand(5)) / 100
            slip_pop = ext[3]
            slip_dead = ext[4]
            slip_damage_flug = true
            member.slip_damage = true
          end
        end  
      end
      # 默认的连续伤害
      if member.slip_damage? && member.exist? && !slip_damage_flug
        damage += member.apply_variance(member.maxhp / 10, 10)
        slip_dead = false
        slip_pop = true
        slip_damage_flug = true
        member.slip_damage = true
      end
      damage = member.hp - 1 if damage >= member.hp && slip_dead = false
      member.hp -= damage
      @spriteset.set_damage_pop(actor, member.index, damage) if slip_pop
      member.perform_collapse if member.dead? && member.slip_damage
      member.clear_action_results
    end
    @status_window.refresh
    # HP和MP的定时改变
    wait(55) if slip_damage_flug
    slip_damage_flug = false
    for member in $game_party.members + $game_troop.members
      member.clear_action_results
      next unless member.exist?
      actor = member.actor?
      mp_damage = 0
      for state in member.states
        next unless state.extension.include?("连续伤害")
        for ext in state.slip_extension
          if ext[0] == "mp"
            base_damage = ext[1] + member.maxmp * ext[2] / 100
            mp_damage += base_damage + base_damage * (rand(5) - rand(5)) / 100
            slip_pop = ext[2]
            slip_damage_flug = true
          end
        end
        member.mp_damage = mp_damage
        member.mp -= mp_damage
        @spriteset.set_damage_pop(actor, member.index, mp_damage) if slip_pop
      end   
      member.clear_action_results
    end
    @status_window.refresh
    # 伤害和回復的定时改变
    wait(55) if slip_damage_flug
    # 是否有自动回复
    for member in $game_party.members
      if member.auto_hp_recover and member.exist?
        plus_hp = member.maxhp / 20
        member.hp += plus_hp
        @spriteset.set_damage_pop(true, member.index, plus_hp * -1)
        plus_hp_flug = true
      end
      member.clear_action_results
    end
    @status_window.refresh
    wait(55) if plus_hp_flug
    @help_window.dispose if @help_window != nil
    @help_window = nil
    move2_info_viewport
    $game_troop.turn_ending = true
    $game_troop.preemptive = false
    $game_troop.surprise = false
    process_battle_event
    $game_troop.turn_ending = false
    start_party_command_selection
  end
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行 : 攻击  ※再定义
  #--------------------------------------------------------------------------
  def execute_action_attack
    if @active_battler.actor?
      if @active_battler.weapon_id == 0
        action = @active_battler.non_weapon
        # 行动中不会死的队员全员为不死身化
        immortaling
      else  
        action = $data_weapons[@active_battler.weapon_id].base_action
        # 用赋予战斗不能的武器来分歧不死身设定
        if $data_weapons[@active_battler.weapon_id].state_set.include?(1)
          for member in $game_party.members + $game_troop.members
            next if member.immortal
            next if member.dead?
            member.dying = true
          end
        else
          immortaling
        end
      end  
    else
      if @active_battler.weapon == 0
        action = @active_battler.base_action
        immortaling
      else
        action = $data_weapons[@active_battler.weapon].base_action
        if $data_weapons[@active_battler.weapon].state_set.include?(1)
          for member in $game_party.members + $game_troop.members
            next if member.immortal
            next if member.dead?
            member.dying = true
          end
        else
          immortaling
        end
      end  
    end
    target_decision
    @spriteset.set_action(@active_battler.actor?, @active_battler.index, action)
    playing_action
  end
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行 : 防御  ※再定义
  #--------------------------------------------------------------------------
  def execute_action_guard
    @help_window.set_text("防御", 1)
    @help_window.visible = true
    # 解除角色的主动化
    @active_battler.active = false
    wait(45)
    @help_window.visible = false
  end
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行 : 逃走
  #--------------------------------------------------------------------------
  def execute_action_escape
    @spriteset.set_action(false, @active_battler.index, @active_battler.run_success)
    @help_window.set_text("逃走", 1)
    @help_window.visible = true
    # 解除角色的主动化
    @active_battler.active = false
    @active_battler.escape
    Sound.play_escape
    wait(45)
    @help_window.visible = false
  end
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行 : 待机  ※再定义
  #--------------------------------------------------------------------------
  def execute_action_wait
    # 解除角色的主动化
    @active_battler.active = false
    wait(45)
  end   
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行 : 技能  ※再定义
  #--------------------------------------------------------------------------
  def execute_action_skill
    skill = @active_battler.action.skill
    # 用赋予战斗不能的技能来分歧不死身设定
    if skill.plus_state_set.include?(1)
      for member in $game_party.members + $game_troop.members
        next if member.immortal
        next if member.dead?
        member.dying = true
      end
    else
      # 行动中不会死的队员全员为不死身化
      immortaling
    end
    # 判别技能使用可能
    return unless @active_battler.skill_can_use?(skill)
    # 决定目标
    target_decision(skill)
    # 动作开始
    @spriteset.set_action(@active_battler.actor?, @active_battler.index, skill.base_action)
    # 帮助窗口中显示技能名
    pop_help(skill)
    # 动作中
    playing_action
    # 技能成本消费
    @active_battler.consum_skill_cost(skill)
    # 还原状态窗口
    @status_window.refresh
    # 取得公共事件
    $game_temp.common_event_id = skill.common_event_id
  end
  #--------------------------------------------------------------------------
  # ● 战斗行动的实行 : 物品  ※再定义
  #--------------------------------------------------------------------------
  def execute_action_item
    item = @active_battler.action.item
    # 用赋予战斗不能的物品来分歧不死身设定
    if item.plus_state_set.include?(1)
      for member in $game_party.members + $game_troop.members
        next if member.immortal
        next if member.dead?
        member.dying = true
      end
    else
      # 行动中不会死的队员全员为不死身化
      immortaling
    end
    $game_party.consume_item(item)
    target_decision(item)
    @spriteset.set_action(@active_battler.actor?, @active_battler.index, item.base_action)
    pop_help(item)
    playing_action
    $game_temp.common_event_id = item.common_event_id
  end
  #--------------------------------------------------------------------------
  # ● 决定目标
  #--------------------------------------------------------------------------
  def target_decision(obj = nil)
    @targets = @active_battler.action.make_targets
    # 目标不存在时、动作中断
    if @targets.size == 0
      action = @active_battler.recover_action
      @spriteset.set_action(@active_battler.actor?, @active_battler.index, action)
    end
    if obj != nil
      # 如果默认了设定复数回合攻击时变换成单体目标
      if obj.for_two? or obj.for_three? or obj.dual?
        @targets = [@targets[0]]
      end
      # 随机目标时、选择的一体保持在随机范围
      if obj.extension.include?("随机目标")
        randum_targets = @targets.dup
        @targets = [randum_targets[rand(randum_targets.size)]]
      end
    end
    # 目标情报发送到角色精灵
    @spriteset.set_target(@active_battler.actor?, @active_battler.index, @targets)
  end   
  #--------------------------------------------------------------------------
  # ● 实行动作中
  #--------------------------------------------------------------------------
  def playing_action
    loop do
      update_basic
      # 查看被归纳在主动角色的动作情报
      action = @active_battler.play
      next if action == 0
      @active_battler.play = 0
      if action[0] == "个别处理"
        individual
      elsif action == "击倒许可"
        unimmortaling
      elsif action == "解除主动"
        break action_end
      elsif action == "完毕"
        break action_end
      elsif action[0] == "对象动画"
        damage_action(action[1])
      end
    end  
  end
  #--------------------------------------------------------------------------
  # ● 个别处理
  #--------------------------------------------------------------------------
  def individual
    # 保持目标情报
    @individual_target = @targets
    @stand_by_target = @targets.dup
  end
  #--------------------------------------------------------------------------
  # ● 击倒禁止
  #--------------------------------------------------------------------------
  def immortaling
    # 赋予全员不死身
    for member in $game_party.members + $game_troop.members
      # 如果不能战斗时跳过处理
      next if member.dead?
      # 有事件等设定不死身创立解除无效的标志
      member.non_dead = true if member.immortal
      member.immortal = true
    end  
  end  
  #--------------------------------------------------------------------------
  # ● 击倒许可
  #--------------------------------------------------------------------------
  def unimmortaling
    # 个别处理中无击败许可
    return if @active_battler.individual
    # 解除全员的不死身化(用事件设定的不死身除外)
    for member in $game_party.members + $game_troop.members
      if member.dying
        member.dying = false
        if member.dead? or member.hp == 0
          member.add_state(1)
          member.perform_collapse
        end
      end
      next if member.non_dead
      next if member.dead?
      member.immortal = false
      member.add_state(1) if member.hp == 0
      member.perform_collapse
    end
    # 在这个时候反映待机动作
    @targets = @stand_by_target if @stand_by_target != nil
    return if @targets == nil or @targets.size == 0
    for target in @targets
      @spriteset.set_stand_by_action(target.actor?, target.index)
      # 确认自动复活
      next unless target.hp == 0
      resurrection(target)
    end  
  end
  #--------------------------------------------------------------------------
  # ● 自动复活
  #--------------------------------------------------------------------------
  def resurrection(target)
    for state in target.states
      for ext in state.extension
        name = ext.split('')
        next unless name[0] == "自"
        wait(50)
        name = name.join
        name.slice!("自动复活/")
        target.hp = target.maxhp * name.to_i / 100
        target.remove_state(1)
        target.remove_state(state.id)
        target.animation_id = N01::RESURRECTION
        target.animation_mirror = true if $back_attack
        @status_window.refresh
        wait($data_animations[N01::RESURRECTION].frame_max * 4)
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● 魔法反射・无效
  #--------------------------------------------------------------------------
  def magic_reflection(target, obj)
    return if obj.physical_attack
    for state in target.states
      for ext in state.extension
        name = ext.split('')
        next unless name[0] == "魔"
        if name[2] == "反"
          name = name.join
          name.slice!("魔法反射/")
          target.animation_id = name.to_i
          target.animation_mirror = true if $back_attack
          @reflection = true
        else
          name = name.join
          name.slice!("魔法无效/")
          target.animation_id = name.to_i
          target.animation_mirror = true if $back_attack
          @invalid = true
        end  
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● 物理反射・无效
  #--------------------------------------------------------------------------
  def physics_reflection(target, obj)
    return if obj != nil && !obj.physical_attack
    for state in target.states
      for ext in state.extension
        name = ext.split('')
        next unless name[0] == "物"
        if name[2] == "反"
          name = name.join
          name.slice!("物理反射/")
          target.animation_id = name.to_i
          target.animation_mirror = true if $back_attack
          @reflection = true
        else
          name = name.join
          name.slice!("物理无效/")
          target.animation_id = name.to_i
          target.animation_mirror = true if $back_attack
          @invalid = true
        end
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● 技能成本吸收
  #--------------------------------------------------------------------------
  def absorb_cost(target, obj)
    for state in target.states
      if state.extension.include?("成本吸收")
        cost = @active_battler.calc_mp_cost(obj)
        # 区分为SP消费和HP消费
        return target.hp += cost if obj.extension.include?("HP消耗")
        return target.mp += cost
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● 吸收处理
  #--------------------------------------------------------------------------
  def absorb_attack(obj, target, index, actor)
    absorb = target.hp_damage
    absorb = target.mp_damage if target.mp_damage != 0
    # 目标是复数同时吸收处理
    @wide_attack = true if obj.scope == 2 or obj.scope == 4 or obj.scope == 6 or obj.extension.include?("全区域")
    if @wide_attack && @absorb == nil && @targets.size != 1
      # 返还吸收的部分
      @active_battler.hp -= @active_battler.hp_damage
      @active_battler.mp -= @active_battler.mp_damage
      # 之后加算吸收返还的数值
      @absorb = absorb
      @absorb_target_size = @targets.size - 2
    elsif @absorb != nil && @absorb_target_size > 0
      @active_battler.hp -= @active_battler.hp_damage
      @active_battler.mp -= @active_battler.mp_damage
      @absorb += absorb
      @absorb_target_size -= 1
    # 处理复数目标的最重吸收
    elsif @absorb != nil
      # 返还吸收的部分
      @active_battler.hp -= @active_battler.hp_damage
      @active_battler.mp -= @active_battler.mp_damage
      @absorb += absorb
      # 在这里反映全部吸收部分
      @active_battler.hp_damage = -@absorb
      @active_battler.mp_damage = -@absorb if target.mp_damage != 0
      @active_battler.hp -= @active_battler.hp_damage
      @active_battler.mp -= @active_battler.mp_damage
      # 吸收量是0时吸收者方面的处理
      absorb_action = ["absorb", nil, false] if @absorb == 0
      absorb_action = [nil, nil, false] if @absorb != 0
      @spriteset.set_damage_action(actor, index, absorb_action)
      @active_battler.perform_collapse
      @absorb = nil
      @absorb_target_size = nil
    # 单体吸收的处理
    else
      if N01::ABSORB_DAMAGE
        # 返还吸收的部分
        @active_battler.hp += @active_battler.hp_damage
        @active_battler.mp += @active_battler.mp_damage
        # 反映吸收
        @active_battler.hp_damage = -absorb
        @active_battler.mp_damage = -absorb if target.mp_damage != 0
        @active_battler.hp -= @active_battler.hp_damage
        @active_battler.mp -= @active_battler.mp_damage
      end
      # 吸收量是0时吸收者方面的处理
      absorb_action = ["absorb", nil, false] if absorb == 0
      absorb_action = [nil, nil, false] if absorb != 0
      @spriteset.set_damage_action(actor, index, absorb_action)
      # 逆向吸收时HP为0时
      @absorb_dead = true if @active_battler.hp == 0 && !@active_battler.non_dead
    end
    # 吸收量是0时对象者方面的处理
    return 0 if absorb == 0
  end
  #--------------------------------------------------------------------------
  # ● 动作完毕
  #--------------------------------------------------------------------------
  def action_end
    # 初期化
    @individual_target = nil
    @help_window.visible = false if @help_window != nil && @help_window.visible
    @active_battler.active = false
    @active_battler.clear_action_results
    # 慎重起见解除不死身化
    unimmortaling
    # 被反射时
    if @active_battler.reflex != nil
      if @active_battler.action.skill?
        obj = @active_battler.action.skill
        @active_battler.perfect_skill_effect(@active_battler, obj)
      elsif @active_battler.action.item?
        obj = @active_battler.action.item
        @active_battler.item_effect(@active_battler, obj)
      else
        @active_battler.perfect_attack_effect(@active_battler)
      end
      pop_damage(@active_battler, obj, @active_battler.reflex)
      @active_battler.perform_collapse
      @active_battler.reflex = nil
      wait(N01::COLLAPSE_WAIT)
    end
    #因逆向吸收战斗不能时
    if @absorb_dead
      @active_battler.perform_collapse
      @absorb_dead = false
      wait(N01::COLLAPSE_WAIT)
    end
    # 缩短到下次行动前的等待
    wait(N01::ACTION_WAIT)
  end  
  #--------------------------------------------------------------------------
  # ● 伤害处理
  #--------------------------------------------------------------------------
  def damage_action(action)
    # 单独处理时目标一个一个发出
    @targets = [@individual_target.shift] if @active_battler.individual
    # 技能时
    if @active_battler.action.skill?
      obj = @active_battler.action.skill
      for target in @targets
        return if target == nil
        return if target.dead? && !obj.for_dead_friend?
        # HP为0时战斗不能復活以外不MISS
        target.revival = true if obj.for_dead_friend?
        if target.hp == 0 && !obj.for_dead_friend?
          target.perfect_skill_effect(@active_battler, obj)
        # 确认必中
        elsif obj.extension.include?("必中")
          target.perfect_skill_effect(@active_battler, obj)
        else
          # 确认反射
          magic_reflection(target, obj) unless obj.extension.include?("无视反射")
          physics_reflection(target, obj) unless obj.extension.include?("无视反射")
          # 计算伤害
          target.skill_effect(@active_battler, obj) unless @reflection or @invalid
        end  
        pop_damage(target, obj, action) unless @reflection or @invalid
        # 确认成本吸收
        absorb_cost(target, obj)
        # 获取反射动作
        @active_battler.reflex = action if @reflection
        @reflection = false
        @invalid = false
      end
    # 物品时
    elsif @active_battler.action.item?
      obj = @active_battler.action.item
      for target in @targets
        return if target == nil
        return if target.dead? && !obj.for_dead_friend?
        target.revival = true if obj.for_dead_friend?
        if target.hp == 0 && !obj.for_dead_friend?
          target.perfect_item_effect(@active_battler, obj)
        elsif obj.extension.include?("必中")
          target.perfect_item_effect(@active_battler, obj)
        else
          magic_reflection(target, obj) unless obj.extension.include?("无视反射")
          physics_reflection(target, obj) unless obj.extension.include?("无视反射")
          target.item_effect(@active_battler, obj) unless @reflection or @invalid
        end
        pop_damage(target, obj, action) unless @reflection or @invalid
        @active_battler.reflex = action if @reflection
        @reflection = false
        @invalid = false
      end
    # 通常攻击时
    else
      for target in @targets
        return if target == nil or target.dead?
        physics_reflection(target, nil)
        target.perfect_attack_effect(@active_battler) if target.hp <= 0
        target.attack_effect(@active_battler) unless target.hp <= 0 or @reflection or @invalid
        pop_damage(target, nil, action) unless @reflection or @invalid
        # 获取反射动作
        @active_battler.reflex = action if @reflection
        @reflection = false
        @invalid = false
      end
    end
    # 还原状态窗口
    @status_window.refresh
    # 考虑连续性懂得随机目标、立刻选择下个目标
    return if obj == nil
    target_decision(obj) if obj.extension.include?("随机目标")
  end
  #--------------------------------------------------------------------------
  # ● 伤害表示  action = [动画ID,反转标志,动作许可]
  #--------------------------------------------------------------------------
  def pop_damage(target, obj, action)
    index = @active_battler.index
    actor = @active_battler.actor?
    if obj != nil
      # 技能或者物品是吸收属性时
      absorb = absorb_attack(obj, target, index, actor) if obj.absorb_damage
      action.push(true) if absorb == 0
      # 扩张设定为伤害动作禁止时
      action[2] = false if obj.extension.include?("禁止伤害动作")
    end
    # 还原对象
    @spriteset.set_damage_action(target.actor?, target.index, action)
  end
end  
#==============================================================================
# ■ Game_BattleAction
#------------------------------------------------------------------------------
# 　战斗行动处理的类。
#==============================================================================
class Game_BattleAction
  #--------------------------------------------------------------------------
  # ● 判定行动是否有效  ※再定义
  #--------------------------------------------------------------------------
  def valid?
    return false if nothing?                      # 什么都不作
    return true if @forcing                       # 强制行动中
    return false unless battler.movable?          # 行动不能
    if skill?                                     # 技能
      if battler.derivation != 0
        battler.derivation = 0
        return true
      end  
      return false unless battler.skill_can_use?(skill)
    elsif item?                                   # 物品
      return false unless friends_unit.item_can_use?(item)
    end
    return true
  end
  #--------------------------------------------------------------------------
  # ● 作成目标的排列  ※再定义
  #--------------------------------------------------------------------------
  def make_targets
    if attack?
      return make_attack_targets
    elsif skill?
      targets = make_obj_targets(skill)
      targets = make_obj_targets2(skill, targets) if skill.extension != ["无"]
      return targets
    elsif item?
      targets = make_obj_targets(item)
      targets = make_obj_targets2(item, targets) if item.extension != ["无"]
      return targets
    end
  end
  #--------------------------------------------------------------------------
  # ● 作成技能或是物品的目标的扩张
  #--------------------------------------------------------------------------
  def make_obj_targets2(obj, targets)
    if obj.extension.include?("全区域")
      targets = []
      targets += opponents_unit.existing_members
      targets += friends_unit.existing_members
    end
    if obj.extension.include?("自身以外")
      targets.delete($game_party.members[battler.index]) if battler.actor?
      targets.delete($game_troop.members[battler.index]) unless battler.actor?
    end
    return targets.compact
  end
end
#==============================================================================
# ■ Sprite_Base
#------------------------------------------------------------------------------
# 　追加了动画的表示处理的精灵的类。
#==============================================================================
class Sprite_Base < Sprite
  #--------------------------------------------------------------------------
  # ● 动画的更新 动画追随精灵
  #--------------------------------------------------------------------------
  alias update_animation_n01 update_animation
  def update_animation
    @animation_ox = x - ox + width / 2
    @animation_oy = y - oy + height / 2
    update_animation_n01
  end
end  
#==============================================================================
# ■ Spriteset_Battle
#------------------------------------------------------------------------------
# 　整理战斗画面的精灵的类。
#==============================================================================
class Spriteset_Battle
  #--------------------------------------------------------------------------
  # ● 敌方精灵的作成
  #--------------------------------------------------------------------------
  def create_enemies
    @enemy_sprites = []
    for i in 0...$game_troop.members.size
      enemy = $game_troop.members
      @enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
      # 战斗开始启动动作
      @enemy_sprites.opacity = 0 if $game_troop.members.hidden
      @enemy_sprites.first_action if $game_troop.members != nil
    end
  end
  #--------------------------------------------------------------------------
  # ● 主人公精灵的作成
  #--------------------------------------------------------------------------
  def create_actors
    @actor_sprites = []
    # 准备成员最大数精灵
    member = N01::MAX_MEMBER
    for i in 0...member
      actor = $game_party.members
      @actor_sprites.push(Sprite_Battler.new(@viewport1, actor))
      # 战斗开始启动动作
      @actor_sprites.first_action if $game_party.members != nil
    end
  end
  #--------------------------------------------------------------------------
  # ● 战斗层精灵的作成
  #--------------------------------------------------------------------------
  def create_battlefloor
    @battlefloor_sprite = Sprite.new(@viewport1)
    @battlefloor_sprite.bitmap = Cache.system("BattleFloor")
    @battlefloor_sprite.x = N01::FLOOR[0]
    @battlefloor_sprite.y = N01::FLOOR[1]
    @battlefloor_sprite.z = N01::FLOOR[2]
    @battlefloor_sprite.opacity = 128
    # 偷袭时時、反转层面和背景
    back_attack
    if $back_attack
      @battlefloor_sprite.mirror = true
      @battleback_sprite.mirror = true
      $game_troop.surprise = true
    else  
      $game_troop.surprise = false
    end  
  end  
  #--------------------------------------------------------------------------
  # ● 背部攻击
  #--------------------------------------------------------------------------
  def back_attack  
    # 強制背部攻击时标志ON
    for i in 0...N01::BACK_ATTACK_SWITCH.size
      return $back_attack = true if $game_switches[N01::BACK_ATTACK_SWITCH]
    end
    # 如果没发生偷袭时将中断处理
    return $back_attack = false unless $game_troop.surprise && N01::BACK_ATTACK
    # 确认根据装备等背部攻击的无效化
    for actor in $game_party.members
      return $back_attack = false if N01::NON_BACK_ATTACK_WEAPONS.include?(actor.weapon_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR1.include?(actor.armor1_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR2.include?(actor.armor2_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR3.include?(actor.armor3_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR4.include?(actor.armor4_id)
      for i in 0...N01::NON_BACK_ATTACK_SKILLS.size
        return $back_attack = false if actor.skill_id_learn?(N01::NON_BACK_ATTACK_SKILLS)
      end  
    end
    # 发生背部攻击
    $back_attack = true
  end
  #--------------------------------------------------------------------------
  # ● 主人公精灵的更新  ※再定义
  #--------------------------------------------------------------------------
  def update_actors
    for i in 0...$game_party.members.size
      if @actor_sprites.battler.id != $game_party.members.id
        @actor_sprites.battler = $game_party.members
        @actor_sprites.make_battler
        @actor_sprites.first_action
      end  
    end  
    for sprite in @actor_sprites
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  # ● 伤害动作组合　
  #--------------------------------------------------------------------------  
  def set_damage_action(actor, index, action)
    @actor_sprites[index].damage_action(action) if actor
    @enemy_sprites[index].damage_action(action) unless actor
  end
  #--------------------------------------------------------------------------
  # ● 伤害POP组合　
  #--------------------------------------------------------------------------  
  def set_damage_pop(actor, index, damage)
    @actor_sprites[index].damage_pop(damage) if actor
    @enemy_sprites[index].damage_pop(damage) unless actor
  end
  #--------------------------------------------------------------------------
  # ● 目标组合
  #--------------------------------------------------------------------------  
  def set_target(actor, index, target)
    @actor_sprites[index].get_target(target) if actor
    @enemy_sprites[index].get_target(target) unless actor
  end
  #--------------------------------------------------------------------------
  # ● 动作组合
  #--------------------------------------------------------------------------  
  def set_action(actor, index, kind)
    @actor_sprites[index].start_action(kind) if actor
    @enemy_sprites[index].start_action(kind) unless actor
  end  
  #--------------------------------------------------------------------------
  # ● 待机动作组合
  #--------------------------------------------------------------------------  
  def set_stand_by_action(actor, index)
    @actor_sprites[index].push_stand_by if actor
    @enemy_sprites[index].push_stand_by unless actor
  end  
  #--------------------------------------------------------------------------
  # ● 光标移动的组合
  #--------------------------------------------------------------------------  
  def set_cursor(actor, index)
    return [@actor_sprites[index].x, @actor_sprites[index].y] if actor
    return [@enemy_sprites[index].x, @enemy_sprites[index].y] unless actor
  end
end
#==============================================================================
# ■ Sprite_MoveAnime
#------------------------------------------------------------------------------
# 　动画飞出用的精灵。
#==============================================================================
class Sprite_MoveAnime < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :battler
  attr_accessor :base_x   # 自身的基本X坐标
  attr_accessor :base_y   # 自身的基本Y坐标
  #--------------------------------------------------------------------------
  # ● 客观初期化
  #--------------------------------------------------------------------------
  def initialize(viewport,battler = nil)
    super(viewport)
    @battler = battler
    self.visible = false
    @base_x = 0
    @base_y = 0
    @move_x = 0                # 移动后的X坐标
    @move_y = 0                # 移动后Y坐标
    @moving_x = 0              # 1单位相当移动的X坐标
    @moving_y = 0              # 1单位相当移动的Y坐标
    @orbit = 0                 # 圆轨道
    @orbit_plus = 0            # 加算的圆轨道
    @orbit_time = 0            # 圆轨道计算时间
    @through = false           # 是否贯通
    @finish = false            # 移动完毕的标志
    @time = 0                  # 一动时间
    @angle = 0                 # 武器的角度
    @angling = 0               # 1单位相当移动的武器的角度
  end
  #--------------------------------------------------------------------------
  # ● 获取动作
  #--------------------------------------------------------------------------  
  def anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,icon_index,icon_weapon)
    # 算出1单位相当的移动距离
    @time = speed
    @moving_x = distanse_x / speed
    @moving_y = distanse_y / speed
    # 是否贯通
    @through = true if type == 1
    # 获取圆轨道
    @orbit_plus = orbit
    @orbit_time = @time
    # 有无武器图片
    if weapon != ""
      action = N01::ANIME[weapon].dup
      @angle = action[0]
      end_angle = action[1]
      time = action[2]
      # 调出1单位相当的旋转角度
      @angling = (end_angle - @angle)/ time
      # 取得开始角度
      self.angle = @angle
      # 显示武器图片
      self.mirror = mirror
      if icon_weapon
        self.bitmap = Cache.system("Iconset")
        self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
        self.ox = 12
        self.oy = 12
      else
        self.bitmap = Cache.character(icon_index)
        self.ox = self.bitmap.width / 2
        self.oy = self.bitmap.height / 2
      end  
      self.visible = true
      # 显示在角色面前
      self.z = 1000
    end  
    # 最初不动只显示一次
    self.x = @base_x + @move_x
    self.y = @base_y + @move_y + @orbit
    if id != 0
      animation = $data_animations[id]
      start_animation(animation, mirror)
    end
  end  
  #--------------------------------------------------------------------------
  # ● 变化了的移动组合
  #--------------------------------------------------------------------------  
  def action_reset
    @moving_x = @moving_y = @move_x = @move_y = @base_x = @base_y = @orbit = 0
    @orbit_time = @angling = @angle = 0   
    @through = self.visible = @finish = false
    dispose_animation
  end   
  #--------------------------------------------------------------------------
  # ● 贯通完毕
  #--------------------------------------------------------------------------  
  def finish?
    return @finish
  end
  #--------------------------------------------------------------------------
  # ● 单位更新
  #--------------------------------------------------------------------------
  def update
    super
    # 时间消耗
    @time -= 1
    # 时间内指定的移动
    if @time >= 0
      @move_x += @moving_x
      @move_y += @moving_y
      # 计算圆轨道
      if @time < @orbit_time / 2
        @orbit_plus = @orbit_plus * 5 / 4
      elsif @time == @orbit_time / 2
        @orbit_plus *= -1
      else
        @orbit_plus = @orbit_plus * 2 / 3
      end  
      @orbit += @orbit_plus
    end   
    # 就算时间完毕如果是贯穿的话也会继续直进
    @time = 100 if @time < 0 && @through
    @finish = true if @time < 0 && !@through
    # 更新精灵的坐标
    self.x = @base_x + @move_x
    self.y = @base_y + @move_y + @orbit
    # 贯穿时、从画面消失的完毕标志ON
    if self.x < -200 or self.x > 840 or self.y < -200 or self.y > 680
      @finish = true
    end
    # 更新武器图片
    if self.visible
      @angle += @angling
      self.angle = @angle
    end  
  end
end
#==============================================================================
# ■ Sprite_Weapon
#------------------------------------------------------------------------------
# 　显示武器用的精灵。
#==============================================================================
class Sprite_Weapon < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :battler
  #--------------------------------------------------------------------------
  # ● 客观初始化
  #--------------------------------------------------------------------------
  def initialize(viewport,battler = nil)
    super(viewport)
    @battler = battler
    @action = []                     # 武器的动作情报
    @move_x = 0                      # 移动后的X坐标
    @move_y = 0                      # 移动后的Y坐标
    @move_z = 0                      # 移动后的Z坐标
    @plus_x = 0                      # 略微调整X坐标
    @plus_y = 0                      # 略微调整Y坐标
    @angle = 0                       # 武器的旋转角度
    @zoom_x = 1                      # 武器的横向放大率
    @zoom_y = 1                      # 武器的纵向放大率
    @moving_x = 0                    # 1单位相当移动的X坐标
    @moving_y = 0                    # 1单位相当移动的Y坐标
    @angling = 0                     # 1单位相当的旋转角度
    @zooming_x = 1                   # 1单位相当的横向放大率
    @zooming_y = 1                   # 1单位相当的纵向放大率   
    @freeze = -1                     # 固定动画用的武器位置
    @mirroring = false               # 角色是否为反转
    @time = N01::ANIME_PATTERN + 1   # 更新回数
    # 获取武器
    weapon_graphics
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    super
  end
  #--------------------------------------------------------------------------
  # ● 获取武器
  #--------------------------------------------------------------------------  
  def weapon_graphics(left = false)
    if @battler.actor?
      weapon = @battler.weapons[0] unless left
      weapon = @battler.weapons[1] if left
    else
      weapon = $data_weapons[@battler.weapon]
      # 确认敌方的反转标志
      @mirroring = true if @battler.action_mirror
    end
    # 如果没有武器时处理被取消
    return if weapon == nil
    # 如果用ICON时
    if weapon.graphic == ""
      icon_index = weapon.icon_index
      self.bitmap = Cache.system("Iconset")
      self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      @weapon_width = @weapon_height = 24
    # 如果有指定ID时、获取不是ICON的图片  
    else
      self.bitmap = Cache.character(weapon.graphic)
      @weapon_width = self.bitmap.width
      @weapon_height = self.bitmap.height
    end
  end
  #--------------------------------------------------------------------------
  # ● 获取动画固定时的武器位置
  #--------------------------------------------------------------------------  
  def freeze(action)
    @freeze = action
  end
  #--------------------------------------------------------------------------
  # ● 获取武器动作 freeze
  #--------------------------------------------------------------------------  
  def weapon_action(action,loop)
    # 没有名称时不显示
    if action == ""
      self.visible = false
    # 空手时不显示
    elsif @weapon_id == 0
      self.visible = false
    # 受取武器的动作情报
    else
      @action = N01::ANIME[action]
      act0 = @action[0]
      act1 = @action[1]
      act2 = @action[2]
      act3 = @action[3]
      act4 = @action[4]
      act5 = @action[5]
      act6 = @action[6]
      act7 = @action[7]
      act8 = @action[8]
      act9 = @action[9]
      act10 = @action[10]
      # 角色为反转时、X轴的动作也逆转
      if @mirroring
        act0 *= -1
        act3 *= -1
        act4 *= -1
        act9 *= -1
      end
      # 背部攻击时逆转
      if $back_attack && N01::BACK_ATTACK
        act0 *= -1
        act3 *= -1
        act4 *= -1
        act9 *= -1
      end
      # 确认角色的动画图片数
      time = N01::ANIME_PATTERN
      # 确认Z坐标
      if act2
        self.z = @battler.position_z + 1
      else
        self.z = @battler.position_z - 1
      end
      # 在这里实行反转、如果已经反转就还原
      if act6
        if self.mirror
          self.mirror = false
        else
          self.mirror = true
        end
      end
      # 反映角色的反转
      if @mirroring
        if self.mirror
          self.mirror = false
        else
          self.mirror = true
        end
      end
      # 背后攻击时逆转
      if $back_attack && N01::BACK_ATTACK
        if self.mirror
          self.mirror = false
        else
          self.mirror = true
        end
      end  
      # 计算以动画图片数相除的变化
      @moving_x = act0 / time
      @moving_y = act1 / time
      # 代入最初的角度
      @angle = act3
      self.angle = @angle
      # 计算更新角度
      @angling = (act4 - act3)/ time
      # 角度没有被插入时、在这里加算剩余旋转的部分
      @angle += (act4 - act3) % time
      # 放大缩小
      @zooming_x = (1 - act7) / time
      @zooming_y = (1 - act8) / time
      # 如果是反转时、逆转反转前的原点
      if self.mirror
        case act5
        when 1 # 左上→到右上
          act5 = 2
        when 2 # 右上→到左上
          act5 = 1
        when 3 # 左下→到右下
          act5 = 4
        when 4 # 右下→到左下
          act5 = 3
        end  
      end   
      # 设定旋转前的原点
      case act5
      when 0 # 中心
        self.ox = @weapon_width / 2
        self.oy = @weapon_height / 2
      when 1 # 左上
        self.ox = 0
        self.oy = 0
      when 2 # 右上
        self.ox = @weapon_width
        self.oy = 0
      when 3 # 左下
        self.ox = 0
        self.oy = @weapon_height
      when 4 # 右下
        self.ox = @weapon_width
        self.oy = @weapon_height
      end  
      # 略微调整坐标
      @plus_x = act9
      @plus_y = act10
      # 往返循环时标志ON
      @loop = true if loop == 0
      # 第一次时0开始、在这时作－1回的动作
      @angle -= @angling
      @zoom_x -= @zooming_x
      @zoom_y -= @zooming_y
      # 更新精灵的坐标
      @move_x -= @moving_x
      @move_y -= @moving_y
      @move_z = 1000 if act2
      # 固定动画时、在这时消化动作
      if @freeze != -1
        for i in 0..@freeze + 1
          @angle += @angling
          @zoom_x += @zooming_x
          @zoom_y += @zooming_y
          # 更新精灵的坐标
          @move_x += @moving_x
          @move_y += @moving_y
        end
        @angling = 0
        @zooming_x = 0
        @zooming_y = 0
        @moving_x = 0
        @moving_y = 0
      end
      # 可视
      self.visible = true
    end
  end  
  #--------------------------------------------------------------------------
  # ● 变化后的动作全部组合
  #--------------------------------------------------------------------------  
  def action_reset
    @moving_x = @moving_y = @move_x = @move_y = @plus_x = @plus_y = 0
    @angling = @zooming_x = @zooming_y = @angle = self.angle = @move_z = 0
    @zoom_x = @zoom_y = self.zoom_x = self.zoom_y = 1
    self.mirror = self.visible = @loop = false
    @freeze = -1
    @action = []
    @time = N01::ANIME_PATTERN + 1
  end
  #--------------------------------------------------------------------------
  # ● 作出往返循环
  #--------------------------------------------------------------------------  
  def action_loop
    # 让动作相反
    @angling *= -1
    @zooming_x *= -1
    @zooming_y *= -1
    @moving_x *= -1
    @moving_y *= -1
  end  
  #--------------------------------------------------------------------------
  # ● 主人公是反转时、自身也反转
  #--------------------------------------------------------------------------
  def mirroring
    return @mirroring = false if @mirroring
    @mirroring = true
  end  
  #--------------------------------------------------------------------------
  # ● 只有在主人公动画被更新时武器动作的変化也更新
  #--------------------------------------------------------------------------
  def action
    return if @time <= 0
    @time -= 1
    # 旋转、更新放大缩小
    @angle += @angling
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    # 更新精灵的坐标
    @move_x += @moving_x
    @move_y += @moving_y
    # 往返循环时动作反转
    if @loop && @time == 0
      @time = N01::ANIME_PATTERN + 1
      action_loop
    end
  end  
  #--------------------------------------------------------------------------
  # ● 单位更新
  #--------------------------------------------------------------------------
  def update
    super
    # 旋转、更新放大缩小
    self.angle = @angle
    self.zoom_x = @zoom_x
    self.zoom_y = @zoom_y
    # 更新精灵的坐标
    self.x = @battler.position_x + @move_x + @plus_x
    self.y = @battler.position_y + @move_y + @plus_y
    self.z = @battler.position_z + @move_z - 1
  end
end#==============================================================================
# ■ Game_Battler (分割定义 1)
#------------------------------------------------------------------------------
# 　处理角色的类。
#==============================================================================
class Game_Battler
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :hp_damage        # 行动結果: HP 伤害
  attr_accessor :mp_damage        # 行动結果: MP 伤害
  attr_accessor :move_x           # X方向的移动修正
  attr_accessor :move_y           # Y方向的移动修正
  attr_accessor :move_z           # Z方向的移动修正
  attr_accessor :jump             # 修正跳跃
  attr_accessor :active           # 是否主动
  attr_accessor :non_dead         # 不死身标志
  attr_accessor :dying            # 即死标志
  attr_accessor :slip_damage      # 连续伤害标志
  attr_accessor :derivation       # 技能连发ID
  attr_accessor :individual       # 技能连发ID
  attr_accessor :play             # 动作情报
  attr_accessor :force_action     # 强制动作情报
  attr_accessor :force_target     # 目标变更情报
  attr_accessor :revival          # 复活
  attr_accessor :double_damage    # HPMP两方同时伤害
  attr_accessor :reflex           # 技能反射情报
  attr_accessor :absorb           # 技能成本吸收
  attr_reader   :base_position_x  # 初期配置X坐标
  attr_reader   :base_position_y  # 初期配置Y坐标   
  attr_accessor :force_damage     # 事件的伤害
  #--------------------------------------------------------------------------
  # ● 客观初期化
  #--------------------------------------------------------------------------
  alias initialize_n01 initialize
  def initialize
    initialize_n01
    @move_x = @move_y = @move_z = @plus_y = @jump = @derivation = @play = 0
    @force_action = @force_target = @base_position_x = @base_position_y = 0
    @absorb = @act_time = @force_damage = 0
    @active = @non_dead = @individual = @slip_damage = @revival = false
    @double_damage = @dying = false
  end
  #--------------------------------------------------------------------------
  # ● 返还最新的状态ID
  #--------------------------------------------------------------------------
  def state_id
    return @states[@states.size - 1]
  end
  #--------------------------------------------------------------------------
  # ● 判定技能的使用可能  ※再定义
  #--------------------------------------------------------------------------
  def skill_can_use?(skill)
    return false unless skill.is_a?(RPG::Skill)
    return false unless movable?
    return false if silent? and skill.spi_f > 0
    if skill.extension.include?("HP消耗")
      return false if calc_mp_cost(skill) > hp
    else
      return false if calc_mp_cost(skill) > mp
    end
    if $game_temp.in_battle
      return skill.battle_ok?
    else
      return skill.menu_ok?
    end
  end
  #--------------------------------------------------------------------------
  # ● 技能的消费 MP 计算  ※再定义
  #--------------------------------------------------------------------------
  def calc_mp_cost(skill)
    if half_mp_cost && !skill.extension.include?("MP消耗减半无效")
      cost = skill.mp_cost / 2
    else
      cost = skill.mp_cost
    end
    if skill.extension.include?("%成本MAX")
      return self.maxhp * cost / 100 if skill.extension.include?("HP消耗")
      return self.maxmp * cost / 100
    elsif skill.extension.include?("%成本NOW")
      return self.hp * cost / 100 if skill.extension.include?("HP消耗")
      return self.mp * cost / 100
    end
    return cost
  end
  #--------------------------------------------------------------------------
  # ● 技能成本消费
  #--------------------------------------------------------------------------
  def consum_skill_cost(skill)
    return false unless skill_can_use?(skill)
    cost = calc_mp_cost(skill)
    return self.hp -= cost if skill.extension.include?("HP消耗")
    return self.mp -= cost
  end
  #--------------------------------------------------------------------------
  # ● 根据通常攻击计算伤害  修正二刀流
  #--------------------------------------------------------------------------
  alias make_attack_damage_value_n01 make_attack_damage_value
  def make_attack_damage_value(attacker)
    make_attack_damage_value_n01(attacker)
    # 只有在装备了两把武器时修正有效
    return unless attacker.actor?
    return if attacker.weapons[0] == nil
    return if attacker.weapons[1] == nil
    @hp_damage = @hp_damage * N01::TWO_SWORDS_STYLE[0] / 100
  end
  #--------------------------------------------------------------------------
  # ● 根据技能或者物品来计算伤害　修正二刀流
  #--------------------------------------------------------------------------
  alias make_obj_damage_value_n01 make_obj_damage_value
  def make_obj_damage_value(user, obj)
    make_obj_damage_value_n01(user, obj)
    # 只有在装备了两把武器时修正有效
    return unless user.actor?
    return if user.weapons[0] == nil
    return if user.weapons[1] == nil
    if obj.damage_to_mp  
      @mp_damage = @mp_damage * N01::TWO_SWORDS_STYLE[1] / 100 # 伤害MP
    else
      @hp_damage = @hp_damage * N01::TWO_SWORDS_STYLE[1] / 100 # 伤害HP
    end
  end
  #--------------------------------------------------------------------------
  # ● 使用通常攻击的効果  全部战斗不能，不能绝对回避的处理
  #--------------------------------------------------------------------------
  def perfect_attack_effect(attacker)
    clear_action_results
    make_attack_damage_value(attacker)            # 计算伤害
    execute_damage(attacker)                      # 反映伤害
    apply_state_changes(attacker)                 # 状态变化
  end
  #--------------------------------------------------------------------------
  # ● 使用技能的效果  全部战斗不能，不能绝对回避的处理
  #--------------------------------------------------------------------------
  def perfect_skill_effect(user, skill)
    clear_action_results
    make_obj_damage_value(user, skill)            # 伤害計算
    make_obj_absorb_effect(user, skill)           # 吸収効果計算
    execute_damage(user)                          # 伤害反映
    apply_state_changes(skill)                    # ステート変化
  end
  #--------------------------------------------------------------------------
  # ● 使用物品的効果  全部战斗不能，不能绝对回避的处理
  #--------------------------------------------------------------------------
  def perfect_item_effect(user, item)
    clear_action_results
    hp_recovery = calc_hp_recovery(user, item)    # 计算HP的回复量
    mp_recovery = calc_mp_recovery(user, item)    # 计算MP的回复量
    make_obj_damage_value(user, item)             # 计算伤害
    @hp_damage -= hp_recovery                     # 扣除HP的回复量
    @mp_damage -= mp_recovery                     # 扣除MP的回复量
    make_obj_absorb_effect(user, item)            # 计算吸收效果
    execute_damage(user)                          # 反映伤害
    item_growth_effect(user, item)                # 使用成长效果
    if item.physical_attack and @hp_damage == 0   # 物理ノー伤害判定
      return                                    
    end
    apply_state_changes(item)                     # 状态变化
  end
  #--------------------------------------------------------------------------
  # ● 伤害的反映
  #--------------------------------------------------------------------------
  alias execute_damage_n01 execute_damage
  def execute_damage(user)
    execute_damage_n01(user)
    # 吸収时这里的处理相冲
    if @absorbed               
      user.hp_damage = -@hp_damage
      user.mp_damage = -@mp_damage
    end
  end
  #--------------------------------------------------------------------------
  # ● 使用技能的効果
  #--------------------------------------------------------------------------
  alias skill_effect_n01 skill_effect
  def skill_effect(user, obj)
    # 保持变化前的HPMP
    nowhp = self.hp
    nowmp = self.mp
    # 为了计算现在HPMP的威力获取变化前的使用者的HPMP
    if obj.extension.include?("HP消耗")
      user_hp = user.hp + user.calc_mp_cost(obj)
      user_mp = user.mp
    else  
      user_hp = user.hp
      user_mp = user.mp + user.calc_mp_cost(obj)
    end  
    # 确认扩张设定
    check_extension(obj)
    # 计算伤害
    skill_effect_n01(user, obj)
    # 有伤害系的扩张时这里的处理会相冲
    if @extension
      self.hp = nowhp
      self.mp = nowmp
    end
    # 攻击未名中时中断处理
    return if self.evaded or self.missed
    # 变换伤害属性
    damage = @hp_damage unless obj.damage_to_mp
    damage = @mp_damage if obj.damage_to_mp
    # 比例伤害
    if @ratio_maxdamage != nil
      damage = self.maxhp * @ratio_maxdamage / 100 unless obj.damage_to_mp
      damage = self.maxmp * @ratio_maxdamage / 100 if obj.damage_to_mp
    end
    if @ratio_nowdamage != nil
      damage = self.hp * @ratio_nowdamage / 100 unless obj.damage_to_mp
      damage = self.mp * @ratio_nowdamage / 100 if obj.damage_to_mp
    end
    # 成本威力
    if @cost_damage
      cost = user.calc_mp_cost(obj)
      if obj.extension.include?("HP消耗")
        damage = damage * cost / user.maxhp
      else
        damage = damage * cost / user.maxmp
      end
    end
    # 现在HP威力
    damage = damage * user_hp / user.maxhp if @nowhp_damage
    # 现在MP威力
    damage = damage * user_mp / user.maxmp if @nowmp_damage
    # 放弃伤害属性的变换
    @hp_damage = damage unless obj.damage_to_mp
    @mp_damage = damage if obj.damage_to_mp
    # 反应扩张
    if @extension
      self.hp -= @hp_damage
      self.mp -= @mp_damage
    end
    # 初期化
    @extension = false
    @cost_damage = false
    @nowhp_damage = false
    @nowmp_damage = false
    @ratio_maxdamage = nil
    @ratio_nowdamage = nil
  end
  #--------------------------------------------------------------------------
  # ● 确认扩张设定
  #--------------------------------------------------------------------------
  def check_extension(skill)
    for ext in skill.extension
      # 成本威力
      if ext == "成本威力"  
        @extension = true
        next @cost_damage = true
      # 现在HP威力
      elsif ext == "现HP威力"
        @extension = true
        next @nowhp_damage = true
      # 现在MP威力
      elsif ext == "现MP威力"
        @extension = true
        next @nowmp_damage = true
      else
        # 比例伤害
        name = ext.split('')
        if name[5] == "M"
          name = name.join
          name.slice!("%伤害MAX/")
          @extension = true
          next @ratio_maxdamage = name.to_i
        elsif name[5] == "N"
          name = name.join
          name.slice!("%伤害NOW/")
          @extension = true
          next @ratio_nowdamage = name.to_i
        end  
      end
    end  
  end
  #--------------------------------------------------------------------------
  # ● 初期配置的変更
  #--------------------------------------------------------------------------
  def change_base_position(x, y)
    @base_position_x = x
    @base_position_y = y
  end
  #--------------------------------------------------------------------------
  # ● 初期化
  #--------------------------------------------------------------------------
  def reset_coordinate
    @move_x = @move_y = @move_z = @jump = @derivation = 0
    @active = @non_dead = @individual = false   
  end
  #--------------------------------------------------------------------------
  # ● 使用连续伤害的効果
  #--------------------------------------------------------------------------
  def slip_damage_effect
    if slip_damage? and @hp > 0
      @hp_damage = apply_variance(maxhp / 10, 10)
      @hp_damage = @hp - 1 if @hp_damage >= @hp
      self.hp -= @hp_damage
    end
  end
  #--------------------------------------------------------------------------
  # ● 事件的伤害POP
  #--------------------------------------------------------------------------
  def damage_num(num = nil)
    return if dead? or !$game_temp.in_battle or num == 0
    @force_damage = num
  end
end  
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　处理主人公的类。
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :two_swords_change          # 强制替换二刀流的标志
  #--------------------------------------------------------------------------
  # ● 根据ID判定技能是否习得
  #--------------------------------------------------------------------------
  def skill_id_learn?(skill_id)
    return @skills.include?(skill_id)
  end
  #--------------------------------------------------------------------------
  # ● 判定技能的使用可能  ※再定义
  #--------------------------------------------------------------------------
  def skill_can_use?(skill)
    return super
  end
  #--------------------------------------------------------------------------
  # ● 图片的变更
  #--------------------------------------------------------------------------
  def graphic_change(character_name)
    @character_name = character_name
  end
  #--------------------------------------------------------------------------
  # ● 击倒的实行 ※再定义
  #--------------------------------------------------------------------------
  def perform_collapse
    Sound.play_actor_collapse if $game_temp.in_battle and dead?
  end
  #--------------------------------------------------------------------------
  # ● 初期配置的取得
  #--------------------------------------------------------------------------
  def base_position
    base = N01::ACTOR_POSITION[self.index]
    @base_position_x = base[0]
    @base_position_y = base[1]
    # バックアタック時はX軸を逆に
    @base_position_x = Graphics.width - base[0] if $back_attack && N01::BACK_ATTACK
  end
  #--------------------------------------------------------------------------
  # ● 战斗画面 X 坐标的取得
  #--------------------------------------------------------------------------
  def position_x
    return 0 if self.index == nil
    return @base_position_x + @move_x
  end
  #--------------------------------------------------------------------------
  # ● 战斗画面 Y 坐标的取得
  #--------------------------------------------------------------------------
  def position_y
    return 0 if self.index == nil
    return @base_position_y + @move_y + @jump
  end
  #--------------------------------------------------------------------------
  # ● 战斗画面 Z 坐标的取得
  #--------------------------------------------------------------------------
  def position_z
    return 0 if self.index == nil
    return self.index + @base_position_y + @move_y + @move_z - @jump + 200
  end  
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　处理敌方的类。
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :adj_speed        # 复数会合行动的速度修正
  attr_accessor :act_time         # 行动数回
  #--------------------------------------------------------------------------
  # ● 动作速度的決定 复数回合行动用
  #--------------------------------------------------------------------------
  def make_action_speed2(adj)
    @adj_speed = self.action.speed if @adj_speed == nil
    @adj_speed = @adj_speed * adj / 100
  end
  #--------------------------------------------------------------------------
  # ● 击倒的实行 ※再定义
  #--------------------------------------------------------------------------
  def perform_collapse
    @force_action = ["N01collapse"] if $game_temp.in_battle and dead?
  end
  #--------------------------------------------------------------------------
  # ● 获取初期配置
  #--------------------------------------------------------------------------
  def base_position
    return if self.index == nil
    # 确认角色画像的大小修正Y坐标
    bitmap = Bitmap.new("Graphics/Battlers/" + @battler_name) if !self.anime_on
    bitmap = Bitmap.new("Graphics/Characters/" + @battler_name) if self.anime_on && N01::WALK_ANIME
    bitmap = Bitmap.new("Graphics/Characters/" + @battler_name + "_1") if self.anime_on && !N01::WALK_ANIME
    height = bitmap.height
    @base_position_x = self.screen_x + self.position_plus[0]
    @base_position_y = self.screen_y + self.position_plus[1] - height / 3
    bitmap.dispose
    # 背后攻击时X轴逆转
    if $back_attack && N01::BACK_ATTACK
      @base_position_x = Graphics.width - self.screen_x - self.position_plus[0]
    end
  end
  #--------------------------------------------------------------------------
  # ● 战斗画面 X 坐标的取得
  #--------------------------------------------------------------------------
  def position_x
    return @base_position_x - @move_x
  end
  #--------------------------------------------------------------------------
  # ● 战斗画面 Y 坐标的取得
  #--------------------------------------------------------------------------
  def position_y
    return @base_position_y + @move_y + @jump
  end
  #--------------------------------------------------------------------------
  # ● 战斗画面 Z 坐标的取得
  #--------------------------------------------------------------------------
  def position_z
    return position_y + @move_z - @jump + 200
  end
end
#==============================================================================
# ■ Sprite_Damage
#------------------------------------------------------------------------------
# 　伤害表示的精灵。
#==============================================================================
class Sprite_Damage < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :battler
  #--------------------------------------------------------------------------
  # ● 客观初期化
  #--------------------------------------------------------------------------
  def initialize(viewport,battler = nil)
    super(viewport)
    @battler = battler
    @damage = 0
    @duration = 0
    @x = 0
    @y = 0
    @z_plus = 0
    @minus = false
    @num1 = Sprite.new(viewport)
    @num2 = Sprite.new(viewport)
    @num3 = Sprite.new(viewport)
    @num4 = Sprite.new(viewport)
    @num5 = Sprite.new(viewport)
    @num1.visible = false
    @num2.visible = false
    @num3.visible = false
    @num4.visible = false
    @num5.visible = false
  end
  #--------------------------------------------------------------------------
  # ● 更新
  #--------------------------------------------------------------------------
  def update
    force_damage
    move_damage(@num5, @pop_time) if @num5.visible
    move_damage(@num4, @pop_time - 2) if @num4.visible
    move_damage(@num3, @pop_time - 4) if @num3.visible
    move_damage(@num2, @pop_time - 6) if @num2.visible
    move_damage(@num1, @pop_time - 8) if @num1.visible
    move_window if @window != nil
    @duration -= 1 if @duration > 0
  end
  #--------------------------------------------------------------------------
  # ● 事件的伤害POP
  #--------------------------------------------------------------------------
  def force_damage
    if @battler.force_damage != 0
      damage_pop(@battler.force_damage)
      @battler.hp -= @battler.force_damage
      @force_damage = true
      @battler.force_damage = 0
      $game_temp.status_window_refresh = true
    end
  end
  #--------------------------------------------------------------------------
  # ● 数値的移动
  #--------------------------------------------------------------------------
  def move_damage(num, min)
    case @duration
    when min-1..min
      num.y -= 4
    when min-3..min-2
      num.y -= 3
    when min-6..min-4
      num.y -= 2
    when min-14..min-7
      num.y += 2
    when min-17..min-15
      num.y -= 2
    when min-23..min-18
      num.y += 1
    when min-27..min-24
      num.y -= 1
    when min-30..min-28
      num.y += 1
    when min-33..min-31
      num.y -= 1
    when min-36..min-34
      num.y += 1
    end
    next_damage if @battler.double_damage && @duration == min-34
    num.opacity = 256 - (12 - @duration) * 32
    num.visible = false if @duration == 0
    if @force_damage && @duration == 0
      @force_damage = false
      @battler.perform_collapse
    end
  end
  #--------------------------------------------------------------------------
  # ● 文字窗口的移动
  #--------------------------------------------------------------------------
  def move_window
    @window.x -= 6 if @window_time > 0 && @window.x > 0
    @window_time -= 1
    if @duration == 0
      @window.dispose
      @window = nil
    end
  end  
  #--------------------------------------------------------------------------
  # ● HPMP两方同时伤害
  #--------------------------------------------------------------------------
  def next_damage
    @battler.hp_damage = 0
    @battler.double_damage = false
    damage_pop
  end
  #--------------------------------------------------------------------------
  # ● 准备伤害POP
  #--------------------------------------------------------------------------
  def damage_pop(num = nil)
    reset
    damage = battler.hp_damage
    # 抽出状态的变化
    states = battler.added_states
    text = ""
    # MP伤害用文本(HPMP两方同时伤害除外)
    if [email protected]_damage && @battler.mp_damage != 0
      text = N01::POP_MP_DAM if battler.mp_damage > 0
      text = N01::POP_MP_REC if battler.mp_damage < 0
      damage = battler.mp_damage
    end
    # 连续伤害不显示MP伤害以外的文字
    if num == nil
      text = N01::POP_MISS if battler.missed && states == []
      text = N01::POP_DAMAGE0 if damage == 0 && states == [] && !battler.revival
      text = N01::POP_EVA if battler.evaded
      text = N01::POP_CRI if battler.critical
      for state in states
        # 无POP设定的状态不显示
        unless state.extension.include?("无POP")
          text += " " if text != ""
          text += state.name
        end
      end
    else
      damage = num
    end
    # 区分伤害和回复
    @minus = false
    @minus = true if damage < 0
    damage = damage.abs
    # 略微调整POP位置
    adjust = -16
    adjust = 16 if $back_attack
    adjust = 0 if damage == 0
    @x = battler.position_x + adjust
    @y = battler.position_y
    window(text) if text != ""
    @pop_time = N01::NUM_DURATION
    # 没有伤害时没有数字的POP
    return @duration = @pop_time if damage == 0
    @num_time = -1
    damage_file(@num1, damage % 10, @pop_time - 7) if damage >= 0
    damage_file(@num2, (damage % 100)/10, @pop_time - 5) if damage >= 10
    damage_file(@num3, (damage % 1000)/100, @pop_time - 3) if damage >= 100
    damage_file(@num4, (damage % 10000)/1000, @pop_time - 1) if damage >= 1000
    damage_file(@num5, (damage % 100000)/10000, @pop_time + 1) if damage >= 10000
  end  
  #--------------------------------------------------------------------------
  # ● 准备情报窗口
  #--------------------------------------------------------------------------
  def window(text)
    @window = Window_Damage.new(@x - 64, @y - 22)
    @window.pop_text(text)
    @window_time = 5
  end  
  #--------------------------------------------------------------------------
  # ● 准备数字画像
  #--------------------------------------------------------------------------
  def damage_file(num, cw, dur)
    num.visible = true
    # 判別文件
    file = N01::DAMAGE_GRAPHICS
    file = N01::RECOVER_GRAPHICS if @minus
    # 数字
    num.bitmap = Cache.system(file)
    @num_time += 1
    sx = num.bitmap.width / 10
    num.src_rect.set(cw * sx, 0, sx, num.height)
    num.x = @x - (num.width + N01::NUM_INTERBAL) * @num_time
    num.y = @y
    num.z = 2000 - @num_time
    @duration = dur
    @window.x = num.x - @window.width + 64 if @window != nil && N01::NON_DAMAGE_WINDOW
    @window.x = num.x - @window.width + 26 if @window != nil && !N01::NON_DAMAGE_WINDOW
    @window.x = 0 if @window != nil && @window.x < 0
  end
  #--------------------------------------------------------------------------
  # ● 伤害组合
  #--------------------------------------------------------------------------
  def reset
    @num5.visible = @num4.visible = @num3.visible = @num2.visible = @num1.visible = false
    @window.dispose if @window != nil
    @window = nil
  end  
  #--------------------------------------------------------------------------
  # ● 开放
  #--------------------------------------------------------------------------
  def dispose
    super
    @num1.dispose
    @num2.dispose
    @num3.dispose
    @num4.dispose
    @num5.dispose
    @window.dispose if @window != nil
  end  
end
#==============================================================================
# ■ Window_Damage
#------------------------------------------------------------------------------
# 　危机等表示的窗口。
#==============================================================================
class Window_Damage < Window_Base
  #--------------------------------------------------------------------------
  # ● 客观初期化
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 160, 46)
    self.opacity = 0 if N01::NON_DAMAGE_WINDOW
  end
  #--------------------------------------------------------------------------
  # ● 窗口内容的作成
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # ● 状态设定
  #--------------------------------------------------------------------------
  def pop_text(text, align = 1)
    self.contents.clear
    self.width = self.contents.text_size(text).width + 36
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.color = normal_color
    self.contents.font.size = 16
    self.contents.draw_text(0,-8, width - 32, 32, text, align)
  end  
end  
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　游戏中处理所有窗口的超级类。
#==============================================================================
class Window_Base < Window  
  #--------------------------------------------------------------------------
  # ● 状态的描画  ※再定义(反映设定不显示状态ICON)
  #--------------------------------------------------------------------------
  def draw_actor_state(actor, x, y, width = 96)
    count = 0
    for state in actor.states
      break if state.extension.include?("不显示ICON")
      draw_icon(state.icon_index, x + 24 * count, y)
      count += 1
      break if (24 * count > width - 24)
    end
  end
end
#==============================================================================
# ■ Game_Temp
#------------------------------------------------------------------------------
# 　不包含存储数据、处理一时数据的类。
#==============================================================================
class Game_Temp
  #--------------------------------------------------------------------------
  # ● 公开变数
  #--------------------------------------------------------------------------
  attr_accessor :status_window_refresh    # 状态窗口的还原标志
  #--------------------------------------------------------------------------
  # ● 客观初期化
  #--------------------------------------------------------------------------
  alias initialize_n01 initialize
  def initialize
    initialize_n01
    @status_window_refresh = false
  end
end  
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　实行时间指令的解释。
#==============================================================================
class Game_Interpreter
  #--------------------------------------------------------------------------
  # ● HP 的增减
  #--------------------------------------------------------------------------
  def command_311
    if $game_temp.in_battle
      value = operate_value(@params[1], @params[2], @params[3])
      iterate_actor_id(@params[0]) do |actor|
        next if actor.dead?
        if @params[4] == false and actor.hp + value <= 0
          actor.damage_num(actor.hp - 1) # 如果不允许战斗不能时变为1
        else
          actor.damage_num(-value)
        end
      end
      return true
    else
      value = operate_value(@params[1], @params[2], @params[3])
      iterate_actor_id(@params[0]) do |actor|
        next if actor.dead?
        if @params[4] == false and actor.hp + value <= 0
          actor.hp = 1    # 如果不允许战斗不能时变为1
        else
          actor.hp += value
        end
        actor.perform_collapse
      end
      if $game_party.all_dead?
        $game_temp.next_scene = "gameover"
      end
      return true
    end  
  end
  #--------------------------------------------------------------------------
  # ● 敌角色的 HP 增减
  #--------------------------------------------------------------------------
  def command_331
    value = operate_value(@params[1], @params[2], @params[3])
    iterate_enemy_index(@params[0]) do |enemy|
      if enemy.hp > 0
        if @params[4] == false and enemy.hp + value <= 0
          enemy.damage_num(enemy.hp - 1) # 如果不允许战斗不能时变为1
        else
          enemy.damage_num(-value)
        end
      end
    end
    return true
  end
end  




将以上三个脚本按顺序插到                ▼ 外来RGSS插件脚本素材      的后边

点评

asd1010110
好强大的脚本  发表于 2012-1-18 10:30
这里什么都没有
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册会员

本版积分规则

拿上你的纸笔，建造一个属于你的梦想世界，加入吧。
 注册会员
找回密码

站长信箱：[email protected]|手机版|小黑屋|无图版|Project1游戏制作

GMT+8, 2024-12-28 20:13

Powered by Discuz! X3.1

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表