| 赞 | 0 |
| VIP | |
| 好人卡 | |
| 积分 | 1 |
| 经验 | |
| 最后登录 | 2014-2-3 |
| 在线时间 | 91 小时 |
- 梦石
- 0
- 星屑
- 50
- 在线时间
- 91 小时
- 注册时间
- 2012-3-3
- 回帖
- 56
|
加入我们,或者,欢迎回来。
您需要 登录 才可以下载或查看,没有账号?注册会员
×
本帖最后由 Mr丶木头 于 2014-1-23 22:21 编辑
话说花了三天时间来翻译这个脚本呢,开始本来时准备自用,后来翻译着翻译着眼看就快翻译完了- -|(木头君有很强烈的强迫症{:2_270:} )
所以干脆翻译完来方便大家创建自己的华丽丽的战斗系统吧!
模板来自@hcm 君的
【RMVA全动画脚本】Sideview横版战斗系统改编版(2013.1.17更新)
感谢@破晓记录线 发现的问题
2014年1月23日
已重新发布范例包,如已使用该脚本的玩家只需将脚本动画设定部分844行的“弓”改成“展示弓”即可。范例包还在character目录下加入了bow和arrow的动画图片。
新的范例包请自行提取RGSS300。
SideView mt汉化版.zip
(898.92 KB, 下载次数: 274)
SideView动画设置部分
- =begin
- #==============================================================================
- 译者注:这是使用了hcm君提供的全动态SideView脚本作为翻译的模板。
- [url=http://rpg.blue/thread-236237-1-1.html]http://rpg.blue/thread-236237-1-1.html[/url]
-
- 其实mt君不懂日文呢,用了林格斯翻译家后麻麻再也不用担心我的翻译了!
- 好多不懂的地方也是实践后用自己的话表达出来的。翻译错误肯定是有的,
- 但是大概意思不会错。
- 那么关于所有SideView的动画设定都在此页了,使用前请详细阅读该脚本的设置页。
- 使用时请注意将该范例下Graphics文件夹下的图像素材拷贝到你的游戏中哦。
- 拷贝时可以不复制数据库内的113-116号动画,因为你需要开始自己设计动画了哦。
- 已知BUG: 在选择单体技能后,选择目标敌人时技能已经开始吟唱了??
- ps.话说SideView的脚本自定义功能真的很强大呢
- 2014年1月17日由mt君译。
- #==============================================================================
- =end
- #==============================================================================
- # ■ SideView动画設定 v100
- #------------------------------------------------------------------------------
- # 横版战斗全部的动画设定
- #==============================================================================
- module N03
- #--------------------------------------------------------------------------
- # ● 全局设置
- #--------------------------------------------------------------------------
-
- #位置统一修正
- XADJ = -40
- YADJ = -20
-
- # 角色初期位置(H:角色的高度(位于空中))
- ACTOR_POSITION=[
- # X轴 Y轴 H轴
- [ 415+XADJ, 165+YADJ, 0], #1号位置
- [ 415+XADJ, 195+YADJ, 0], #2号位置
- [ 475+XADJ, 215+YADJ, 0], #3号位置
- [ 475+XADJ, 195+YADJ, 0] #4号位置
-
- ]
-
- # 战斗中行动结束后、到下个角色行动开始之间的等待时间。
- ACTION_END_WAIT = 8
-
- # 回合结束时的等待时间
- TURN_END_WAIT = 12
-
- # 被偷袭时背对敌人。允许true 不允许false
- BACK_ATTACK = true
-
- # 是否允许我方受伤时采用默认的效果。
- ACTOR_DAMAGE = false
-
- # 是否允许地方受伤时采用默认的效果。
- ENEMY_DAMAGE = false
-
- # 敌人图像,动作,动画是否翻转显示。
- ENEMY_MIRROR = true
-
- # 不死的状态ID
- IMMORTAL_ID = 10
-
- # 战斗日志开关 打开true
- BATTLE_LOG = true
-
- # 以下技能不使用特效。
- NO_DISPLAY_SKILL_ID = [1,2,3,4,5,6,7]
-
- # 伤害数字显示开关 打开true
- DAMAGE_POP = true
-
- # 状态付加显示开关 打开true
- STATE_POP = true
-
- # 伤害数字图像文件名(放在System下)
- DAMAGE_PLUS = "damage_num+"
- # 恢复数字图像文件名(放在System下)
- DAMAGE_MINUS = "damage_num-"
- # MP伤害数字图像文件名(放在System下)
- DAMAGE_MP = "damage_mp"
- # TP伤害数字图像文件名(放在System下)
- DAMAGE_TP = "damage_tp"
- # 伤害数字文字间距调整
- DAMAGE_ADJUST = -4
-
- # 战斗前镜头位置调整 [X轴, Y轴]
- CAMERA_POSITION = [ 0, -40]
-
- #--------------------------------------------------------------------------
- # ● 战斗背景环境 背景放大倍率和坐标的调整
- #--------------------------------------------------------------------------
- # 地面文件名…设定地面(Battlebacks1)图像文件名。
- # "全Battlebacks1"指定统一的Battlebacks1设定
- # 背景文件名…设定背景(Battlebacks2)图像文件名。
- # "全Battlebacks2"指定统一的Battlebacks2设定
- # 坐标调整…[X轴, Y轴]
- # 放大率……[横放大率, 纵放大率]
- # 允许晃动……如果允许晃动画面true 否则false
- # 开关ー…战斗开始时自动打开该开关。如果设置为负数则使用SideView专用开关。
- # 在特定的场合下ON可以管理一套战斗方案和背景。
- # 如果不想这么做 0
-
- FLOOR1_DATA = {
- #――地面文件名――― 坐标調整 放大率 允许晃动 开关
- "Sea_ex01" => [ [ 0, 0], [ 75, 75], false, 0],
- "全Battlebacks1" => [ [ 0, 0], [ 100, 100], true, 0],
-
- }
- FLOOR2_DATA = {
- #――背景文件名――― 坐标調整 放大率 允许晃动 开关
- "Ship_ex" => [ [ 0, 120], [ 150, 150], true, 0],
- "全Battlebacks2" => [ [ 0, 120], [ 150, 150], true, 0],
-
- }
-
- #==============================================================================
- # ■ 动画
- #------------------------------------------------------------------------------
- # 这里设置战斗中基础动作。用来组合动画
- #==============================================================================
- # 这里是一个动画检索表
- ACTION = {
-
- #--------------------------------------------------------------------------
- # ● 动画设置
- #--------------------------------------------------------------------------
- # 默认可以多个角色放置在一个图像文件中。
- # 如果你想使用单个角色文件,请制作适合人物动作的图片放置其中。
- # 一人用一个图像文件(在文件头部有个$号)情况下也没有问题
-
- # 文件名后缀…要使用的角色图像文件名后面加上后缀。
- # 角色文件名+后缀作为图像完整的文件名
- # 例)Actor1角色添加"_1"为Actor1_1
- # 如果你只想使用一个角色文件请设置为空""
- # 角色的图像文件放在Characters下,敌人的图像文件放在Battlers下
- #
- # 纵行…图像纵位置。一般是0-3代表第1~4行。不过没有数量上的限制
- # 不要超过图像设定的行数
- # 横行…图像横位置、动画开始的位置。左从0~3开始。
- # 单元格的动画会从这个数字的位置到右边。
- # 模式… 0:固定 1:单向 2:往復 3:单向循环 4:往復循环
- # 速度…动画播放速度。数字越大越快
- # Z轴…动画叠放次序。数字越大越靠前
- # 循环…动画播放到最后会从头播放 允许true
- # 影…是否允许显示一个图像阴影 如果允许true 否则false
- # 武器…显示武器。如果不想留空""
- # 武器动画允许叠加
-
- #―动作名(待机系)― 判别 后缀 纵行 横行 模式 速度 Z轴 循环 影 武器
- "待机" => ["motion", "", 1, 0, 4, 12, 0, true, true, "待机武器" ],
- "待机(固定)WT" => ["motion", "", 1, 0, 0, 12, 0, true, true, "" ],
- "敌待机(固定)WT" => ["motion", "", 0, 0, 0, 12, 0, true, true, "" ],
- "待机(固定)" => ["motion", "", 1, 2, 0, 12, 0,false, true, "" ],
- "死亡" => ["motion", "_1", 1, 1, 0, 12, 0, true,false, "" ],
- "魔法" => ["motion", "_1", 1, 0, 3, 12, 0, true,false, "" ],
- "特技" => ["motion", "_1", 2, 0, 3, 12, 0, true,false, "" ],
- "面向右边待机" => ["motion", "", 3, 0, 4, 12, 0, true, true, "待机武器M" ],
- "胜利动作" => ["motion", "", 0, 0, 1, 6, 0, true, true, "" ],
-
- #―动作名(移动系)― 判别 后缀 纵行 横行 模式 速度 Z轴 循环 影 武器
- "左移动画" => ["motion", "", 1, 0, 4, 6, 100, true, true, "待机武器" ],
- "右移动画" => ["motion", "", 2, 0, 4, 6, 100, true, true, "待机武器M" ],
-
- #―动作名(攻击系)― 判别 纵行 横行 模式 速度 Z轴 循环 影 武器
- "展示武器" => ["motion", "", 0, 0, 1, 2, 200,false, true, "纵摇摆"],
- "展示盾牌" => ["motion", "", 0, 0, 1, 2, 200,false, true, "纵摇摆L"],
- "展示盾牌和武器" => ["motion", "", 0, 0, 1, 2, 200,false, true, "纵摇摆","纵摇摆L"],
- "盾防御" => ["motion", "", 1, 0, 1, 2, 200,false, true, "盾"],
- "武器拳套" => ["motion", "", 1, 0, 1, 2, 200,false, true, "拳戳刺" ],
- "用武器横戳" => ["motion", "", 1, 0, 1, 2, 200,false, true, "戳刺" ],
- "举起武器" => ["motion", "", 1, 0, 1, 2, 200,false, true, "举起" ],
- "展示弓" => ["motion", "", 1, 0, 1, 2, 200,false, true, "弓"],
-
- #--------------------------------------------------------------------------
- # ● 角色移动 敌人将做反向的移动
- #--------------------------------------------------------------------------
- # 目標…设置目标坐标的参照物。正数参照现在的位置,负数参照初期位置,如果你不想设置输入-7
- # [0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标] [6=画面]
- # X轴…对象的X坐标
- # Y轴…对象的Y坐标
- # H轴…对象的H坐标(距离地面的高度) nil为只有XY方向移动
- # 速度…每帧移动的像素数。负数指定时间,得到帧的总数量。
- # 曲线…移动时的曲线轨道、负数则弯曲向下。
- # 跳跃…抛物线轨道。[从开始到顶点, 从顶点下落]
- # 动画…移动时播放的动画名。
-
- #――动作名(系统系)―― 判别 目標 X轴 Y轴 H轴 速度 曲线 跳跃 动画
- "战斗前我方配置" => ["move",-7, 180, 0, 0, 0, 0, [ 0, 0], "待机"],
- "退场" => ["move",-7, 180, 0, 0, 7, 0, [ 0, 0], "右移动画"],
- "逃跑途中" => ["move",-7, 80, 0, 0, 7, 0, [ 0, 0], "右移动画"],
- "输入命令移动" => ["move",-7, -20, 0, nil,-10, 0, [ 0, 0], "待机"],
- "受到伤害时后退" => ["move", 0, 20, 0, nil,-10, 0, [ 0, 0], ""],
- "受到暴击时后退" => ["move", 0, 60, 0, nil,-10, 0, [ 0, 0], ""],
-
- #――动作名(复位系)―― 判别 目標 X轴 Y轴 H轴 速度 曲线 跳跃 动画
- "坐标复位早" => ["move",-7, 0, 0, 0,-10, 0, [ 0, 0], "右移动画"],
- "坐标复位" => ["move",-7, 0, 0, 0,-20, 0, [ 0, 0], "右移动画"],
- "坐标复位曲线" => ["move",-7, 0, 0, 0,-20, -2, [ 0, 0], "右移动画"],
- "坐标复位面向左" => ["move",-7, 0, 0, 0,-20, 0, [ 0, 0], "待机"],
-
- #――动作名(自身系)―― 判别 目標 X轴 Y轴 H轴 速度 曲线 跳跃 动画
- "前移一步" => ["move", 0, -20, 0, 0,-10, 0, [ 0, 0], "左移动画"],
- "后退一步" => ["move", 0, 20, 0, 0,-10, 0, [ 0, 0], "左移动画"],
- "前跳一步" => ["move", 0, -30, 0, 0,-10, 0, [ 20,-20], "左移动画"],
- "后跳一步" => ["move", 0, 30, 0, 0,-10, 0, [ 20,-20], "左移动画"],
- "胜利动作" => ["move", 0, 10, 0, 0,-25, 0, [ 30,-30], "待机(固定)"],
- "胜利跳跃武器" => ["move", 0, 0, 0, 0,-15, 0, [ 20, 0], "举起武器"],
- "胜利跳跃着地" => ["move",-7, 0, 0, 0,-10, 0, [ 0, 0], "展示武器"],
- "飞起" => ["move", 0, 0, 0, 20, -2, 0, [ 0, 0], ""],
- "降落" => ["move", 0, 0, 0, -20, -2, 0, [ 0, 0], ""],
-
- #――动作名(目標系)―― 判别 目標 X轴 Y轴 H轴 速度 曲线 跳跃 动画
- "移动到目标面前" => ["move", 1, 30, 0, 0,-20, 0, [ 0, 0], "左移动画"],
- "移动到目标后方" => ["move", 1, -60, 0, 0,-20, 0, [ 0, 0], "左移动画"],
- "移动到目标身上" => ["move", 1, 0, 0, 0,-10, 0, [ 0, 0], "左移动画"],
- "跳到目标头上" => ["move",-1, 0, 0, 100,-20, 0, [ 40,-20], "举起武器"],
- "移动到敌人身上并展示武器"=> ["move",-1, 0, 0, 0,-10, 0, [ 0, 0], "展示武器"],
-
- #--------------------------------------------------------------------------
- # ● 武器动画
- #--------------------------------------------------------------------------
- # 类型…[0…使用图标Icons]
- # [1…独自图像(图像名使用默认的武器设定名。位于Characters文件夹下)]
- # [2…动画元素(仿RM2003。像角色行走图一样的动画图像。图像名使用默认的武器设定名。位于Characters文件夹下)]
- # 移动…图像移动距离。[X轴, Y轴]
- # 調整…微整武器坐标。[X轴, Y轴]
- # 始度…动作前开始角度。顺指针0~360度。負逆时针
- # 終度…动作后角度
- # 原点…图像原点。[0…中心] [1…左上] [2…右上] [3…左下] [4…右下] [5…与角色相同]
- # 翻转…设置为true水平翻转表示图像
- # 放大…[X轴放大率, Y轴放大率] 允许使用浮点数。
- # Z轴…图像是否显示在手的前方,如果是true
- # 逆手…是否显示右手武器的图像(盾牌或者二刀流)
- # 更新…-1与角色动画同时更新。如果你想独立更新 [更新时间间隔, 更新格子数, 是否循环]
- #
- # 后缀…虽然你已经设定了武器(副武器)的图像。
- # 如果你设置了后缀,那么新的文件名将加上后缀。
- # 例) "纵摇摆"加后缀"" => 图像文件名"IconSet"
- # 例) "纵摇摆2"加后缀"_1" => 图像文件名"IconSet_1"
- # 如果你使用图标文件,在System下,独立动画在Characters下
- #
- # 图像…如果你想直接指定武器名在这里输入,会忽略头部的图标设定。
- # 图像放在Characters文件夹下。
-
- #―动作名― 判别 类型 移动 調整 始度 終度 原点 翻转 放大 Z轴 逆手 更新 后缀 图像
- "纵摇摆" => ["wp", 0,[ 6, 0],[ -4,-10], -45, 45, 4, false, [1,1], false, false, -1, "", ""],
- "待机武器" => ["wp", 0,[ 6,-4],[ -4, -8], 10, 10, 4, false, [1,1], false, false, -1, "", ""],
- "待机武器M" => ["wp", 0,[ 6,-4],[ -8,-12], 30, 30, 4, true, [1,1], true, false, -1, "", ""],
- "盾" => ["wp", 0,[ 0, 0],[ 12, 0], 0, 0, 4, false, [1,1], true, true, -1, "", ""],
- "纵摇摆L" => ["wp", 0,[ 6, 0],[ 0, -8],-135, 45, 4, false, [1,1], true, true, -1, "", ""],
- "拳戳刺" => ["wp", 0,[-20, 0],[ 5, 5], -45, -45, 4, false, [1,1], false, false, -1, "", ""],
- "戳刺" => ["wp", 0,[-25, 0],[ 25,-10], 45, 45, 4, false, [1,1], false, false, -1, "", ""],
- "举起" => ["wp", 0,[ 6,-4],[ -4,-10], 90, -45, 4, false, [1,1], false, false, -1, "", ""],
-
- #―2003仕様― 判别 タイプ 移动 調整 始度 終度 原点 翻转 放大 Z轴 逆手 更新 インデックス 图像
- "弓" => ["wp", 0,[ 1, 0],[ -1, 0], 50, 45, 5, false, [1,1], true, false, -1, "", ""],
-
- # 飞行类武器 判别 タイプ 移动 調整 始度 終度 原点 翻转 放大 Z轴 二刀 更新 インデックス 图像
- "箭支" => ["wp", 0,[ 0, 0],[ 0, 0], 0, 45, 0, false, [1,1], true, false,[2,6,false], "", "arrow01"],
- "旋转" => ["wp", 0,[ 0, 0],[ 0, 0], 0, 360, 0, false, [1,1], true, false,[1,8, true], "", ""],
-
- #--------------------------------------------------------------------------
- # ● 武器飞行动画 让子弹飞
- #--------------------------------------------------------------------------
- # ID…数据库的动画ID。0动画不表示。[移动过程动画ID, 命中的动画ID]
- # 始…动画移动开始位置。如果你输入负数,则在多个目标上只播放一个动画。
- # [0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标] [6=画面]
- # 后…动画移动结束位置。如果你输入负数,则在多个目标上只播放一个动画。
- # [0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标] [6=画面]
- # 始調整…移动开始坐标调整。[X轴, Y轴] 敌人进行负向计算
- # 后調整…移动结束坐标调整。[X轴, Y轴]
- # 速度…在X轴上每帧移动的像素数。如果你设置负数,打击速度将根据距离改变 ???
- # 类型…移动后处理方法。[0=消失] [1=贯穿] [2=消失??]
- # 軌道…移动軌道。[从开始到顶点, 从顶点到结束]
- # Z轴…是否允许武器覆盖角色
- # 等待…动画结束是否等待动作true [移动过程动画等待, 命中时动画等待]
- # 伤害…运动到目标时计算伤害
- # 归位…运动完是否归位(回旋镖)
- # 镜头…是否允许镜头缩放
- # 循环…是否允许循环
- # 翻转不可…在任何情况下动画不翻转设置为true
- # 武器…武器动作名。利用否则""
-
- #――动作名―― 判别 ID 始 后 始調整 后調整 速度 类型 軌道 Z轴 循环 伤害 归位 镜头 循环 翻转不可 武器
- "箭支发射WT" => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 20, 0, [ 0, 0], true, [ true, true], true, true, true, false, false, "箭支"],
- "箭支发射" => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 20, 0, [ 0, 0], true, [false,false], true, true, true, false, false, "箭支"],
- "水鉄砲发射" => ["m_a",[69,69], 0, 1, [ 0, 0], [ 0, 0], 10, 0, [ 0, 0], true, [ true, true], true, true, true, true, false, ""],
- "武器投掷开始" => ["m_a",[ 0,-1], 0, 1, [ 4,-6], [ 0, 0], 10, 2, [-3,-3], true, [ true,false], true, true, true, false, false, "旋转"],
- "武器投掷戻し" => ["m_a",[ 0, 0], 1, 0, [ 0, 0], [ 4,-6], 10, 0, [ 3, 3], true, [ true,false], false, true, true, false, false, "旋转"],
-
- #--------------------------------------------------------------------------
- # ● 战斗动画
- #--------------------------------------------------------------------------
- # ID…数据库动画ID。-1主武器动画 -2副武器动画
- # -3技能设置的动画
- # 对象…[0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标]
-
- #―动作名(伤害系)― 判别 ID 对象 归位 循环 伤害 镜头 翻转不可 翻转 Z轴
- "对象动画武器" => ["anime", -1, 1, false, false, true, true, false, false, true],
- "对象动画武器WT" => ["anime", -1, 1, false, true, true, true, false, false, true],
- "对象动画武器LWT" => ["anime", -2, 1, false, true, true, true, false, false, true],
- "对象动画" => ["anime", -3, 1, false, false, true, true, false, false, true],
- "对象动画WT" => ["anime", -3, 1, false, true, true, true, false, false, true],
-
- #――动作名(自身系)――
- "魔法咏唱中" => ["anime", 113, 0, true, true, false, true, false, false, true],
- "特技待机中" => ["anime", 114, 0, true, true, false, true, false, false, true],
- "魔法发动动画" => ["anime", 115, 0, false, true, false, true, false, false, false],
- "特技发动动画" => ["anime", 116, 0, false, true, false, true, false, false, false],
-
- #--------------------------------------------------------------------------
- # ● 镜头动画
- #--------------------------------------------------------------------------
- # 对象…移动和缩放的对象
- # [0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标] [6=画面]
- # 調整坐标…镜头坐标的调整 [X轴(正方向画面→), Y轴(正方向画面↓)]
- # 时间…镜头动作的时间
- # 放大…镜头的放大率(%)。100原大小。
- # 等待…是否等待镜头移动完成。如果是true。
-
- #――动作名―― 判别 对象 調整坐标 放大率 时间 等待
- "镜头复位" => ["camera", 6, [ 0, 0], 100, 40, false],
- "放大" => ["camera", 6, [ 0, 100], 120, 40, false],
- "缩小" => ["camera", 6, [ 0, 0], 80, 40, false],
-
- #--------------------------------------------------------------------------
- # ● 画面晃动 空中(H坐标大于0)的角色不会晃动
- #--------------------------------------------------------------------------
- # 方向…晃动的方向 [横,纵] 数值越大幅度越大
- # 速度…摇晃的速度。
- # 时间…摇晃的时间。摆动幅度会随着时间推移而减小
- # 等待…是否等待镜头移动完成。如果是true。
-
- #――动作名―― 判别 方向 速度 时间 等待
- "晃动小" => ["shake", [ 0, 4], 2, 16, false],
- "晃动中" => ["shake", [ 0, 6], 3, 30, false],
- "晃动大" => ["shake", [ 0,12], 3, 40, false],
-
- #--------------------------------------------------------------------------
- # ● 画面色调改变 改变背景和角色的色调
- #--------------------------------------------------------------------------
- # 对象…色调改变对象
- # [0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标]
- # [6=背景] [7=自分+目标] [8=自分以外] [9=自分+目标以外] [10=所有]
- # 色调…[ R, G, B, 强度, 时间, 返回]
- # 返回…变更完成返回原来色调的时间。如果不则设置为0
- # 等待…是否等待镜头移动完成。如果是true。
-
- # 改变名 判别 对象 R, G, B, 强度 时间 返回 等待
- "色调初始化" => ["color", 10, [ 0, 0, 0, 0, 30, 0], false],
- "虚弱色调" => ["color", 0, [ 255, 50, 50, 100, 40, 40], false],
- "毒色调" => ["color", 0, [ 170, 50, 255, 170, 30, 30], false],
- "泛用异常状态色调" => ["color", 0, [ 255, 255, 50, 170, 40, 40], false],
- "昏暗背景" => ["color", 6, [ 0, 0, 0, 255, 30, 0], false],
- "自身和目标以外暗淡" => ["color", 9, [ 0, 0, 0, 255, 30, 0], false],
-
- #--------------------------------------------------------------------------
- # ● 过渡 更变画面使用的过渡
- #--------------------------------------------------------------------------
- # 执行"画面固定"操作运行之前请保持画面静止。
- #
- # 边界…边界的模糊值。越大越模糊。
- # 时间…画面转变的时间。游戏画面在过渡时是静止的。
- # 过渡文件名…。文件位于Pictures下。
-
- #―――动作名――― 判别 边界 时间 文件名
- "圈圈过渡" => ["ts", 40, 60, "circle"],
-
- #--------------------------------------------------------------------------
- # ● 幻影
- #--------------------------------------------------------------------------
- # 数…幻影数。0用来关闭幻影。幻影越多程序负载越大
- # 间隔…幻影间隔。单位帧。
- # 处理…对幻影的处理。true为消失、false不消失
- # 透明度…幻影透明度
-
- #――动作名―― 判别 数 间隔 处理 透明度
- "幻影ON" => ["mirage", 4, 3, true, 160],
- "幻影OFF" => ["mirage", 0, 0, true, 0],
-
- #--------------------------------------------------------------------------
- # ● 角色旋转 图像旋转
- #--------------------------------------------------------------------------
- # 角色被旋转完成后角度会复位。
- # 旋转中心是图像几何中心。武器动作不会播放。
- #
- # 时间…旋转时间。0会立即处理
- # 始度…旋转开始时角度。0~360度。正逆时针,敌人计算相反
- # 終度…旋转结束时角度。0~360度。
- # 类型…旋转结束后处理。[0…旋转复位] [1…定在结束角度] [2…循环]
-
- #――动作名―― 判别 时间 始 終 类型
- "右1旋转" => ["angle", 12, 0, -360, 0],
- "左1旋转" => ["angle", 12, 0, 360, 0],
-
- #--------------------------------------------------------------------------
- # ● 角色放大縮小 图像放大縮小
- #--------------------------------------------------------------------------
-
- # 角色被缩放完成后大小会复位。
- # 武器动作不会播放。
- # 时间…放大縮小时间。
- # 开始大小…放大縮小开始时的大小。允许小数点。[X轴(横), Y轴(纵)]
- # 结束大小…放大縮小结束时的大小。[X轴(横), Y轴(纵)]
- # 类型…放大縮小结束后处理。[0…还原大小] [1…保持大小] [2…循环]
-
- #――动作名―― 判别 时间 开始大小 结束大小 类型
- "横向缩放" => ["zoom", 12, [1.0, 1.0], [0.5, 1.0], 0],
- "纵向缩放" => ["zoom", 12, [1.0, 1.0], [1.0, 0.5], 0],
- #--------------------------------------------------------------------------
- # ● 角色透明度操作 图像透明度改变
- #--------------------------------------------------------------------------
- # 时间…透明度改变时间。
- # 开始…改变开始时不透明度。0透明、255不透明
- # 结束…改变结束时透明度
- # 影…是否存在影子
- # 武器…武器是否同时透明
- # 循环…透明度更变完成后是否允许反向操作。
- # 等待…是否等待透明度操作完成。
-
- #――动作名―― 判别 时间 开始 结束 影 武器 循环 等待
- "逃跑透明" => ["opacity", 30, 255, 0, true, true, false, false],
- "透明化" => ["opacity", 60, 255, 0, true, true, false, false],
- "透明化WT" => ["opacity", 60, 255, 0, true, true, false, true],
- "透明化解除" => ["opacity", 60, 0, 255, true, true, false, false],
- "透明化解除WT" => ["opacity", 60, 0, 255, true, true, false, true],
-
- #--------------------------------------------------------------------------
- # ● 气泡动画 源于事件中的气泡动画
- #--------------------------------------------------------------------------
- # 类型…气泡类型(纵位置)
- # 速度…更新速度。元素将从第二针开始播放
- # 大小…气泡大小
-
- # 气泡名 判别 类型 速度 サイズ
- "异常状态/泛用" => ["balloon", 6, 10, 1],
- "异常状态/虚弱" => ["balloon", 5, 10, 1],
- "异常状态/睡眠" => ["balloon", 9, 10, 1],
-
- #--------------------------------------------------------------------------
- # ● 图片显示
- #--------------------------------------------------------------------------
- # 番号…使用图片的编号。用于管理图片。可以显示任意数量的图片
- # 所有动画结束然后自动擦除(Bitmap解放)
- # 开始坐标…移动开始位置。图片的左上为原点。[X轴, Y轴]
- # 如果图片已经出现,留空[]将设置为默认的地方。
- # 结束坐标…移动结束位置。如果你只是显示图片,把它设定为和开始坐标一样。
- # 使用平面时设置开始坐标和结束坐标为空[]
- # 时间…移动时间。0用于擦除图片。
- # Z轴…图片的Z坐标。100以上则显示在角色上方
- # 透明度…透明度設定。[初始透明度, 每1帧增加的透明度]
- # 平面使用…平面类(图像被放置的像瓷砖)使用的矩形。[X轴,Y轴]
- # 如果不使用平面请留空[]
- # BA反転…被偷袭时是否逆向显示图片。
- # 使用平面时也一样。
- # 图片文件名…存放在pictures内的文件名。
-
- # 判别 番号 开始坐标 结束坐标 时间 Z轴 透明度 平面使用 BA翻转 文件名
- "插入A1" => ["pic", 0, [-300, 8], [ 100, 8], 30, 50, [ 0, 10], [], true, "示例图片_01"],
- "插入A2" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor4-2"],
- "插入A3" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor5-2"],
- "插入A4" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor5-3"],
- "插入終" => ["pic", 0, [], [ 600, 8], 30, 90, [255, 0], [], true, ""],
- "插入背景始" => ["pic", 1, [ 0, 8], [ 100, 8], 10, 80, [ 0, 10], [544,288], true, "cutin_back"],
- "插入背景終" => ["pic", 1, [], [], 10, 80, [255, -7], [544,288], true, ""],
- "白色淡入" => ["pic", 0, [ 0, 0], [ 0, 0], 50,500, [ 0, 6], [], false, "white"],
- "白色淡出" => ["pic", 0, [ 0, 0], [ 0, 0], 50,500, [255, -6], [], false, "white"],
-
- #--------------------------------------------------------------------------
- # ● 状态操作
- #--------------------------------------------------------------------------
- # 对象…[0=自分] [1=目标] [2=敌全] [3=我方全] [4=敌我方全] [5=第二目标]
- # 括展…对上面设置的对象进行拓展 [0=不] [1=随机1体] [2=自身除外]
- # 操作…状态附加"+" 解除"-"
- # ID…操作状态ID
-
- # 状态付与名 判别 对象 拡張 操作 ID
- "战斗不能付与" => ["sta", 0, 0, "+", [1]],
-
- #--------------------------------------------------------------------------
- # ● FPS(游戏整体的速率)改变
- #--------------------------------------------------------------------------
- # 游戏速率…60为默认值
-
- #――动作名―― 判别 速率
- "慢速" => ["fps", 15],
- "常速" => ["fps", 60],
-
- #--------------------------------------------------------------------------
- # ● 角色图像改变
- #--------------------------------------------------------------------------
- # 维持…战斗结束后是否继续保持更变后的状态。(永久改变)
- # 指数…设置变身后角色行走图的位置
- # [0][1][2][3]
- # [4][5][6][7]
- #
- # 文件名…行走图的文件名。位于Characters下
- # 敌人位于Battlers下
- # 脸部…如果要改变角色脸部头像 [头像位置,文件名]
- # 如果不改变留空[]
-
- #―――动作名――― 判别 维持 指数 文件 脸部
- "化妆成狼" => ["change", false, 6, "Animal", [0, "Actor4"]],
- #--------------------------------------------------------------------------
- # ● 技能派生
- #--------------------------------------------------------------------------
- # 习得…没有学习的技能是否允许被派生发动。
- # 发动条件…派生的技能是否需要发动条件。
- # 技能ID…派生的技能ID
-
- #―――动作名――― 判别 习得 条件 技能ID
- "多段攻击に派生" => ["der", true, false, 130],
- #--------------------------------------------------------------------------
- # ● 音效系统 BGM・BGS・SE
- #--------------------------------------------------------------------------
- # 类别…音效"se" 背景音乐"bgm" 背景音效"bgs"
- # 速率…50~150。
- # 音量…50~150。
- # 文件名…""BGM、BGS留空""则不改变任何数据。
-
- #――动作名―― 判别 类别 速率 音量 文件名
- "Bow1" => ["sound", "se", 100, 80, "Bow1"],
-
- #--------------------------------------------------------------------------
- # ● 电影播放 ogv文件
- #--------------------------------------------------------------------------
- # 文件名…要播放的文件名。在Movies文件夹下
-
- #――动作名―― 判别 文件名
- "死亡标志播放" => ["movie", "sample1"],
-
- #--------------------------------------------------------------------------
- # ● 开关操作
- #--------------------------------------------------------------------------
- # 开关如果被设置为负数将会只在SideView中进行操作。
- #
- # ON编号…放置在数列中的开关ID将被统一打开。
- # OFF编号
- #
- #――动作名―― 判别 ON编号 OFF编号
- "スイッチNo1/ON" => ["switch", [ 1], []],
- "进入太空背景改变"=> ["switch", [-4], []],
- "太空背景解除" => ["switch", [], [-4]],
- "魔方陣ON" => ["switch", [-5], []],
- "魔方陣OFF" => ["switch", [], [-5]],
-
- #--------------------------------------------------------------------------
- # ● 变量操作
- #--------------------------------------------------------------------------
- # 变量编号
- # 操作…[0=代入] [1=加法] [2=减法] [3=乘法] [4=除法] [5=求余]
- # 操作数…指定一个数字作为操作的目标。如果为负数,则该数字指向的变量为实际操作数。
- #
- # ――动作名―― 判别 変数No 操作 操作数
- "変数No1/+1" => ["variable", 1, 1, 1],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (游戏开关) 设置条件、动画的分歧
- #--------------------------------------------------------------------------
- # 开关编号…如果是负数则只操作SideView的开关。
- # 操作…ON-true、OFF-false
- # 分歧…满足条件时的处理。
- # [0=执行下列动作] [1=取消执行操作] [2=动作结束]
- #
- #―――动作名――― 判别 开关号 条件 分歧
- "スイッチNo1=ONで実行" => ["n_1", 1, true, 0],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (变量)
- #--------------------------------------------------------------------------
- # ID…变量的ID
- # 数值…需要对比的数字。如果是负数,将比较该数字变量存储的数字。
- # 条件…对比条件…[0=等于] [1=小] [2=大]
- # 分歧…当满足条件时。
- # [0=执行以下操作:] [1=取消以下操作:] [2=全部动作取消]
- #
- #―――动作名――― 判别 ID 数值 条件 分歧
- "変数No1=1で実行" => ["n_2", 1, 1, 0, 0],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (状态)
- #--------------------------------------------------------------------------
- # 对象…要参照的对象 [0=自身] [1=目标] [2=敌全体] [3=我方全体] [4=敌我方全体] [5=第二目标]
- # 状态ID…无论在任何状态下??
- # 条件…[0=获得状态] [1=未获得此状态]
- # 人数…在人数上需要满足的条件,0指全体
- # 分歧…满足条件时执行的操作。
- # [0=执行下列操作:] [1=不执行下列操作:] [2=全部动作结束]
- #
- #―――动作名――― 判别 对象 ID 条件 人数 分歧
- "死亡确认" => ["n_3", 1, 1, 0, 1, 1],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (技能)
- #--------------------------------------------------------------------------
- # 对象…要参照的对象 [0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=敌我方全体] [5=第二目标]
- # 技能ID
- # 条件…[0=可用] [1=不可用]
- # 人数…在人数上需要满足的条件,0指全体
- # 分歧…满足条件时执行的操作。
- # [0=执行下列操作:] [1=不执行下列操作:] [2=全部动作结束]
- #
- #―――动作名――― 判别 对象 ID 条件 人数 分歧
- "強撃使用可限定" => ["n_4", 0, 80, 0, 1, 0],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (参数)
- #--------------------------------------------------------------------------
- # 对象…要参照的对象 [0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=敌我方全体] [5=第二目标]
- # 种类…要比较参数的种类:
- # [1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP] [7=攻击力]
- # [8=防御力] [9=魔法力] [10=魔法防御] [11=敏捷性] [12=運]
- #
- # 数值…需要对比的条件。负数将使用最大值的百分比。(只限于HP MP TP)
- # 条件…比较数字的条件…[0=相同] [1=小于] [2=大于]
- # 人数…在人数上需要满足的条件,0指全体
- # 分歧…满足条件时执行的操作。
- # [0=执行下列操作:] [1=不执行下列操作:] [2=全部动作结束]
- #
- #―――动作名――― 判别 对象 种类 数值 条件 人数 分歧
- "HP50%以上で実行" => ["n_5", 0, 4, -50, 2, 1, 0],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (装备)
- #--------------------------------------------------------------------------
- # 对象… [0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=敌我方全体] [5=第二目标]
- # 类型…装备种类。 [0=武器] [1=防具]
- # 装备ID…上述类型物品的装备。要指定多个装备则放于数组中统一设置[]。
- # 如果指定为负数,则指该装备类型。
- # 条件…[0=已装备] [1=为装备]
- # 人数…在人数上需要满足的条件,0指全体
- # 分歧…满足条件时执行的操作。
- # [0=执行下列操作:] [1=不执行下列操作:] [2=全部动作结束]
- #
- #―――动作名――― 判别 对象 类型 ID 条件 人数 分歧
- "手斧限定" => ["n_6", 0, 0, [1], 0, 1, 0],
- "拳限定" => ["n_6", 0, 0, [-2], 0, 1, 0],
- "拳除外" => ["n_6", 0, 0, [-2], 0, 1, 1],
- "弓限定" => ["n_6", 0, 0, [-6], 0, 1, 0],
- "弓除外" => ["n_6", 0, 0, [-6], 0, 1, 1],
- "拳弓除外" => ["n_6", 0, 0,[-2,-6], 0, 1, 1],
-
- #--------------------------------------------------------------------------
- # ● 条件分歧 (脚本)
- #--------------------------------------------------------------------------
- # 分歧…满足条件时执行的操作。
- # [0=执行下列操作:] [1=不执行下列操作:] [2=全部动作结束]
- # 脚本…返回类型为布尔值(true,false)
- #
- #―――动作名――― 判别 分歧 脚本
- "50%的概率执行" => ["n_7", 0, "rand(100) < 50"],
- "角色限定" => ["n_7", 0, "@battler.actor?"],
- "角色ID1限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 1"],
- "角色ID2限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 2"],
- "角色ID6限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 6"],
- "角色ID7限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 7"],
- "敌人限定" => ["n_7", 0, "!@battler.actor?"],
- "敌人中止" => ["n_7", 2, "!@battler.actor?"],
- "二刀流限定" => ["n_7", 0, "@battler.dual_wield?"],
-
- #--------------------------------------------------------------------------
- # ● 第二个目标操作
- #--------------------------------------------------------------------------
- # 第二目标:独立于指定的普通目标以外的目标。
- # 如果你不想做任何事情,通常把它定为相同的目标。
- #
- # 对象…[0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=敌我方全体] [5=第二目标]
- #
- # INDEX…将限定目标方的引索值 INDEX = [指数, 判别]
- # 指数…目标方的数值
- # 判别…数值的条件 [0=不指定] [1=该指数为目标] [2=该指数以外]
- #
- # ID…目标角色(敌人)ID限定。0不限定
- # 如果指定为负数,则该目标除外。
- #
- # 状态…限定为拥有该状态的目标。0不限定
- # 如果设置为负数,限定为没有该状态的目标。
- #
- # 技能…限定为能使用该技能的目标。0不限定
- # 如果设置为负数,则限定为不能使用该技能的目标。
- #
- # 参数…限定参数的目标 参数 = [种类, 数值, 判别]
- # 种类…[0=不限定] [1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP]
- # [7=攻击力] [8=防御力] [9=魔法力] [10=魔法防御] [11=敏捷性] [12=运气]
- # 数值…比较的参数数值。负数将指定为百分比(HP・MP・TP限定)
- # 判别…数值的条件 [0=相同] [1=小于] [2=大于]
- #
- # 装备…限定装备与否的目标。 装备 = [类型, ID]
- # 类型…[0=武器] [1=防具]
- # ID…可以将装备ID放入数组中[]。0不限定
- # 如果指定为负数,则指装备类型。
- #
- # 拓展…拓展上述目标以外的目标 [0=不] [1=随机1体] [2=除了自己]
- # 操作…[0=不操作] [1=将第二目标更变为主目标] [2=初始化第二目标]
-
- #――动作名―― 判别 对象 INDEX ID 状态技能 参数 装备 拓展 操作
- "我方全员(除自身)" => ["s_t", 3, [ 0, 0], 0, 0, 0, [ 0, 0, 0], [ 0,[0]], 2, 0],
- "全体" => ["s_t", 4, [ 0, 0], 0, -1, 0, [ 0, 0, 0], [ 0,[0]], 0, 1],
-
- #--------------------------------------------------------------------------
- # ● 调用公共事件
- #--------------------------------------------------------------------------
- # ID…公共事件ID
- # 等待…是否等待公共事件运行完成
- #
- #―――动作名――― 判别 ID 等待
- "1号公共事件" => ["common", 1, true],
-
- #--------------------------------------------------------------------------
- # ● 脚本操作
- #--------------------------------------------------------------------------
- # 运行该脚本。
- #
- #―――动作名―――
- "测试脚本" => ["p = 1 "],
-
- #--------------------------------------------------------------------------
- # ● 其他 不允许设置的项目
- #--------------------------------------------------------------------------
- # 伤害动画…遵循之前的Pop伤害设置。
- # 翻转…图像的水平翻转。再次翻转则还原。
- # 武器消去…强制不显示武器图像。
- # 武器消去解除…解除强制不显示武器图像。
- # 敌消失…运行消失的效果。用它来显示敌人的战斗不能
- # 消失禁止…目标的HP减为0时不允许消失。一般用在连击技能发动前。
- # 消失禁止解除…解除消失禁止。连击技能发动结束时请调用它。
- # 待机取消…不执行待机动画。如战斗中发生事件。
- # 待机取消解除…解除待机取消。
- # 初期位置改变…将现在的坐标变为初期位置
- # 初期位置改变解除…初期位置改变原坐标
- # 强制…强制目标进行下一个动作
- # 强制2…强制目标进行下两个动作
- # 下一个行动者…当前角色行动立即结束,切换到下个行动者
- # 个人开始…多目标行为时个人的动作,他是开始标志。
- # 个人结束…个人动作结束标志
- # 循环开始…"循环开始"到"循环结束"之间的动画反复执行
- # 循环结束…
-
- #―――动作名――― 判别
- "伤害动画" => ["damage_anime"],
- "翻转" => ["mirror"],
- "武器消去" => ["weapon_off"],
- "武器消去解除" => ["weapon_on"],
- "敌消失" => ["normal_collapse"],
- "禁止消失" => ["no_collapse"],
- "允许消失" => ["collapse"],
- "待机取消" => ["non_motion"],
- "待机取消解除" => ["non_motion_cancel"],
- "初期位置改变" => ["change_base_position"],
- "初期位置改变解除" => ["set_base_position"],
- "强制" => ["force_action"],
- "强制2" => ["force_action2"],
- "下一个行动者" => ["next_battler"],
- "个人开始" => ["individual_start"],
- "个人结束" => ["individual_end"],
- "循环开始" => ["loop_start"],
- "循环结束" => ["loop_end"],
-
- #--------------------------------------------------------------------------
- # ● 等待时间
- #--------------------------------------------------------------------------
- # (例) "20" …等待20帧
- #
- # (例) "-20" …在0~20间随机等待
-
- #--------------------------------------------------------------------------
- # ● 快捷命令
- #--------------------------------------------------------------------------
- # 这些快捷命令可以让你减少工作强度
- # 所以对于经常使用的操作可以在这里设置。
- #
- # [战斗动画]
- # (例) "anime(20)" …播放数据库20号动画(有等待)
- # (例) "anime(20,false)" …播放数据库20号动画(无等待)
- # (例) "anime_me(20)" …对自身播放数据库20号动画(有等待)
- # (例) "anime_me(20,false)" …对自身播放数据库20号动画(有等待)
- #
- # [等待 延迟指数]
- # (例) "delay(12)"…指数1号等待0帧 2号等待12帧 3号等待24帧…
- #
- # [效果音(SE)]
- # (例) "se('Bow1')" …播放'Bow1'SE文件
- # (例) "se('Bow1',50)" …播放'Bow1'SE文件并且音量为50
- #
- # [强制执行动画(全部动作)]
- # (例) "target('受到伤害时后退')" …目标强制执行"受到伤害时后退"
- # (例) "target2('受伤')" …第二目标强制执行"受伤"
-
- }
- #==============================================================================
- # ■ 动画表
- #==============================================================================
- FULLACTION = {
-
- # ―――待机系―――
- "通常待机" => ["待机武器","待机"],
- "通常待机固定" => ["待机(固定)WT"],
- "虚弱待机" => ["异常状态/虚弱","虚弱色调","待机","待机"],
- "防御待机" => ["待机(固定)WT"],
- "毒待机" => ["异常状态/泛用","毒色调","待机","待机","敌人限定","80"],
- "睡眠待机" => ["异常状态/睡眠","敌人限定","40","敌人中止","死亡","死亡"],
- "泛用异常状态待机" => ["异常状态/泛用","泛用异常状态色调","待机","待机","敌人限定","80"],
- "等待" => ["待机","60"],
- "战斗不能" => ["死亡"],
-
- # ――システム系――
- "战斗开始我方" => ["战斗前我方配置","delay(4)","坐标复位面向左"],
- "我方退场" => ["退场"],
- "逃跑" => ["镜头复位","delay(4)","退场"],
- "敌逃跑" => ["对象动画","逃跑透明","退场"],
- "逃跑失败" => ["镜头复位","delay(4)","逃跑途中","后退一步","坐标复位面向左"],
- "输入命令" => ["输入命令移动"],
- "输入命令后" => ["坐标复位早"],
- "命令后防御" => ["坐标复位早","循环开始","待机(固定)WT","循环结束"],
- "命令后魔法" => ["坐标复位早","待机(固定)","循环开始","魔法咏唱中","循环结束"],
- "命令后特技" => ["坐标复位早","待机(固定)","循环开始","特技待机中","循环结束"],
- "防御" => ["对象动画","待机(固定)WT"],
- "回避" => ["角色限定","右1旋转","后跳一步","10","坐标复位面向左"],
- "盾躲避" => ["se('Evasion2')","盾防御","60"],
- "保护开始" => ["移动到目标身上","初期位置改变"],
- "保护结束" => ["初期位置改变解除","坐标复位面向左"],
- "被保护开始" => ["后退一步","后退一步","待机(固定)WT"],
- "被保护结束" => ["坐标复位面向左"],
- "胜利姿势摇摆" => ["胜利动作","120"],#"胜利跳跃武器","胜利跳跃着地","120"],
- "后空翻姿势" => ["右1旋转","胜利动作","拳限定","武器拳套","拳除外","展示武器","120"],
-
- # ―リ动画系―
- "受伤" => ["受到伤害时后退","坐标复位面向左"],
- "被暴击" => ["受到暴击时后退","坐标复位面向左"],
- "纵揺れ" => ["飞起","降落","飞起","降落","飞起","降落"],
-
- # ―快捷动作系―
- "斬り" => ["展示武器","对象动画武器","10"],
- "拳" => ["武器拳套","对象动画武器","10"],
- "弓" => ["Bow1","弓","箭支发射","9"],
- "攻击" => ["拳限定","拳","弓限定","弓","拳弓除外","斬り"],
- "准备开始攻击" => ["移动到目标面前","禁止消失","个人开始","二刀流限定","二刀左"],
- "攻击结束返回" => ["死亡确认","对象动画武器WT","个人结束","允许消失","下一个行动者","坐标复位"],
- "二刀左" => ["展示盾牌","对象动画武器LWT"],
- "特技发动" => ["前移一步","举起武器","特技发动动画"],
- "魔法发动" => ["前移一步","举起武器","魔法发动动画"],
- "插入" => ["插入背景始","插入分歧","70","插入終","插入背景終","20"],
- "插入分歧" => ["角色ID1限定","插入A1","角色ID2限定","插入A2","角色ID6限定","插入A3","角色ID7限定","插入A4"],
- "死亡标志动画" => ["白色淡入","50","死亡标志播放","白色淡出","50"],
- "进入太空背景" => ["昏暗背景","se('Blind',70)","30","进入太空背景改变","色调初始化"],
- "太空背景解除" => ["昏暗背景","50","太空背景解除","色调初始化"],
- "魔方陣表示" => ["se('Blind',70)","画面固定","魔方陣ON","サークル"],
- "魔方陣消去" => ["40","画面固定","魔方陣OFF","サークル"],
-
- # ――通常攻击系――
- "通常攻击" => ["准备开始攻击","待机(固定)","攻击结束返回"],
- "斩击攻击" => ["准备开始攻击","展示武器","攻击结束返回"],
- "拳攻击" => ["准备开始攻击","武器拳套","攻击结束返回"],
- "横戳攻击" => ["准备开始攻击","用武器横戳","攻击结束返回"],
- "弓攻击" => ["前移一步","禁止消失","个人开始","Bow1","弓",
- "箭支发射WT","个人结束","允许消失","坐标复位"],
-
- # ――技能系―――
- "泛用技能" => ["特技发动","展示武器","伤害动画","坐标复位"],
- "泛用魔法" => ["魔法发动","展示武器","伤害动画","坐标复位"],
-
- "水鉄砲" => ["特技发动","展示武器","水鉄砲发射","坐标复位"],
- "武器投掷" => ["特技发动","Bow1","展示武器","6","待机(固定)","武器投掷开始","武器投掷戻し","坐标复位"],
- "插入攻击" => ["特技发动","插入","准备开始攻击","展示武器","攻击结束返回"],
- "播放攻击" => ["特技发动","待机(固定)","死亡标志动画","准备开始攻击","展示武器","攻击结束返回"],
- "变身狼" => ["特技发动","化妆成狼","待机(固定)","40","坐标复位"],
- "5回攻击" => ["特技发动","禁止消失","弓除外","移动到目标面前","攻击","攻击","攻击","攻击","攻击","允许消失","坐标复位"],
- "技能派生" => ["武器投掷","多段攻击に派生"],
- "背景改变攻击" => ["魔法发动","展示武器","缩小","进入太空背景","伤害动画","镜头复位","太空背景解除","坐标复位"],
- "ピクチャ攻撃" => ["魔法发动","魔方陣表示","举起武器","anime(80,false)","60","摇晃大","对象动画","魔方陣消去","坐标复位"],
- "暗転攻击" => ["特技发动","自身和目标以外暗淡","se('Laser',150)",
- "幻影ON","移动到目标面前","anime(35,false)","移动到目标后方","对象动画",
- "展示武器","20","色调初始化","坐标复位","幻影OFF"],
- "空中攻击" => ["特技发动","Bow1","前跳一步","跳到目标头上",
- "待机(固定)","左1旋转","10","anime(117,false)","移动到敌人身上并展示武器",
- "对象动画","晃动中","强制","纵揺れ","20",
- "后跳一步","坐标复位"],
-
- # ――物品系―――
- "物品使用" => ["移动到目标面前","待机(固定)","对象动画WT","坐标复位面向左"],
-
- "测试动作" => ["插入A1"#"200","200","200","200","200","200","200","200","200","300"
-
-
-
-
- ],
-
- }
- #==============================================================================
- # ■ 战斗计划
- #------------------------------------------------------------------------------
- # 战斗场景的控制管理
- # 游戏控制开关・SideView专用开关
- #==============================================================================
- BATTLE_PROGRAM = {
-
- #--------------------------------------------------------------------------
- # ● 开关控制
- #--------------------------------------------------------------------------
- # 开关…程序控制开关。如果是负数将制定SideView专用的开关。
- # 如果是off,被执行的程序将强制终止。
- # SideView专用开关将在战斗结束时被重置(全OFF)。
- # 如果你想控制事件战斗前SideView专用开关操作,在事件脚本中加入
- # $sv_camera.switches[1] = true
- # (打开1号开关)
- #
- # ON编号…批量打开开关操作。如果是负数将制定SideView专用的开关。
- # 统一操作的开关数组。
- # 例…[1,2,-5] 将游戏开关1,2号和SideView专用开关5号打开。
- #
- # OFF编号…批量关闭开关操作。如果是负数将制定SideView专用的开关。
- # 如果你不想则留空[]。
- #
- # 时间…对开关操作进行的延时动作(单位帧)
- # 例如设置为100,将从程序开始时的100帧后进行开关操作。
- # [参考值] 30秒…1800 1分…3600 5分…18000 10分…36000 1小时…216000
- #
- # 随机修正…最终时间将由上述时间值至加上该修正的时间值。单位帧。
- # 例如时间设置为300修正设置为300,开关最终时间将在300-600中随机打开。
-
- #――程序名―― 判别 开关 ON番号 OFF番号 时间 修正值
- "背景要塞" => ["switch", -1, [-2], [], 1200, 0],
- "背景大海" => ["switch", -2, [-3], [], 2400, 0],
-
- #--------------------------------------------------------------------------
- # ● SE/BGM/BGS播放
- #--------------------------------------------------------------------------
- # 开关…控制开关。如果是负数将制定SideView专用的开关。
- #
- # 种类…音效"se" 背景音乐"bgm" 背景音效"bgs"
- #
- # 音调…50~150
- # 音量…50~150
- # 文件名…如果留空则不改变当前的音效。
-
- #―程序名―― 判别 开关 种类 音调 音量 文件名
- "潮汐" => ["sound", -1, "bgs", 100, 80, "Sea"],
-
- #--------------------------------------------------------------------------
- # ● 背景控制 对背景自动控制
- #--------------------------------------------------------------------------
- # 开关…控制开关
- #
- # 种类…对操作的背景种类选择。1地面、2远景图
- #
- # 滚动速度…背景的卷动速度。[X轴, Y轴]
- # 单位为每100帧移动的像素数。
- # 高速移动时,1000是一个标准值。
- #
- # BA翻转…被偷袭时是否反向滚动背景。
- #
- # 图像…需要更变背景图的情况下输入。如果不改变留空""
- # 地面位于Battlebacks1下,背景(远景)位于Battlebacks2下
- # 如果设置了,将会永久改变。
- #
- # 填充图像…背景滚动时,为了时背景更自然化所使用的填充图像。
- #
- # 中断…当背景运行时突然显示其他背景时的处理方法。
- # 允许被打断设置为true
- # 不允许被打断设置为false(其他背景挂起当前背景完成后显示被挂起的背景)
-
- #――程序名―― 判别 开关 种类 速度 BA翻转 图像 填充图像 中断
- "远景右移动" => ["scroll", -1, 1, [ 40, 0], true, "", "", true],
- "海背景3改变" => ["scroll", -2, 1, [ 120, 0], true, "Sea_ex03", "Sea_ex02", true],
- "海背景4改变" => ["scroll", -3, 1, [ 40, 0], true, "Sea_ex01", "Sea_ex04", true],
- "宇宙改变1" => ["scroll", -4, 1, [ 0, 0], true, "DarkSpace", "", false],
- "宇宙改变2" => ["scroll", -4, 2, [ 0, 0], true, "DarkSpace", "", false],
-
- #--------------------------------------------------------------------------
- # ● 周期图片 周期性出现的图片。比如大风或者魔法阵
- #--------------------------------------------------------------------------
- # 开关…周期图片控制开关
- # No.…对图片操作的编号。
- # 移动速度…每100帧移动的像素数。[X轴, Y轴] 如果设置为零则与背景同时滚动
- # 间隔…图片出现周期间隔。单位1帧。0表示无限制循环
- #
- # 透明操作…图像的透明度操作。[初始透明度, 每100帧增加的透明度]
- # 如果回到起始透明度255,会重复。
- # Z轴…图像的Z坐标。100以上会被现实到窗口前面。
- # 允许晃动…如果允许晃动则设置为true
- # BA翻转…被偷袭时是否反向播放图片。
- # 文件名…位于Pictures文件夹下。
-
- #――程序名―― 判别 开关 No. 速度 间隔 透明操作 Z轴 允许晃动 BA翻转 文件名
- "大风" => ["kpic", -1, 0,[ 500, 0], 0, [ 255, 0], 90, false, true, "back_wind"],
-
- #--------------------------------------------------------------------------
- # ● 周期SE 周期响起se音效。如雷鸣。
- #--------------------------------------------------------------------------
- # 开关…控制音效的开关。
- # 周期…音效出现的周期。单位帧。
- # 随机修正…周期会增加该随机值作为修正值。
- #
- # 音调。50~150。
- # 音量…50~150。
- # 开始执行…如果设置为true则打开开关时立即播放音效。
- # 文件名…
-
- #――程序名―― 判别 开关 周期 修正 音调 音量 开始执行 文件名
- "海鸥" => ["keep_se", -1, 400, 100, 150, 60, false, "Crow"],
- "海鸥2" => ["keep_se", -1, 300, 200, 140, 45, true, "Crow"],
-
- #--------------------------------------------------------------------------
- # ● 周期晃动 如地震、船上场合。
- #--------------------------------------------------------------------------
- # 开关…对晃动进行控制的开关。设置为ON则开始晃动。
- # 周期…晃动的周期。单位帧。
- # 随机修正…周期会增加该随机值作为修正值。
- #
- # 方向…晃动的方向 [横,纵] 数字越大幅度越大。
- # 速度…摇晃的速度。越小越快。
- # 时间…摇晃持续时间。摇晃的幅度会随着时间推移而减轻。
- # 开始执行…如果打开则立即执行不需要等待周期。
-
- #―程序名―― 判别 开关 周期 修正 方向 速度 时间 开始执行
- "船摇摆" => ["keep_sk", -1, 130, 0,[ 0, 4], 80, 120, true],
-
- #--------------------------------------------------------------------------
- # ● 周期色调改变
- #--------------------------------------------------------------------------
- # 开关…控制色调改变的开关。
- # 周期…单位帧。
- # 随机修正…周期会增加该随机值作为修正值。
- #
- # 对象…色调改变对象 [0=背景] [1=敌全] [2=我方全] [3=敌我方全] [4=全部]
- # 色调…[ R, G, B, 强度, 改变时间, 回归]
- # 回归…改变完成后回归原色调需要的时间。设置为0则不回归。
- # 开始执行…如果打开则立即执行不需要等待周期。
-
- #――程序名―― 判别 开关 周期 修正 对象 R, G, B, 强度 时间 回归 开始执行
- "雷光" => ["keep_c", 0, 300, 100, 4,[255,255,255,255, 8, 8], true],
- "紧急" => ["keep_c", 0, 150, 0, 4,[255, 0, 0,100, 40, 40], true],
-
- }
- #==============================================================================
- # ■ 镜头设置
- #------------------------------------------------------------------------------
- # 在这里设置镜头改变的时机以及参数。
- # 请不要改变名称。
- #==============================================================================
- BATTLE_CAMERA = {
- #--------------------------------------------------------------------------
- # ● 镜头 画面的缩放或者移动。
- #--------------------------------------------------------------------------
- # 对象…操作的对象 [2=敌全] [3=我方全] [4=敌我方全] [6=画面]
- # 調整坐标…镜头最终坐标的微调 [X轴(正方向→), Y轴(正方向↓)]
- # 时间…镜头调整的用时。
- # 放大率…100为原大小。
-
- #――动作名―― 判别 对象 調整坐标 放大率 时间
- "回合开始前" => ["camera", 3, [ 0, 0], 100, 40],
- "回合开始后" => ["camera", 6, [ 0, 0], 100, 40],
- "战斗结束时" => ["camera", 3, [ 0, 0], 100, 50],
-
- }
- end
复制代码
SideView图像设定部分
- #==============================================================================
- # ■ SideView图像設定
- #------------------------------------------------------------------------------
- # 角色动画贴图的设定。
- # 图像的详细设定请参阅每个实例。
- #==============================================================================
- class SideView
- #--------------------------------------------------------------------------
- # ● 动画图像横纵格子数 = [ 横, 縦] 动画默认的情况下为[1, 1]
- #--------------------------------------------------------------------------
- def max_pattern
- # 对每个角色的分别设定
- case id
- when 1 # 1号角色
- return [ 3, 4]
- when -1 # 1号敌人(敌人的ID要指定为负数)
- return [ 1, 1]
- else # 没有指定ID的情况下
- return [ 3, 4] if id > 0 # 全角色(ID为正)
- return [ 1, 1] if id < 0 # 全敌人(ID负数)
- end
- # 要分行设置ID请参阅此例
- end
- #--------------------------------------------------------------------------
- # ● 阴影文件名 图像在Characters下 false为无阴影
- #--------------------------------------------------------------------------
- def shadow
- return "shadow01" if id > 0 # 全角色
- return false if id < 0 # 全敌人
- end
- #--------------------------------------------------------------------------
- # ● 角色图像翻转設定 默认状态下为翻转true
- #--------------------------------------------------------------------------
- def graphic_mirror_flag
- return false if id > 0 # 全角色
- return true if id < 0 # 全敌人
- end
- #--------------------------------------------------------------------------
- # ● 角色画像参照先固定 バトラーアニメ設定のインデックス参照を必ず""にするならtrue
- #--------------------------------------------------------------------------
- def graphic_fix
- return false if id > 0 # 全アクター
- return true if id < 0 # 全エネミー
- end
- #--------------------------------------------------------------------------
- # ● 通常待机
- #--------------------------------------------------------------------------
- def normal
- return "通常待机" if id > 0 # 全角色
- return "敌待机(固定)WT" if id < 0 # 全敌人
- # 你可以为每个角色设置不同的待机动画
- end
- #--------------------------------------------------------------------------
- # ● 虚弱待机 HP在1/4以下的待机动画
- #--------------------------------------------------------------------------
- def pinch
- return "虚弱待机" if id > 0 # 全角色
- end
- #--------------------------------------------------------------------------
- # ● 状态动画 如果多个状态重叠,则优先显示高优先度的状态
- #--------------------------------------------------------------------------
- def state(state_id)
- # 状态ID分岐
- case state_id
- when 1
- return "战斗不能" if id > 0 # 全角色"战斗不能"
- return "敌消失" if id < 0 # 全敌人
- when 2
- return "毒待机"
- when 6
- return "睡眠待机"
- when 3,4,5,7,8
- return "泛用异常状态待机"
- when 9
- return "防御待机"
- end
- end
- #--------------------------------------------------------------------------
- # ● 命令动画
- #--------------------------------------------------------------------------
- def command
- # 选择技能ID分岐
- case skill_id
- when 2
- return "命令后防御"
- end
- # 技能类型分歧
- case skill_type
- when 1 # 特技
- return "命令后特技"
- when 2 # 魔法
- return "命令后魔法"
- when 5 # 开枪
- return "命令后开枪"
- when 6 # 聚能
- return "命令后聚能"
- end
- end
- #--------------------------------------------------------------------------
- # ● 战斗开始动画
- #--------------------------------------------------------------------------
- def first_action
- return "战斗开始我方" if id > 0 # 全角色
- return "敌待机(固定)WT" if id < 0 # 全敌人
- end
- #--------------------------------------------------------------------------
- # ● 胜利动画
- #--------------------------------------------------------------------------
- def win
- case id
- when 2,7,10 # 2・7・10号角色
- return "后空翻姿势"
- else
- return "胜利姿势摇摆"
- end
- end
- #--------------------------------------------------------------------------
- # ● 战斗退场动画 完成战斗时的退场动画
- #--------------------------------------------------------------------------
- def remove_action
- return "我方退场"
- end
- #--------------------------------------------------------------------------
- # ● 逃跑动画
- #--------------------------------------------------------------------------
- def escape
- return "逃跑" if id > 0 # 全角色
- return "敌逃跑" if id < 0 # 全敌人
- end
- #--------------------------------------------------------------------------
- # ● 逃跑失败动画
- #--------------------------------------------------------------------------
- def escape_ng
- return "逃跑失败"
- end
- #--------------------------------------------------------------------------
- # ● 输入命令前的等待动作
- #--------------------------------------------------------------------------
- def command_b
- return "输入命令"
- end
- #--------------------------------------------------------------------------
- # ● 输入命令后的等待动作
- #--------------------------------------------------------------------------
- def command_a
- return "输入命令后"
- end
- #--------------------------------------------------------------------------
- # ● 受伤动画
- #--------------------------------------------------------------------------
- def damage(attacker)
- # 被暴击的情况
- if critical?
- return "被暴击"
- # 治疗的情况下
- elsif recovery?
- # 不想设定动画则只需要return
- return
- end
- # 受到X号技能显示的动画
- case damage_skill_id
- when 1 # 技能1号的情况下
- return "受伤"
- when 136 # 不想设定动画则只需要return
- return
- end
- # 受到物品ID分歧
- case damage_item_id
- when 1 # 物品1号的情况下
- return
- else
- # 以上物品ID以外
- if damage_item_id != 0
- return
- end
- end
- # 伤害为零的情况 (如敌人逃跑、法术被免疫)
- if damage_zero?
- return
- end
- # 上述情况外
- return "受伤"
- end
- #--------------------------------------------------------------------------
- # ● 回避动作
- #--------------------------------------------------------------------------
- def evasion(attacker)
- return "盾躲避" if shield? # 如果装备了盾牌
- return "回避"
- end
- #--------------------------------------------------------------------------
- # ● 攻击失手时的动作
- #--------------------------------------------------------------------------
- def miss(attacker)
- #return "盾防御" if shield?
- return "回避"
- end
- #--------------------------------------------------------------------------
- # ● 武器动画 装备武器后的普通攻击
- # 也可以设定敌人装备武器。
- #--------------------------------------------------------------------------
- def weapon_action
- # 武器ID指定
- case weapon_id
- when 0 # 武器0号的情况下(徒手)
- return "通常攻击"
- when 1 # 武器1号的情况下
- return "斩击攻击"
- end
- # 武器类型指定
- case weapon_type
- when 1 # 武器类型1号的情况下
- return "斩击攻击"
- when 4,5,7,8,9 # 同时指定多个武器
- return "斩击攻击"
- when 2
- return "拳攻击"
- when 3
- return "横戳攻击"
- when 6
- return "弓攻击"
- end
- end
- #--------------------------------------------------------------------------
- # ● 敌人主武器 指定ID的敌人装备武器
- #--------------------------------------------------------------------------
- def enemy_weapon1_id
- case id
- when -1 # 1号敌人(敌人的ID为负数)
- return 0 # 武器ID分歧。0则指空手
- else
- return 0
- end
- end
- #--------------------------------------------------------------------------
- # ● 敌人副武器 指定ID的敌人装备副武器
- #--------------------------------------------------------------------------
- def enemy_weapon2_id
- case id
- when -1 # 1号敌人(敌人的ID为负数)
- return 0 # 武器ID分歧。0则指空手
- else
- return 0
- end
- end
- #--------------------------------------------------------------------------
- # ● 敌人盾 指定ID的敌人装备盾牌,它的优先度高于副武器
- #--------------------------------------------------------------------------
- def enemy_shield_id
- case id
- when -1 # 1号敌人(敌人的ID为负数)
- return 0 # 防具ID分歧。0则无防具
- else
- return 0
- end
- end
- #--------------------------------------------------------------------------
- # ● 武器图像指定
- #--------------------------------------------------------------------------
- # 武器动画类型[1:独自图像] [2:2003仕様]
- # 参考之前的武器动画设定。
- # return "001-Weapon01" ←请把这个文件放在同一个Characters文件夹中
- def weapon_graphic(weapon_id, weapon_type)
- # 武器ID分歧
- case weapon_id
- when 1 # 武器1号图像文件名
- return ""
- end
- # 武器类型分歧
- case weapon_type
- when 6 # 武器类型6号图像文件名
- return "bow01"
- end
- end
- #--------------------------------------------------------------------------
- # ● 盾图像指定
- #--------------------------------------------------------------------------
- # 动画类型 [1:独自图像] [2:2003仕様]
- # 副武器参照之前的副武器动画设定。
- #
- # return "001-Shield01" ←请把这个文件放在同一个Characters文件夹中
- def shield_graphic(weapon_id, shield_type)
- # 防具ID分歧
- case shield_id
- when 41 # 41号防具图像文件名
- return ""
- end
- # 防具类型分歧
- case shield_type
- when 5 # 5号防具类型图像文件名
- return ""
- end
- end
-
- #--------------------------------------------------------------------------
- # ● 技能动画
- #--------------------------------------------------------------------------
- def skill_action
- case skill_id # 技能ID分歧
- when 1 # 普通攻击
- return weapon_action
- when 2
- return "防御"
- when 3,4,5 # 对多个敌人发动攻击
- return weapon_action
- when 6 # 逃跑
- return escape
- when 7
- return "等待"
- #--------
- when 150
- return "测试动作"
- when 128
- return "水鉄砲"
- when 129
- return "武器投掷"
- when 130
- return "5回攻击"
- when 131
- return "カットイン攻击"
- when 132
- return "播放攻击"
- when 133
- return "オオカミ変身"
- when 134
- return "技能派生"
- when 36#135
- return "暗転攻击"
- when 37#136
- return "空中攻击"
- end
-
- # 指定技能名称分歧
- # 建议使用此类型指定技能,因为这在数据库中被移动可以不用重新修改。
- case skill_name
- when "背景変更サンプル"
- return "背景変更攻撃"
- when "ピクチャ攻撃サンプル"
- return "ピクチャ攻撃"
- end
-
- case skill_type # 技能类型分歧
- when 1 # 特技
- return "泛用技能"
- when 2 # 魔法
- return "泛用魔法"
- when 3 # 特技
- return "汎用开枪"
- when 4 # 魔法
- return "汎用聚能"
- end
- return "泛用技能"
- end
- #--------------------------------------------------------------------------
- # ● 物品动画
- #--------------------------------------------------------------------------
- def item_action
- case item_id # 物品ID分歧
- when 1
- return "物品使用"
- else
- return "物品使用"
- end
- end
- #--------------------------------------------------------------------------
- # ● 反击技能ID 反击的技能ID分歧
- #--------------------------------------------------------------------------
- # ※数据库で設定された技能や武器、图像の複数回攻击は反映されません
- def counter_skill_id
- return 1
- end
- #--------------------------------------------------------------------------
- # ● 魔法反射动画ID 魔法反射时的技能动画
- #--------------------------------------------------------------------------
- def reflection_anime_id
- return 118
- end
- #--------------------------------------------------------------------------
- # ● 保护开始动画
- #--------------------------------------------------------------------------
- def substitute_start_action
- return "保护开始"
- end
- #--------------------------------------------------------------------------
- # ● 保护结束动画
- #--------------------------------------------------------------------------
- def substitute_end_action
- return "保护结束"
- end
- #--------------------------------------------------------------------------
- # ● 被保护目标动画开始
- #--------------------------------------------------------------------------
- def substitute_receiver_start_action
- return "被保护开始"
- end
- #--------------------------------------------------------------------------
- # ● 被保护目标动画结束
- #--------------------------------------------------------------------------
- def substitute_receiver_end_action
- return "被保护结束"
- end
- #--------------------------------------------------------------------------
- # ● 敌人级别 利用条件分歧应用。
- #--------------------------------------------------------------------------
- def level
- case id
- when -1 # 1号敌人
- return 0
- end
- return 0
- end
-
- end
复制代码
Sideview核心脚本部分
- #==============================================================================
- # ■ Sideview Ver100
- #------------------------------------------------------------------------------
- # サイドビューバトラーを管理するクラスです。
- #==============================================================================
- class SideView
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_accessor :x # 画面X座標
- attr_accessor :y # 画面Y座標
- attr_accessor :z # 画面Z座標
- attr_accessor :h # 高さ座標
- attr_accessor :j # ジャンプ座標
- attr_accessor :c # カーブ座標
- attr_accessor :ox # 横原点
- attr_accessor :oy # 縦原点
- attr_accessor :oy_adjust # 縦原点補正
- attr_accessor :angle # 回転角度
- attr_accessor :zoom_x # 横の拡大率
- attr_accessor :zoom_y # 縦の拡大率
- attr_accessor :pattern_w # セル横位置(矩形内)
- attr_accessor :pattern_h # セル縦位置(矩形内)
- attr_accessor :sx # セル横位置(画像全体)
- attr_accessor :sy # セル縦位置(画像全体)
- attr_accessor :pattern_type # セル更新タイプ
- attr_accessor :pattern_time # セル更新間隔
- attr_accessor :graphic_name # バトラー画像ファイル名
- attr_accessor :graphic_file_index # バトラー画像ファイル名インデックス
- attr_accessor :graphic_index # バトラー画像インデックス
- attr_accessor :cw # セル横矩形
- attr_accessor :ch # セル縦矩形
- attr_accessor :shadow_visible # 影表示
- attr_accessor :weapon_visible # 武器表示
-
- attr_accessor :wait # 次の動作待ち時間
- attr_accessor :weapon_index # 表示中の武器画像インデックス配列
- attr_accessor :weapon_end # 武器アニメ終了フラグ
- attr_accessor :force_action # 強制アクション
- attr_accessor :target_battler # ターゲットバトラー情報
- attr_accessor :second_targets # セカンドターゲット情報
- attr_accessor :m_a_targets # アニメ飛ばしターゲット情報
- attr_accessor :individual_targets # 個別処理ターゲットバトラー情報
- attr_accessor :effect_data # エフェクトデータ
- attr_accessor :anime_id # アニメID配列
- attr_accessor :anime_move_id # 飛ばしアニメID配列
- attr_accessor :mirror # 反転フラグ
- attr_accessor :opacity # 透明度
- attr_accessor :opacity_data # 透明度操作情報
- attr_accessor :set_damage # バトルシーンでのダメージ処理
- attr_accessor :m_a_data # アニメ飛ばし情報
- attr_accessor :m_a_starter # アニメ飛ばし開始ターゲット情報
- attr_accessor :action_end # バトルシーンでの行動終了
- attr_accessor :damage_anime_data # ダメージ戦闘アニメのデータ
- attr_accessor :anime_no_mirror # 戦闘アニメの反転禁止フラグ
- attr_accessor :anime_horming # 戦闘アニメのホーミングフラグ
- attr_accessor :anime_camera_zoom # 戦闘アニメがカメラに合わせて拡大縮小するか
- attr_accessor :anime_plus_z # 戦闘アニメZ座標補正
- attr_accessor :derivation_skill_id # スキル派生ID
- attr_accessor :immortal # 不死身フラグ
- attr_accessor :mirage # 残像データ
- attr_accessor :balloon_data # ふきだしデータ
- attr_accessor :timing # 別バトラーからのタイミングデータ
- attr_accessor :timing_targets # タイミングデータを渡す別バトラー
- attr_accessor :color_set # 色調変更データ
- attr_accessor :color # 色調データ
- attr_accessor :change_up # 画像変更フラグ
- attr_accessor :hit # 被攻撃回数
- attr_accessor :add_state # 何度も付加ステートの表示を防ぐフラグ
- attr_accessor :counter_id # カウンター時のスキルID
- attr_accessor :reflection_id # 魔法反射時のアニメID
- attr_accessor :result_damage # ターン終了時のHP変動データ
- attr_accessor :active # 行動権
- attr_accessor :anime_off # 戦闘アニメ消去
- attr_accessor :command_action # コマンドアクションフラグ
-
- attr_accessor :base_x # 初期位置 X座標
- attr_accessor :base_y # 初期位置 Y座標
- attr_accessor :base_h # 初期位置 高さ座標
- attr_accessor :max_pattern_w # セルの横分割数
- attr_accessor :max_pattern_h # セルの縦分割数
-
- attr_reader :collapse # コラプスフラグ
- attr_reader :picture # ピクチャ表示フラグ
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(battler)
- [url=home.php?mod=space&uid=133701]@battler[/url] = battler
- reset
- end
- #--------------------------------------------------------------------------
- # ● 初期化
- #--------------------------------------------------------------------------
- def reset
- @x = 0
- @y = 0
- @z = 0
- @h = 0
- @j = 0
- @c = 0
- [url=home.php?mod=space&uid=271873]@jump[/url] = []
- @curve = []
- @ox = 0
- @oy = 0
- @oy_adjust = 0
- @z_plus = 0
- @move_time = 0
- [url=home.php?mod=space&uid=124954]@Angle[/url] = 0
- @angle_time = 0
- @zoom_x = 1
- @zoom_y = 1
- @zoom_time = 0
- @pattern_w = 0
- @pattern_h = 0
- @sx = 0
- @sy = 0
- @pattern_type = 0
- @pattern_time = 0
- @pattern_rest_time = 0
- @graphic_name = ""
- @graphic_file_index = ""
- @graphic_index = 0
- @cw = 0
- @ch = 0
- @shadow_visible = false
- @weapon_visible = true
-
- [url=home.php?mod=space&uid=36110]@Wait[/url] = 0
- @weapon_index = []
- @weapon_end = true
- @full_action = []
- @action = []
- @force_action = ""
- @target_battler = []
- @second_targets = []
- @individual_targets = []
- @m_a_targets = []
- @effect_data = []
- @anime_id = []
- @anime_move_id = []
- [url=home.php?mod=space&uid=316553]@opacity[/url] = 255
- @opacity_data = []
- @set_damage = false
- @m_a_data = []
- @m_a_starter = []
- @action_end = false
- @damage_anime_data = []
- @anime_no_mirror = false
- @anime_horming = false
- @anime_camera_zoom = false
- @anime_plus_z = true
- @derivation_skill_id = 0
- @immortal = false
- @mirage = []
- @play_data = []
- @balloon_data = []
- @picture = false
- @timing = []
- @timing_targets = []
- @color_set = []
- [url=home.php?mod=space&uid=10453]@color[/url] = []
- @change_up = false
- @non_motion = false
- @graphics_change = false
- @hit = []
- @add_state = []
- @collapse = false
- @counter_id = 0
- @reflection_id = 0
- @result_damage = [0,0]
- @active = false
- @anime_off = false
- @command_action = false
-
- @base_x = 0
- @base_y = 0
- @base_z = 0
- @base_h = 0
- @max_pattern_w = 0
- @max_pattern_h = 0
- @pattern_kind = 0
- @pattern_count = 0
- @move_time = 0
- [url=home.php?mod=space&uid=111303]@mirror[/url] = false
- @battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil
- @pre_change_data = nil
- end
- #--------------------------------------------------------------------------
- # ● セットアップ
- #--------------------------------------------------------------------------
- def setup(bitmap_width, bitmap_height, first_action_flag)
- reset if first_action_flag
- set_data
- set_base_position if !@graphics_change
- set_graphics(bitmap_width, bitmap_height)
- set_target
- setup_graphics_change if @graphics_change
- first_battler_anime_set if first_action_flag
- end
- #--------------------------------------------------------------------------
- # ● バトラーデータ取得
- #--------------------------------------------------------------------------
- def set_data
- return if [url=home.php?mod=space&uid=133701]@battler[/url] == nil
- if @battler.actor?
- @graphic_name = @battler.character_name
- @graphic_index = @battler.character_index
- else
- @graphic_name = @battler.battler_name
- @graphic_index = 0
- end
- @max_pattern_w = max_pattern[0]
- @max_pattern_h = max_pattern[1]
- end
- #--------------------------------------------------------------------------
- # ● ベース座標をセット data = [X軸, Y軸, H軸] moment_set…瞬間配置
- #--------------------------------------------------------------------------
- def set_base_position(moment_set = true)
- mirroring_reset
- if @battler.actor?
- data = N03::ACTOR_POSITION[@battler.index].dup
- @base_x = data[0] * 100 if !@mirror
- @base_x = (Graphics.width - data[0]) * 100 if @mirror
- else
- data = [@battler.screen_x, @battler.screen_y, 0].dup
- @base_x = data[0] * 100 if !$sv_camera.mirror
- @base_x = (Graphics.width - data[0]) * 100 if $sv_camera.mirror
- end
- @base_y = data[1] * 100
- @base_h = data[2] * 100
- @base_z = @y
- return if !moment_set
- @x = @base_x
- @y = @base_y
- @z = @base_z
- end
- #--------------------------------------------------------------------------
- # ● グラフィックデータ取得
- #--------------------------------------------------------------------------
- def set_graphics(bitmap_width, bitmap_height)
- sign = @graphic_name[/^[\!\$]./]
- if sign && sign.include?('$')
- @cw = bitmap_width / @max_pattern_w
- @ch = bitmap_height / @max_pattern_h
- elsif @max_pattern_w == 1 && @max_pattern_h == 1
- @cw = bitmap_width
- @ch = bitmap_height
- else
- @cw = bitmap_width / (@max_pattern_w * 4)
- @ch = bitmap_height / (@max_pattern_h * 2)
- end
- @ox = @cw / 2
- @oy = @ch
- @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
- @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
- end
- #--------------------------------------------------------------------------
- # ● ターゲットをセット
- #--------------------------------------------------------------------------
- def set_target(target = nil)
- @target_battler = target
- @target_battler = [@battler] if target == nil
- @second_targets = @target_battler
- end
- #--------------------------------------------------------------------------
- # ● 画像変更用のセットアップ
- #--------------------------------------------------------------------------
- def setup_graphics_change
- @graphics_change = false
- @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
- @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
- end
- #--------------------------------------------------------------------------
- # ● 戦闘開始時の待機アニメ画像データ取得
- #--------------------------------------------------------------------------
- def first_battler_anime_set
- loop do
- update
- break if @action_data == nil
- break if @action_data[0] == "motion"
- break if @action_data[0] == "move" && @action_data[8] != ""
- break if @full_action == []
- end
- start_action(first_action) if @battler.movable?
- end
- #--------------------------------------------------------------------------
- # ● アクション開始
- #--------------------------------------------------------------------------
- def start_action(kind = nil)
- return if @event_fix && $game_troop.interpreter.running?
- # ウェイト中の場合キャンセル
- return @wait -= 1 if @wait > 0 && kind == nil
- action_setup(false) if kind != nil
- set_action(kind)
- @action = kind if @action == nil
- # 行動配列が無い場合は行動終了処理へ移行
- action_terminate if @action == nil
- # 次のアクション決定
- @action_data = N03::ACTION[@action]
- next_action
- end
- #--------------------------------------------------------------------------
- # ● 行動パラメータの初期化
- #--------------------------------------------------------------------------
- def action_setup(reset = true)
- @event_fix = false
- @set_damage = false
- @action_end = false
- @balloon_data = []
- @loop_act = []
- angle_reset if reset
- zoom_reset if reset
- opacity_reset if reset
- @curve = []
- @c = 0
- convert_jump
- end
- #--------------------------------------------------------------------------
- # ● 行動終了処理
- #--------------------------------------------------------------------------
- def action_terminate
- @mirage = [] if @mirage_end
- mirroring_reset
- @picture = false
- @individual_targets = []
- action_setup if @active
- action_setup(false) if !@active
- # 待機アクションへ移行
- stand_by_action if !@non_motion
- # 戦闘行動のアクティブ権を終了
- next_battler
- end
- #--------------------------------------------------------------------------
- # ● 新しいアクション内容の決定
- #--------------------------------------------------------------------------
- def set_action(kind = nil)
- full_act = N03::FULLACTION[kind]
- @full_action = full_act.dup if full_act != nil
- @action = @full_action.shift
- # 参照したアクションがフルアクションであれば全体のアクションを統合
- full_act2 = N03::FULLACTION[@action]
- @full_action = full_act2.dup + @full_action if full_act2 != nil
- end
- #--------------------------------------------------------------------------
- # ● 次のアクションへ
- #--------------------------------------------------------------------------
- def next_action
- @wait = 0
- # ショートカット確認
- eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
- # ウエイト設定
- @wait = @action.to_i if @wait == 0 && @action_data == nil
- @wait = rand(@wait.abs + 1) if @wait < 0
- # アクション開始
- action_play
- end
- #--------------------------------------------------------------------------
- # ● 待機アクションへ移行
- #--------------------------------------------------------------------------
- def stand_by_action
- # 通常待機に
- stand_by_act = normal
- # HPが1/4でピンチアクションに
- stand_by_act = pinch if @battler.hp <= @battler.mhp / 4
- # ステートチェック
- stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
- # コマンドチェック
- stand_by_act = command if @command_action && command != nil
- set_action(stand_by_act)
- @action = stand_by_act if @action == nil
- end
- #--------------------------------------------------------------------------
- # ● 強制アクション開始
- #--------------------------------------------------------------------------
- def start_force_action
- return if @active
- start_action(@force_action)
- @force_action = ""
- end
- #--------------------------------------------------------------------------
- # ● アクション追加
- #--------------------------------------------------------------------------
- def add_action(kind)
- @full_action.push(kind)
- end
- #--------------------------------------------------------------------------
- # ● アクションの挿入
- #--------------------------------------------------------------------------
- def unshift_action(kind)
- @full_action.unshift(kind)
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- # アクション開始
- start_action
- # 強制アクション開始
- start_force_action if @force_action != ""
- # アニメパターン更新
- update_pattern
- # 移動更新
- update_move
- # 回転更新
- update_angle if @angle_time != 0
- # 拡大縮小更新
- update_zoom if @zoom_time != 0
- # 透明度更新
- update_opacity if @opacity_data != []
- end
- #--------------------------------------------------------------------------
- # ● アニメパターン更新
- #--------------------------------------------------------------------------
- def update_pattern
- return @pattern_rest_time -= 1 if @pattern_rest_time != 0
- return if @max_pattern_w == 1 && @max_pattern_h == 1
- @pattern_rest_time = @pattern_time
- # 再生開始・終了セル位置を取得
- if @pattern_kind > 0 # 通常再生中
- @pattern_start = 0
- @pattern_end = @max_pattern_w - 1
- elsif @pattern_kind < 0 # 逆転再生中
- @pattern_start = @max_pattern_w - 1
- @pattern_end = 0
- end
- # 片道の再生が終了
- @pattern_count += 1 if @pattern_w == @pattern_end && @pattern_kind != 0
- # ループ処理
- case @pattern_type.abs
- when 1,3 # 片道
- @pattern_kind = 0 if @pattern_count != 0 && @pattern_type == 1
- @pattern_kind = 0 if @pattern_count != 0 && @pattern_type == -1
- @pattern_kind = 1 if @pattern_count != 0 && @pattern_type == 3
- @pattern_kind = -1 if @pattern_count != 0 && @pattern_type == -3
- @pattern_w = @pattern_start - @pattern_kind if @pattern_count != 0 && @pattern_type.abs == 3
- @pattern_count = 0
- when 2,4 # 往復
- @pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 2
- @pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -2
- @pattern_kind = 0 if @pattern_count == 2 && @pattern_type == 2
- @pattern_kind = 0 if @pattern_count == 2 && @pattern_type == -2
- @pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 4
- @pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -4
- @pattern_kind = 1 if @pattern_count == 2 && @pattern_type == 4
- @pattern_kind = -1 if @pattern_count == 2 && @pattern_type == -4
- @pattern_count = 0 if @pattern_count == 2
- end
- # セル更新
- @pattern_w += 1 * @pattern_kind
- @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
- end
- #--------------------------------------------------------------------------
- # ● 移動の更新
- #--------------------------------------------------------------------------
- def update_move
- @z = @y / 100 + @z_plus
- return if @move_time == 0
- target_position_set if @horming_move
- @x = (@x * (@move_time - 1) + @target_x) / @move_time
- @y = (@y * (@move_time - 1) + @target_y) / @move_time
- @h = (@h * (@move_time - 1) + @target_h) / @move_time if @move_h != nil
- @c += @curve[@move_time - 1] if @curve[@move_time - 1] != nil
- @j += @jump[@move_time - 1] if @jump[@move_time - 1] != nil
- @move_time -= 1
- convert_jump if @move_time == 0
- end
- #--------------------------------------------------------------------------
- # ● 移動目標の更新
- #--------------------------------------------------------------------------
- def target_position_set
- target_position = N03.get_targets_position(@move_targets, @horming_move)
- @target_x = target_position[0] + @move_x
- @target_y = target_position[1] + @move_y
- @target_h = target_position[2] + @move_h if @move_h != nil
- end
- #--------------------------------------------------------------------------
- # ● 回転更新
- #--------------------------------------------------------------------------
- def update_angle
- @angle += @angling
- @angle_time -= 1
- return if @angle_time != 0
- return angle_reset if @angle_data[4] == 0
- angling(@angle_data) if @angle_data[4] == 2
- end
- #--------------------------------------------------------------------------
- # ● 拡大縮小更新
- #--------------------------------------------------------------------------
- def update_zoom
- @zoom_x += @zooming_x
- @zoom_y += @zooming_y
- @zoom_time -= 1
- return if @zoom_time != 0
- return zoom_reset if @zoom_data[4] == 0
- zooming(@zoom_data) if @zoom_data[4] == 2
- end
- #--------------------------------------------------------------------------
- # ● 透明度更新
- #--------------------------------------------------------------------------
- def update_opacity
- @opacity += @opacity_data[2]
- @opacity_data[0] -= 1
- return if @opacity_data[0] != 0
- return if !@opacity_data[5]
- @opacity_data[2] *= -1
- @opacity_data[0] = @opacity_data[1]
- end
- #--------------------------------------------------------------------------
- # ● アクション実行
- #--------------------------------------------------------------------------
- def action_play
- return if @action_data == nil
- action = @action_data[0]
- # バトラー反転の場合
- return mirroring if action == "mirror"
- # 残像の場合
- return mirage_set if action == "mirage"
- # 回転の場合
- return angling if action == "angle"
- # 拡大縮小の場合
- return zooming if action == "zoom"
- # 透明度操作の場合
- return set_opacity if action == "opacity"
- # バトラーアニメの場合
- return battler_anime if action == "motion"
- # 移動の場合
- return move if action == "move"
- # 武器アニメの場合
- return weapon_anime([@action_data]) if action == "wp"
- # アニメ飛ばしの場合
- return move_anime if action == "m_a"
- # 戦闘シーン通信の場合(コラプス)
- return set_play_data if action == "collapse" or action == "no_collapse"
- # データベース戦闘アニメ表示の場合
- return battle_anime if action == "anime"
- # カメラワークの場合
- return camera if action == "camera"
- # 画面のシェイクの場合
- return shake if action == "shake"
- # 画面色調変更の場合
- return color_effect if action == "color"
- # トランジションの場合
- return transition if action == "ts"
- # ふきだしアニメ表示の場合
- return balloon_anime if action == "balloon"
- # ピクチャ表示の場合
- return picture_set if action == "pic"
- # ステート操作の場合
- return state_set if action == "sta"
- # FPS変更の場合
- return fps if action == "fps"
- # バトラー画像変更の場合
- return graphics_change if action == "change"
- # スキル派生の場合
- return derivating_skill if action == "der"
- # BGM/BGS/SE演奏の場合
- return sound if action == "sound"
- # ムービー再生の場合
- return movie if action == "movie"
- # ゲームスイッチ操作の場合
- return switches if action == "switch"
- # ゲーム変数操作の場合
- return variable if action == "variable"
- # 条件分岐(ゲームスイッチ)の場合
- return nece_1 if action == "n_1"
- # 条件分岐(ゲーム変数)の場合
- return nece_2 if action == "n_2"
- # 条件分岐(ステート)の場合
- return nece_3 if action == "n_3"
- # 条件分岐(スキル)の場合
- return nece_4 if action == "n_4"
- # 条件分岐(パラメータ)の場合
- return nece_5 if action == "n_5"
- # 条件分岐(装備)の場合
- return nece_6 if action == "n_6"
- # 条件分岐(スクリプト)の場合
- return nece_7 if action == "n_7"
- # セカンドターゲット操作の場合
- return second_targets_set if action == "s_t"
- # コモンイベント呼び出しの場合
- return call_common_event if action == "common"
- # 戦闘アニメ消去の場合
- return @anime_off = true if action == "anime_off"
- # 強制戦闘終了の場合
- return BattleManager.process_abort if action == "battle_end"
- # 画面固定の場合
- return Graphics.freeze if action == "graphics_freeze"
- # ダメージアニメの場合
- return damage_anime if action == "damage_anime"
- # 武器消去の場合
- return @weapon_visible = false if action == "weapon_off"
- # 武器消去解除の場合
- return @weapon_visible = true if action == "weapon_on"
- # 待機キャンセルの場合
- return @non_motion = true if action == "non_motion"
- # 待機キャンセル解除の場合
- return @non_motion = false if action == "non_motion_cancel"
- # 初期位置変更の場合
- return change_base_position if action == "change_base_position"
- # 初期位置変更解除の場合
- return set_base_position(false) if action == "set_base_position"
- # 強制アクションの場合
- return force_act if action == "force_action"
- # 強制アクションの場合 (セカンドターゲット)
- return force_act2 if action == "force_action2"
- # 個別開始の場合
- return individual_start if action == "individual_start"
- # 個別終了の場合
- return individual_end if action == "individual_end"
- # ループ開始の場合
- return loop_start if action == "loop_start"
- # ループ終了の場合
- return loop_end if action == "loop_end"
- # 自分のみ更新の場合
- return only_action_on if action == "only_action_on"
- # 自分のみ更新解除の場合
- return only_action_off if action == "only_action_off"
- # 次の行動者へ移行の場合
- return next_battler if action == "next_battler"
- # 画像変更フラグの場合
- return set_change if action == "set_change"
- # スクリプト操作の場合
- return eval(@action_data[0])
- end
- #--------------------------------------------------------------------------
- # ● バトラー反転実行
- #--------------------------------------------------------------------------
- def mirroring
- @mirror = !@mirror
- end
- #--------------------------------------------------------------------------
- # ● 反転初期化
- #--------------------------------------------------------------------------
- def mirroring_reset
- @mirror = false
- mirroring if !@battler.actor? && N03::ENEMY_MIRROR
- mirroring if $sv_camera.mirror
- end
- #--------------------------------------------------------------------------
- # ● 残像実行
- #--------------------------------------------------------------------------
- def mirage_set
- @mirage = @action_data.dup
- @mirage_end = @mirage[3]
- @mirage = [] if @mirage[1] == 0
- end
- #--------------------------------------------------------------------------
- # ● 回転実行
- #--------------------------------------------------------------------------
- def angling(data = @action_data)
- @angle_data = data.dup
- @oy = @ch / 2
- @oy_adjust = @ch * 50
- @angle_time = data[1]
- start_angle = data[2] * N03.mirror_num(@mirror)
- end_angle = data[3] * N03.mirror_num(@mirror)
- # 時間が0以下なら即座に最終角度へ
- @angle_time = 1 if @angle_time <= 0
- # 回転時間から1フレームあたりの角度を出す
- @angling = (end_angle - start_angle) / @angle_time
- # 割り切れない余りを初期角度に
- @angle = (end_angle - start_angle) % @angle_time + start_angle
- end
- #--------------------------------------------------------------------------
- # ● 回転初期化
- #--------------------------------------------------------------------------
- def angle_reset
- @oy = @ch
- @angle = @angle_time = @oy_adjust = 0
- end
- #--------------------------------------------------------------------------
- # ● 拡大縮小実行
- #--------------------------------------------------------------------------
- def zooming(data = @action_data)
- @zoom_data = data.dup
- @zoom_time = data[1]
- start_zoom_x = data[2][0]
- start_zoom_y = data[2][1]
- end_zoom_x = data[3][0]
- end_zoom_y = data[3][1]
- # 時間が0以下なら即座に最終サイズへ
- @zoom_time = 1 if @zoom_time <= 0
- # 拡大縮小時間から1フレームあたりの拡大縮小率を出す
- @zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
- @zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
- # 開始サイズに
- @zoom_x = start_zoom_x
- @zoom_y = start_zoom_y
- end
- #--------------------------------------------------------------------------
- # ● 拡大縮小初期化
- #--------------------------------------------------------------------------
- def zoom_reset
- @zoom_x = @zoom_y = 1
- @zoom_time = 0
- end
- #--------------------------------------------------------------------------
- # ● バトラー透明度操作
- #--------------------------------------------------------------------------
- def set_opacity
- data = @action_data.dup
- @opacity = data[2]
- opacity_move = (data[3] - data[2])/ data[1]
- @opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
- @wait = data[1] if data[7]
- @wait *= 2 if data[6] && data[7]
- end
- #--------------------------------------------------------------------------
- # ● 透明度操作初期化
- #--------------------------------------------------------------------------
- def opacity_reset
- @opacity = 255
- @opacity = 0 if @battler.hidden?
- @opacity_data = []
- end
- #--------------------------------------------------------------------------
- # ● バトラーアニメ実行
- #--------------------------------------------------------------------------
- def battler_anime(anime_data = nil)
- anime_data = @action_data.dup if anime_data == nil
- @graphic_file_index = anime_data[1] if !graphic_fix
- @pattern_h = anime_data[2]
- @pattern_w = anime_data[3]
- @pattern_h = 0 if @max_pattern_w == 1
- @pattern_w = 0 if @max_pattern_h == 1
- @pattern_type = anime_data[4]
- @pattern_time = anime_data[5]
- @pattern_rest_time = anime_data[5]
- @pattern_count = 0
- @pattern_kind = 1
- @pattern_kind = -1 if @pattern_type < 0
- @pattern_kind = 0 if @pattern_type == 0
- @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
- @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
- @z_plus = anime_data[6]
- @wait = set_anime_wait if anime_data[7]
- @shadow_visible = anime_data[8]
- weapon_anime(anime_data)
- end
- #--------------------------------------------------------------------------
- # ● アニメウエイト計算
- #--------------------------------------------------------------------------
- def set_anime_wait
- if @pattern_type > 0
- pattern_time_a = @max_pattern_w - @pattern_w.abs
- elsif @pattern_type < 0
- pattern_time_a = @pattern_w.abs + 1
- else
- return @pattern_time if @pattern_type == 0
- end
- case @pattern_type
- when 1,-1, 3,-3
- return pattern_time_a * @pattern_time
- when 2,-2, 4,-4
- return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time
- end
- end
- #--------------------------------------------------------------------------
- # ● 移動実行
- #--------------------------------------------------------------------------
- def move
- @move_targets = N03.get_targets(@action_data[1].abs, @battler)
- return if @move_targets == []
- @move_targets = [@battler] if @action_data[1].abs == 7
- @move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)
- @move_y = @action_data[3] * 100
- @move_h = @action_data[4] * 100 if @action_data[4] != nil
- @move_h = nil if @action_data[4] == nil
- battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
- @horming_move = true
- @horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7
- target_position_set
- target_position = [@target_x, @target_y, @target_z]
- distanse_move = @action_data[5] > 0
- @move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)
- @wait = @move_time
- curve
- jump
- @move_time = 1 if @move_time == 0
- @horming_move = false if !@move_targets or @move_targets.include?(@battler)
- update_move if @move_time == 1
- end
- #--------------------------------------------------------------------------
- # ● カーブ実行
- #--------------------------------------------------------------------------
- def curve
- @c = 0
- return if @action_data[6] == 0
- @curve = N03.parabola([@action_data[6], -@action_data[6]], @move_time, 100, 4)
- end
- #--------------------------------------------------------------------------
- # ● ジャンプ実行
- #--------------------------------------------------------------------------
- def jump
- convert_jump
- return if @action_data[7] == [0,0]
- @jump = N03.parabola(@action_data[7].dup, @move_time, 100)
- end
- #--------------------------------------------------------------------------
- # ● J座標(ジャンプ高度)をH座標に変換
- #--------------------------------------------------------------------------
- def convert_jump
- @h += @j
- @j = 0
- @jump = []
- end
- #--------------------------------------------------------------------------
- # ● データベース戦闘アニメ実行
- #--------------------------------------------------------------------------
- def battle_anime
- data = @action_data.dup
- targets = N03.get_targets(data[2], @battler)
- return if targets == []
- data[8] = !data[8] if @mirror
- @set_damage = data[5]
- @damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)
- @damage_anime_data[1] = data[8]
- @damage_anime_data[2] = data[7]
- @damage_anime_data[3] = data[6]
- @damage_anime_data[4] = data[9]
- @wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]
- return if @set_damage
- for target in targets do display_anime(targets, target, data) end
- end
- #--------------------------------------------------------------------------
- # ● 武器アニメ開始
- #--------------------------------------------------------------------------
- def weapon_anime(anime_data)
- @weapon_end = true
- for i in 9...anime_data.size
- set_effect_data(anime_data[i]) if anime_data[i] != ""
- end
- end
- #--------------------------------------------------------------------------
- # ● アニメ飛ばし開始
- #--------------------------------------------------------------------------
- def move_anime
- @m_a_starter = []
- @m_a_targets = []
- starters = N03.get_targets(@action_data[2], @battler)
- targets = N03.get_targets(@action_data[3], @battler)
- return if starters == [] or targets == []
- single_start = true if starters != nil && @action_data[2] < 0
- single_start = true if @action_data[1][0] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3
- starters = [starters[0]] if single_start
- single_end = true if targets != nil && @action_data[3] < 0
- single_end = true if @action_data[1][1] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3
- targets = [targets[0]] if single_end
- se_flag = true
- for starter in starters
- for target in targets
- data = @action_data.dup
- data[17] = se_flag
- @effect_data.push(data)
- @m_a_targets.push(target)
- @m_a_starter.push(starter)
- se_flag = false
- end
- end
- end
- #--------------------------------------------------------------------------
- # ● スプライトセット通信
- #--------------------------------------------------------------------------
- def set_effect_data(data = @action)
- action_data = N03::ACTION[data]
- return if action_data == nil
- @effect_data.push(action_data.dup)
- end
- #--------------------------------------------------------------------------
- # ● 戦闘シーン通信のデータを格納
- #--------------------------------------------------------------------------
- def set_play_data(data = @action_data)
- @play_data = data.dup
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメの表示
- #--------------------------------------------------------------------------
- def display_anime(targets, target, data)
- return if !N03.first_of_all_screen_anime(data[1], target, targets)
- target.animation_id = N03.get_attack_anime_id(data[1], @battler)
- target.animation_mirror = data[8]
- target.sv.anime_horming = data[3]
- target.sv.anime_camera_zoom = data[6]
- target.sv.anime_no_mirror = data[7]
- target.sv.anime_plus_z = data[9]
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメ拡張データの初期化
- #--------------------------------------------------------------------------
- def reset_anime_data
- @anime_no_mirror = false
- @anime_horming = false
- @anime_camera_zoom = false
- @timing_targets = []
- @anime_plus_z = true
- end
- #--------------------------------------------------------------------------
- # ● カメラワーク
- #--------------------------------------------------------------------------
- def camera
- data = @action_data.dup
- N03.camera(@battler, data)
- @wait = data[4] if data[5]
- end
- #--------------------------------------------------------------------------
- # ● 画面のシェイク
- #--------------------------------------------------------------------------
- def shake
- data = @action_data.dup
- $sv_camera.shake(data[1], data[2], data[3])
- @wait = data[3] if data[4]
- end
- #--------------------------------------------------------------------------
- # ● 画面色調変更
- #--------------------------------------------------------------------------
- def color_effect
- case @action_data[1]
- when 0,1,2,3,4,5
- targets = N03.get_targets(@action_data[1], @battler)
- when 6
- screen = true
- when 7
- targets = [@battler] + @target_battler
- when 8
- screen = true
- targets = $game_troop.members + $game_party.battle_members - [@battler]
- when 9
- screen = true
- targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler
- when 10
- screen = true
- targets = $game_troop.members + $game_party.battle_members
- end
- return if screen == nil && targets == []
- for target in targets do target.sv.color_set = @action_data[2] end if targets
- @wait = @action_data[2][4] if @action_data[3]
- return if !screen
- $sv_camera.color_set[1] = @action_data[2]
- $sv_camera.color_set[2] = @action_data[2]
- end
- #--------------------------------------------------------------------------
- # ● トランジション
- #--------------------------------------------------------------------------
- def transition
- $sv_camera.perform_transition(@action_data)
- end
- #--------------------------------------------------------------------------
- # ● ふきだしアニメ表示
- #--------------------------------------------------------------------------
- def balloon_anime
- @balloon_data = @action_data.dup
- end
- #--------------------------------------------------------------------------
- # ● ピクチャ表示
- #--------------------------------------------------------------------------
- def picture_set
- @picture = true
- set_effect_data
- end
- #--------------------------------------------------------------------------
- # ● ステート操作
- #--------------------------------------------------------------------------
- def state_set
- targets = N03.get_targets(@action_data[1], @battler)
- return if targets == []
- case @action_data[2]
- when 1 ; targets = [targets[rand(targets.size)]]
- when 2 ; targets -= @battler if targets.include?(@battler)
- end
- for target in targets
- for id in @action_data[4]
- target.add_state(id) if @action_data[3] == "+"
- target.remove_state(id) if @action_data[3] == "-"
- end
- end
- end
- #--------------------------------------------------------------------------
- # ● FPS変更
- #--------------------------------------------------------------------------
- def fps
- Graphics.frame_rate = @action_data[1]
- start_action
- end
- #--------------------------------------------------------------------------
- # ● バトラー画像変更の場合
- #--------------------------------------------------------------------------
- def graphics_change
- @graphics_change = true
- return @battler.graphics_change(@action_data[3]) if !@battler.actor?
- @pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]
- if @action_data[4] == []
- face_name = @battler.face_name
- face_index = @battler.face_index
- else
- face_name = @action_data[4][1]
- face_index = @action_data[4][0]
- end
- @battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)
- end
- #--------------------------------------------------------------------------
- # ● スキル派生
- #--------------------------------------------------------------------------
- def derivating_skill
- # 未修得スキルは派生不可なら
- return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])
- # コスト不足は派生不可なら
- return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])
- # 派生
- @derivation_skill_id = @action_data[3]
- # 以降のアクションをキャンセル
- @full_action = []
- end
- #--------------------------------------------------------------------------
- # ● BGM/BGS/SE演奏
- #--------------------------------------------------------------------------
- def sound
- pitch = @action_data[2]
- vol = @action_data[3]
- name = @action_data[4]
- case @action_data[1]
- when "se"
- Audio.se_play("Audio/SE/" + name, vol, pitch)
- when "bgm"
- # 名前指定のない場合、現在のBGMを変えないように
- name = RPG::BGM.last.name if @action_data[4] == ""
- Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
- when "bgs"
- name = RPG::BGS.last.name if @action_data[4] == ""
- Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
- end
- end
- #--------------------------------------------------------------------------
- # ● ムービーの再生
- #--------------------------------------------------------------------------
- def movie
- Graphics.play_movie('Movies/' + @action_data[1])
- end
- #--------------------------------------------------------------------------
- # ● ゲームスイッチ操作
- #--------------------------------------------------------------------------
- def switches
- for id in @action_data[1]
- $game_switches[id] = true if id > 0
- $sv_camera.switches[id.abs] = true if id < 0
- end
- for id in @action_data[2]
- $game_switches[id] = false if id > 0
- $sv_camera.switches[id.abs] = false if id < 0
- end
- $sv_camera.program_check
- end
- #--------------------------------------------------------------------------
- # ● ゲーム変数操作
- #--------------------------------------------------------------------------
- def variable
- # オペランドチェック
- operand = @action_data[3]
- operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0
- # 変数操作で分岐
- case @action_data[2]
- when 0 ; $game_variables[@action_data[1]] = operand # 代入
- when 1 ; $game_variables[@action_data[1]] += operand # 加算
- when 2 ; $game_variables[@action_data[1]] -= operand # 減算
- when 3 ; $game_variables[@action_data[1]] *= operand # 乗算
- when 4 ; $game_variables[@action_data[1]] /= operand # 除算
- when 5 ; $game_variables[@action_data[1]] %= operand # 剰余
- end
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (ゲームスイッチ)
- #--------------------------------------------------------------------------
- def nece_1
- judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
- judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
- action_diverging(judgment, @action_data[3])
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (ゲーム変数)
- #--------------------------------------------------------------------------
- def nece_2
- variable = $game_variables[@action_data[1]]
- num = @action_data[2]
- num = $game_variables[@action_data[2].abs] if num < 0
- case @action_data[3]
- when 0 ; judgment = variable == num
- when 1 ; judgment = variable < num
- when 2 ; judgment = variable > num
- end
- action_diverging(judgment, @action_data[4])
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (ステート)
- #--------------------------------------------------------------------------
- def nece_3
- targets = N03.get_targets(@action_data[1], @battler)
- return if targets == []
- member_num = @action_data[4]
- member_num = targets.size if @action_data[4] == 0 && targets.size > 1
- hit_count = 0
- miss_count = 0
- for target in targets
- hit_count += 1 if target.state?(@action_data[2])
- miss_count += 1 if !target.state?(@action_data[2])
- end
- case @action_data[3]
- when 0 ; judgment = hit_count >= member_num
- when 1 ; judgment = miss_count >= member_num
- end
- action_diverging(judgment, @action_data[5])
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (スキル)
- #--------------------------------------------------------------------------
- def nece_4
- targets = N03.get_targets(@action_data[1], @battler)
- return if targets == []
- member_num = @action_data[4]
- member_num = targets.size if @action_data[4] == 0 && targets.size > 1
- hit_count = 0
- miss_count = 0
- for target in targets
- hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
- miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
- end
- case @action_data[3]
- when 0 ; judgment = hit_count >= member_num
- when 1 ; judgment = miss_count >= member_num
- end
- action_diverging(judgment, @action_data[5])
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (パラメータ)
- #--------------------------------------------------------------------------
- def nece_5
- targets = N03.get_targets(@action_data[1], @battler)
- return if targets == []
- member_num = @action_data[5]
- member_num = targets.size if @action_data[5] == 0 && targets.size > 1
- hit_count = 0
- for target in targets
- hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
- end
- judgment = hit_count >= member_num
- action_diverging(judgment, @action_data[6])
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (装備)
- #--------------------------------------------------------------------------
- def nece_6
- targets = N03.get_targets(@action_data[1], @battler)
- return if targets == []
- member_num = @action_data[5]
- member_num = targets.size if @action_data[5] == 0 && targets.size > 1
- hit_count = 0
- miss_count = 0
- for target in targets
- hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])
- miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])
- end
- case @action_data[4]
- when 0 ; judgment = hit_count >= member_num
- when 1 ; judgment = miss_count >= member_num
- end
- action_diverging(judgment, @action_data[6])
- end
- #--------------------------------------------------------------------------
- # ● 条件分岐 (スクリプト)
- #--------------------------------------------------------------------------
- def nece_7
- judgment = eval(@action_data[2])
- action_diverging(judgment, @action_data[1])
- end
- #--------------------------------------------------------------------------
- # ● アクション分岐
- #--------------------------------------------------------------------------
- def action_diverging(judgment, kind)
- result = 0
- if judgment
- result = 1 if kind == 1
- result = 2 if kind == 2
- else
- result = 1 if kind == 0
- end
- # フルアクション終了
- return @full_action = [] if result == 2
- # 次のアクションを除去
- @full_action.shift if result == 1
- set_action
- # 次のアクションを実行
- @action_data = N03::ACTION[@action]
- next_action
- end
- #--------------------------------------------------------------------------
- # ● セカンドターゲット操作
- #--------------------------------------------------------------------------
- def second_targets_set
- targets = N03.get_targets(@action_data[1], @battler)
- for target in targets
- targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]
- targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs
- targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]
- targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs
- targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])
- targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)
- targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])
- targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])
- targets.delete(target) if !target.comparison_parameter(@action_data[6])
- targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
- end
- return @second_targets = [] if targets.size == 0
- case @action_data[8]
- when 1 ; targets = [targets[rand(targets.size)]]
- when 2 ; targets.delete(@battler)
- end
- return @second_targets = [] if targets.size == 0
- @second_targets = targets
- case @action_data[9]
- when 0 ; return
- when 1 ; set_play_data(["second_targets_set"])
- when 2 ; set_play_data(["targets_set"])
- end
- @wait += 1
- end
- #--------------------------------------------------------------------------
- # ● コモンイベント呼び出し
- #--------------------------------------------------------------------------
- def call_common_event
- $game_temp.reserve_common_event(@action_data[1])
- $sv_camera.event = true
- @event_fix = @action_data[2]
- end
- #--------------------------------------------------------------------------
- # ● ダメージアニメ
- #--------------------------------------------------------------------------
- def damage_anime(delay_time = 12)
- anime(N03.get_attack_anime_id(-3, @battler), wait = true)
- action_play
- @wait -= delay_time
- @full_action.unshift("eval('@damage_anime_data = []
- @set_damage = true')")
- end
- #--------------------------------------------------------------------------
- # ● 通常コラプス
- #--------------------------------------------------------------------------
- def normal_collapse
- @collapse = true
- return
- end
- #--------------------------------------------------------------------------
- # ● 初期位置変更
- #--------------------------------------------------------------------------
- def change_base_position
- @base_x = @x
- @base_y = @y
- @base_h = @h
- end
- #--------------------------------------------------------------------------
- # ● 強制アクション実行
- #--------------------------------------------------------------------------
- def force_act
- target(@full_action.shift)
- end
- #--------------------------------------------------------------------------
- # ● 強制アクション実行 (セカンドターゲット)
- #--------------------------------------------------------------------------
- def force_act2
- target2(@full_action.shift)
- end
- #--------------------------------------------------------------------------
- # ● 個別処理開始
- #--------------------------------------------------------------------------
- def individual_start
- @individual_targets = @target_battler.dup
- @remain_targets = @target_battler.dup
- @target_battler = [@individual_targets[0]]
- # リピート部分のアクションを保持
- @individual_act = @full_action.dup
- end
- #--------------------------------------------------------------------------
- # ● 個別処理終了
- #--------------------------------------------------------------------------
- def individual_end
- @individual_targets.shift
- for target in @individual_targets
- @individual_targets.shift if target.dead?
- end
- # ターゲットが残っているなら行動リピート
- return @target_battler = @remain_targets if @individual_targets.size == 0
- @full_action = @individual_act.dup
- @target_battler = [@individual_targets[0]]
- end
- #--------------------------------------------------------------------------
- # ● ループ開始
- #--------------------------------------------------------------------------
- def loop_start
- # ループ部分のアクションを保持
- @loop_act = @full_action.dup
- end
- #--------------------------------------------------------------------------
- # ● ループ終了
- #--------------------------------------------------------------------------
- def loop_end
- # 行動リピート
- @full_action = @loop_act.dup if @loop_act != []
- end
- #--------------------------------------------------------------------------
- # ● 次の行動者へ移行
- #--------------------------------------------------------------------------
- def next_battler
- @action_end = true
- @active = false
- end
- #--------------------------------------------------------------------------
- # ● 画像変更フラグ
- #--------------------------------------------------------------------------
- def set_change
- @change_up = true
- end
- #--------------------------------------------------------------------------
- # ● 戦闘シーン通信
- #--------------------------------------------------------------------------
- def play_data
- data = @play_data
- @play_data = []
- return data
- end
- #--------------------------------------------------------------------------
- # ● ショートカットコマンド
- #--------------------------------------------------------------------------
- def anime(anime_id, wait = true)
- @action_data = ["anime",anime_id,1,false,wait,false,true,false]
- end
- def anime_me(anime_id, wait = true)
- @action_data = ["anime",anime_id,0,false,wait,false,true,false]
- end
- def se(file, pitch = 100)
- @action_data = ["sound", "se", pitch, 100, file]
- end
- def target(act)
- for target in @target_battler do target.sv.force_action = act end
- end
- def target2(act)
- for target in @second_targets do target.sv.force_action = act end
- end
- def delay(time)
- @wait = @battler.index * time
- end
- #--------------------------------------------------------------------------
- # ● バトラーのIDを取得
- #--------------------------------------------------------------------------
- def id
- return @battler.id if @battler.actor?
- return [email]-@battler.id[/email]
- end
- #--------------------------------------------------------------------------
- # ● 被クリティカルフラグを取得
- #--------------------------------------------------------------------------
- def critical?
- return @battler.result.critical
- end
- #--------------------------------------------------------------------------
- # ● 被回復フラグを取得
- #--------------------------------------------------------------------------
- def recovery?
- recovery = false
- recovery = true if @battler.result.hp_damage < 0
- recovery = true if @battler.result.mp_damage < 0
- recovery = true if @battler.result.tp_damage < 0
- return recovery
- end
- #--------------------------------------------------------------------------
- # ● 被スキルIDを取得
- #--------------------------------------------------------------------------
- def damage_skill_id
- return @damage_skill_id
- end
- #--------------------------------------------------------------------------
- # ● 被アイテムIDを取得
- #--------------------------------------------------------------------------
- def damage_item_id
- return @damage_item_id
- end
- #--------------------------------------------------------------------------
- # ● 装備武器を取得
- #--------------------------------------------------------------------------
- def weapon_id
- return 0 if !@battler.weapons[0]
- return @battler.weapons[0].id
- end
- #--------------------------------------------------------------------------
- # ● 装備武器のタイプを取得
- #--------------------------------------------------------------------------
- def weapon_type
- return 0 if !@battler.weapons[0]
- return @battler.weapons[0].wtype_id
- end
- #--------------------------------------------------------------------------
- # ● 盾を装備しているか
- #--------------------------------------------------------------------------
- def shield?
- for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
- return false
- end
- #--------------------------------------------------------------------------
- # ● ダメージがあるか
- #--------------------------------------------------------------------------
- def damage_zero?
- return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0
- end
- #--------------------------------------------------------------------------
- # ● スキルIDを取得
- #--------------------------------------------------------------------------
- def skill_id
- return @counter_id if @counter_id != 0
- return 0 if @battler.current_action == nil or @battler.current_action.item == nil
- return 0 if @battler.current_action.item.is_a?(RPG::Item)
- return @battler.current_action.item.id
- end
- #--------------------------------------------------------------------------
- # ● スキルのタイプを取得
- #--------------------------------------------------------------------------
- def skill_type
- return 0 if skill_id == 0
- return $data_skills[skill_id].stype_id
- end
- #--------------------------------------------------------------------------
- # ● スキル名を取得
- #--------------------------------------------------------------------------
- def skill_name
- return "" if skill_id == 0
- return $data_skills[skill_id].name
- end
- #--------------------------------------------------------------------------
- # ● アイテムIDを取得
- #--------------------------------------------------------------------------
- def item_id
- return 0 if @battler.current_action == nil or @battler.current_action.item == nil
- return @battler.current_action.item.id
- end
- #--------------------------------------------------------------------------
- # ● 攻撃アクション
- #--------------------------------------------------------------------------
- def attack_action(item)
- return skill_action if item.is_a?(RPG::Skill)
- return item_action
- end
- #--------------------------------------------------------------------------
- # ● ダメージアクションベース
- #--------------------------------------------------------------------------
- def damage_action_base(item)
- @damage_skill_id = 0
- @damage_item_id = 0
- @damage_skill_id = item.id if item.is_a?(RPG::Skill)
- @damage_item_id = item.id if item.is_a?(RPG::Item)
- end
- #--------------------------------------------------------------------------
- # ● ダメージアクション
- #--------------------------------------------------------------------------
- def damage_action(attacker, item)
- damage_action_base(item)
- act = damage(attacker)
- return if @active
- start_action(act) if act != nil
- end
- #--------------------------------------------------------------------------
- # ● 回避アクション
- #--------------------------------------------------------------------------
- def evasion_action(attacker, item)
- damage_action_base(item)
- act = evasion(attacker)
- return if @active
- start_action(act) if act != nil
- end
- #--------------------------------------------------------------------------
- # ● ミスアクション
- #--------------------------------------------------------------------------
- def miss_action(attacker, item)
- damage_action_base(item)
- act = miss(attacker)
- return if @active
- start_action(act) if act != nil
- end
- #--------------------------------------------------------------------------
- # ● 閃きスクリプト併用処理
- #--------------------------------------------------------------------------
- def flash_action
- return "閃き"
- end
-
- end
-
- #==============================================================================
- # ■ module N03
- #------------------------------------------------------------------------------
- # サイドビューバトルのモジュールです。
- #==============================================================================
- module N03
- #--------------------------------------------------------------------------
- # ● バトラーの敵グループを取得
- #--------------------------------------------------------------------------
- def self.get_enemy_unit(battler)
- return $game_troop if battler.actor?
- return $game_party
- end
- #--------------------------------------------------------------------------
- # ● バトラーの味方グループを取得
- #--------------------------------------------------------------------------
- def self.get_party_unit(battler)
- return $game_party if battler.actor?
- return $game_troop
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメ時間の取得
- #--------------------------------------------------------------------------
- def self.get_anime_time(anime_id)
- return 0 if anime_id <= 0
- return $data_animations[anime_id].frame_max * 4
- end
- #--------------------------------------------------------------------------
- # ● 攻撃アニメの取得
- #--------------------------------------------------------------------------
- def self.get_attack_anime_id(kind, battler)
- return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0
- case kind
- when -1 ; anime_id = battler.atk_animation_id1
- when -2 ; anime_id = battler.atk_animation_id2
- when -3
- if battler.current_action != nil
- anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil
- end
- else ; anime_id = kind
- end
- case anime_id
- when -1 ; anime_id = battler.atk_animation_id1
- when -2 ; anime_id = battler.atk_animation_id2
- end
- return anime_id if anime_id
- return 0
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメデータをセット
- #--------------------------------------------------------------------------
- def self.set_damage_anime_data(targets, target, data)
- return if !first_of_all_screen_anime(data[0], target, targets)
- target.animation_id = data[0]
- target.animation_mirror = data[1]
- target.sv.anime_no_mirror = data[2]
- target.sv.anime_camera_zoom = data[3]
- target.sv.anime_plus_z = data[4]
- end
- #--------------------------------------------------------------------------
- # ● ターゲットの取得
- #--------------------------------------------------------------------------
- def self.get_targets(kind, battler)
- case kind.abs
- when 0 ; return [battler].dup
- when 1 ; return battler.sv.target_battler.dup
- when 2 ; return get_enemy_unit(battler).members.dup
- when 3 ; return get_party_unit(battler).members.dup
- when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup
- when 5 ; return battler.sv.second_targets.dup
- end
- end
- #--------------------------------------------------------------------------
- # ● ターゲットの座標を取得
- #--------------------------------------------------------------------------
- def self.get_targets_position(targets, horming, m_a = nil)
- return [0,0,0] if targets == nil && !$sv_camera.mirror
- return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
- x = y = h = 0
- for i in 0...targets.size
- x += targets[i].sv.base_x if !horming
- y += targets[i].sv.base_y if !horming
- h += targets[i].sv.base_h if !horming
- x += targets[i].sv.x if horming
- y += targets[i].sv.y if horming
- h += targets[i].sv.h if horming
- y -= targets[i].sv.ch * 100 if m_a == 0
- y -= targets[i].sv.ch * 50 if m_a == 1
- end
- return [x / targets.size, y / targets.size, h / targets.size]
- end
- #--------------------------------------------------------------------------
- # ● 速度を時間に変換
- #--------------------------------------------------------------------------
- def self.distanse_calculation(time, target_position, self_position, distanse_move)
- return time if !distanse_move
- distanse_x = self_position[0] - target_position[0]
- distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]
- distanse_y = self_position[1] - target_position[1]
- distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]
- if self_position[2] != nil && target_position[2] != nil
- distanse_h = self_position[2] - target_position[2]
- distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]
- else
- distanse_h = 0
- end
- distanse = [distanse_x, distanse_y, distanse_h].max
- return distanse / (time * 100) + 1
- end
- #--------------------------------------------------------------------------
- # ● 放物線移動計算
- #--------------------------------------------------------------------------
- def self.parabola(data, time, size, type = 1)
- move_data = data
- move_data[0] *= size
- move_data[1] *= size
- move = []
- move_d = []
- for i in 0...time / 2
- move[i] = move_data[0]
- move_d[i] = move_data[1]
- move_data[0] = move_data[0] * type / (1 + type)
- move_data[1] = move_data[1] * type / (1 + type)
- end
- move = move + move_d.reverse!
- move.reverse!
- adjust = move.inject(0) {|result, item| result + item }
- move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0
- move.unshift(0) if time % 2 != 0
- return move
- end
- #--------------------------------------------------------------------------
- # ● 反転値
- #--------------------------------------------------------------------------
- def self.mirror_num(mirror)
- return 1 if !mirror
- return -1
- end
- #--------------------------------------------------------------------------
- # ● カメラワーク
- #--------------------------------------------------------------------------
- def self.camera(battler, data)
- battler = $game_party.battle_members[0] if !battler
- cx = data[2][0] * 100
- cy = data[2][1] * 100
- return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6
- targets = self.get_targets(data[1], battler)
- return if targets == nil or targets == []
- position = self.get_targets_position(targets, true)
- $sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
- end
- #--------------------------------------------------------------------------
- # ● コラプス禁止
- #--------------------------------------------------------------------------
- def self.immortaling
- # 全員に不死身付与
- for member in $game_party.battle_members + $game_troop.members
- # イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる
- member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
- member.add_state(N03::IMMORTAL_ID)
- end
- return true
- end
- #--------------------------------------------------------------------------
- # ● コラプス許可
- #--------------------------------------------------------------------------
- def self.unimmortaling
- # 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
- for member in $game_party.battle_members + $game_troop.members
- next if member.dead?
- # 不死身ステートが行動中に解除されていた場合、解除無効を解除
- member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
- next member.sv.immortal = false if member.sv.immortal
- member.remove_state(N03::IMMORTAL_ID)
- next if member.hp != 0
- member.add_state(1)
- member.perform_collapse_effect
- member.sv.action_terminate
- end
- return false
- end
- #--------------------------------------------------------------------------
- # ● スキル派生
- #--------------------------------------------------------------------------
- def self.derived_skill(battler)
- battler.force_action(battler.sv.derivation_skill_id, -2)
- BattleManager.unshift_action_battlers(battler)
- end
- #--------------------------------------------------------------------------
- # ● ダメージの作成
- #--------------------------------------------------------------------------
- def self.set_damage(battler, hp_damage, mp_damage)
- battler.result.hp_damage = hp_damage
- battler.result.mp_damage = mp_damage
- end
- #--------------------------------------------------------------------------
- # ● ターゲット生死確認
- #--------------------------------------------------------------------------
- def self.targets_alive?(targets)
- return false if targets == []
- for target in targets do return true if !target.dead? end
- return false
- end
- #--------------------------------------------------------------------------
- # ● ターゲットをセカンドターゲットへ
- #--------------------------------------------------------------------------
- def self.s_targets(battler)
- battler.sv.target_battler = battler.sv.second_targets
- return battler.sv.second_targets
- end
- #--------------------------------------------------------------------------
- # ● セカンドターゲットをターゲットへ
- #--------------------------------------------------------------------------
- def self.targets_set(battler)
- battler.sv.second_targets = battler.current_action.make_targets.compact
- battler.sv.target_battler = battler.sv.second_targets
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメ実行判定 (対象:画面時は最初のターゲットのみアニメ実行)
- #--------------------------------------------------------------------------
- def self.first_of_all_screen_anime(anime_id, target, targets)
- anime = $data_animations[anime_id]
- return false if !anime
- return true if anime.position != 3
- return false if anime.position == 3 && target != targets[0]
- targets.delete(target)
- target.sv.timing_targets = targets
- return true
- end
- #--------------------------------------------------------------------------
- # ● 戦闘不能付加攻撃か
- #--------------------------------------------------------------------------
- def self.dead_attack?(battler, item)
- for state in battler.atk_states
- return true if state == battler.death_state_id
- end
- for effect in item.effects
- return true if effect.code == 21 && effect.data_id == battler.death_state_id
- end
- return false
- end
- end
- #==============================================================================
- # ■ Sprite_Weapon
- #------------------------------------------------------------------------------
- # ウエポン表示用のスプライトです。
- #==============================================================================
- class Sprite_Weapon < Sprite_Base
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_reader :index # ウエポン画像配列のインデックス
- attr_reader :battler # 画像が参照しているバトラー
- attr_reader :move_time # 画像が目標に到達するまでの時間
- attr_reader :through # 貫通フラグ
- attr_reader :action_end # 武器アクション終了フラグ
- attr_reader :action_end_cancel # 武器アクション終了フラグ
- attr_reader :hit_position # 画像が目標に到達した時の座標
- attr_accessor :hit_anime_id # 画像が目標に到達した時のアニメID
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(viewport, index, battler)
- super(viewport)
- @index = index
- @battler = battler
- @position_x = @position_y = 0
- @o = 0
- @real_x = @real_y = 0
- @mirror = @battler.sv.mirror
- reset
- set_action
- end
- #--------------------------------------------------------------------------
- # ● 初期化
- #--------------------------------------------------------------------------
- def reset
- @z_plus = 0
- @weapon_data = []
- @move_data = []
- @move_x = 0
- @move_y = 0
- @orbit = []
- @through = false
- @distanse_move = false
- @weapon_width = 0
- @weapon_height = 0
- @anime_time = 0
- @anime_position = 1
- @move_time = 0
- @hit_anime_id = 0
- @move_anime = true
- @action_end = false
- @action_end_cancel = false
- reset_position
- end
- #--------------------------------------------------------------------------
- # ● アクションをセット
- #--------------------------------------------------------------------------
- def set_action
- return if @battler.sv.effect_data == []
- weapon_anime if @battler.sv.effect_data[0][0] == "wp"
- move_anime if @battler.sv.effect_data[0][0] == "m_a"
- @battler.sv.effect_data.shift
- end
- #--------------------------------------------------------------------------
- # ● 武器アニメ実行
- #--------------------------------------------------------------------------
- def weapon_anime
- @weapon_data = @battler.sv.effect_data[0].dup
- set_graphics
- set_ox
- set_weapon_move
- end
- #--------------------------------------------------------------------------
- # ● アニメ移動実行
- #--------------------------------------------------------------------------
- def move_anime
- @move_data = @battler.sv.effect_data[0].dup
- # ターゲットを取得
- @target_battler = [@battler.sv.m_a_targets.shift]
- @target_battler = N03.get_targets(@move_data[3], @battler) if @move_data[3] < 0
- set_move
- return if @move_data[16] == ""
- weapon_data = N03::ACTION[@move_data[16]]
- return if weapon_data == nil
- @weapon_data = weapon_data.dup
- set_graphics
- set_ox
- set_weapon_move
- end
- #--------------------------------------------------------------------------
- # ● 武器画像を取得
- #--------------------------------------------------------------------------
- def set_graphics
- # 武器に依存しない画像設定がある場合
- if @weapon_data[13] != ""
- self.bitmap = Cache.character(@weapon_data[13]).dup
- @weapon_width = self.bitmap.width
- @weapon_height = self.bitmap.height
- return
- end
- # 武器を取得
- weapon = @battler.weapons[0]
- # 逆手装備を取得
- if @weapon_data[10]
- weapon = nil
- for armor in @battler.armors do break weapon = armor if armor.is_a?(RPG::Armor) && armor.etype_id == 1 end
- weapon = @battler.weapons[1] if !weapon
- end
- # 武器がなければ処理をキャンセル
- return if weapon == nil
- # インデックスを取得
- file_index = @weapon_data[12]
- # アイコンを利用するなら
- if @weapon_data[1] == 0
- icon_index = weapon.icon_index
- self.bitmap = Cache.system("Iconset" + file_index).dup
- self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
- @weapon_width = @weapon_height = 24
- # 独自画像指定
- else
- file_name = @battler.sv.weapon_graphic(weapon.id, weapon.wtype_id) if weapon.is_a?(RPG::Weapon)
- file_name = @battler.sv.shield_graphic(weapon.id, weapon.atype_id) if weapon.is_a?(RPG::Armor)
- self.bitmap = Cache.character(file_name + file_index).dup
- @weapon_width = self.bitmap.width
- @weapon_height = self.bitmap.height
- return if @weapon_data[1] == 1
- # 2003仕様の武器アニメ
- @weapon_width /= @battler.sv.max_pattern[0]
- end
- end
- #--------------------------------------------------------------------------
- # ● 画像の原点を取得
- #--------------------------------------------------------------------------
- def set_ox
- # 反転時は設定を逆に
- if @mirror
- case @weapon_data[6]
- when 1 ; @weapon_data[6] = 2 # 左上→右上に
- when 2 ; @weapon_data[6] = 1 # 右上→左上に
- when 3 ; @weapon_data[6] = 4 # 左下→右下に
- when 4 ; @weapon_data[6] = 3 # 右下→左下に
- end
- end
- # 原点を設定
- case @weapon_data[6]
- 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
- when 5 # バトラーと同じ
- self.ox = @weapon_width / 2
- self.oy = @weapon_height
- end
- end
- #--------------------------------------------------------------------------
- # ● バトラーの座標を取得
- #--------------------------------------------------------------------------
- def set_battler_position
- @position_x = @battler.sv.x + @weapon_data[3][0] * N03.mirror_num(@mirror) * 100
- @position_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust) + @weapon_data[3][1] * 100
- reset_position
- end
- #--------------------------------------------------------------------------
- # ● 座標を初期化
- #--------------------------------------------------------------------------
- def reset_position
- @real_x = @position_x / 100
- @real_y = @position_y / 100
- @real_zoom_x = 1
- @real_zoom_y = 1
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメを表示
- #--------------------------------------------------------------------------
- def set_animation(anime_id)
- return if $data_animations[anime_id] == nil
- @anime_position = $data_animations[anime_id].position
- @horming = true
- @horming = false if @anime_position == 3
- @anime_camera_zoom = true
- @anime_no_mirror = false
- start_animation($data_animations[anime_id], @mirror)
- timings = $data_animations[anime_id].timings
- end
- #--------------------------------------------------------------------------
- # ● ヒット時の戦闘アニメ実行
- #--------------------------------------------------------------------------
- def set_hit_animation(position_data, hit_anime_id, target)
- return if $data_animations[hit_anime_id] == nil
- @real_x = position_data[0]
- @real_y = position_data[1]
- @position_x = position_data[0] * 100
- @position_y = position_data[1] * 100
- self.z = position_data[2]
- @z_plus = 1000
- @action_end = false
- @horming = true
- set_animation(hit_anime_id)
- @anime_time = $data_animations[hit_anime_id].frame_max * 4
- @timing_targets = [target]
- @move_time = @hit_anime_id = 0
- @weapon_data = []
- end
- #--------------------------------------------------------------------------
- # ● タイミングバトラー追加
- #--------------------------------------------------------------------------
- def timing_battler_set(target)
- @timing_targets.push(target)
- end
- #--------------------------------------------------------------------------
- # ● 武器の動きを取得
- #--------------------------------------------------------------------------
- def set_weapon_move
- # 開始位置を取得
- set_battler_position if @move_time == 0
- @z_plus = 50 if @z_plus == 0 && @weapon_data[9]
- self.z = @battler.sv.z + @z_plus
- # 反転処理
- @mirror = !@mirror if @weapon_data[7]
- self.mirror = @mirror
- # 更新パターンをセット
- set_pattern
- @max_pattern = 2 if @max_pattern == 1
- # 動きを計算
- @weapon_move_data = []
- @weapon_angle_data = []
- @weapon_zoom_data = []
- num = N03.mirror_num(@mirror)
- for i in 0...@max_pattern
- move_data_x = @weapon_data[2][0] * num * 100 * i / (@max_pattern - 1)
- move_data_y = @weapon_data[2][1] * 100 * i / (@max_pattern - 1)
- move_angle = @weapon_data[4] * num + (@weapon_data[5] * num - @weapon_data[4] * num) * i / (@max_pattern - 1)
- move_zoom_x = 1 + (@weapon_data[8][0] - 1) * i / (@max_pattern - 1)
- move_zoom_y = 1 + (@weapon_data[8][1] - 1) * i / (@max_pattern - 1)
- @weapon_move_data.push([move_data_x, move_data_y])
- @weapon_angle_data.push(move_angle)
- @weapon_zoom_data.push([move_zoom_x, move_zoom_y])
- end
- end
- #--------------------------------------------------------------------------
- # ● 更新パターン
- #--------------------------------------------------------------------------
- def set_pattern
- if @weapon_data[11] == -1
- return @max_pattern = @battler.sv.max_pattern[0] if @battler.sv.pattern_type != 0
- @count = @battler.sv.pattern_time
- @max_count = @battler.sv.pattern_time
- @max_pattern = @battler.sv.max_pattern[0]
- @repeat = false
- else
- @count = @weapon_data[11][0]
- @max_count = @weapon_data[11][0]
- @max_pattern = @weapon_data[11][1]
- @repeat = @weapon_data[11][2]
- end
- @pattern = 0
- end
- #--------------------------------------------------------------------------
- # ● 移動実行
- #--------------------------------------------------------------------------
- def set_move
- # 戦闘アニメを取得
- set_animation(@move_data[1][0]) if $data_animations[@move_data[1][0]] != nil && $data_animations[@move_data[1][0]].position != 3
- @anime_camera_zoom = @move_data[13]
- @loop = @move_data[14]
- @loop = false if @move_data[1][0] == 0
- @anime_no_mirror = @move_data[15]
- @se_flag = @move_data[17]
- # 開始位置を取得
- start_position
- @z_plus = 1000 if @move_data[9]
- # ターゲットバトラー画像にこのアニメのSEとタイミング設定を反映させる
- @timing_targets = @target_battler
- # 座標計算
- @move_x = @move_data[5][0] * 100 * N03.mirror_num(@mirror)
- @move_y = @move_data[5][1] * 100
- # 時間計算か速度計算か
- @distanse_move = true if @move_data[6] > 0
- @move_time = @move_data[6].abs
- # 時間0の場合、アニメが設定されていればアニメ表示時間に合わせる
- if @move_time == 0
- @move_time = $data_animations[@move_data[1][0]].frame_max * 4 if $data_animations[@move_data[1][0]]
- @move_time = 1 if !$data_animations[@move_data[1][0]]
- @distanse_move = false
- end
- # 貫通タイプの場合
- @through = true if @move_data[7] == 1
- @auto_through_flag = false
- @auto_through_flag = true if @move_data[7] == 0
- # ターゲット座標計算
- if @target_battler == nil
- @target_x = @move_x * 100
- @target_x = (Graphics.width - @move_x) * 100 if @mirror
- @target_y = @move_y * 100
- else
- move_data_set
- end
- # ターゲットに到達するまでの時間を計算
- @move_time = distanse_calculation(@move_time, @target_x, @target_y)
- # 円軌道計算
- orbit
- # バトラーのウエイト設定
- @battler.sv.wait = @move_time - 1 if @move_data[10][0]
- @move_horming = @move_data[12]
- end
- #--------------------------------------------------------------------------
- # ● 速度を時間に変換
- #--------------------------------------------------------------------------
- def distanse_calculation(time, target_x, target_y)
- return time if !@distanse_move
- distanse_x = @position_x - @target_x
- distanse_x = @target_x - @position_x if @target_x > @position_x
- distanse_y = @position_y - @target_y
- distanse_y = @target_y - @position_y if @target_y > @position_y
- distanse = [distanse_x, distanse_y].max
- return distanse / (time * 100) + 1
- end
- #--------------------------------------------------------------------------
- # ● 移動目標の更新
- #--------------------------------------------------------------------------
- def move_data_set
- return if @target_battler == nil
- position = N03.get_targets_position(@target_battler, true, @anime_position)
- @target_x = position[0] + @move_x
- @target_y = position[1] - position[2] + @move_y
- end
- #--------------------------------------------------------------------------
- # ● 開始位置を計算
- #--------------------------------------------------------------------------
- def start_position
- starter = [@battler.sv.m_a_starter.shift]
- starter = N03.get_targets(@move_data[2], @battler) if @move_data[2] < 0
- position = [0, 0]
- position = N03.get_targets_position(starter, true, @anime_position) if starter != nil
- @position_x = position[0] + @move_data[4][0] * 100
- @position_y = position[1] + position[2] + @move_data[4][1] * 100
- @position_z = @position_y
- end
- #--------------------------------------------------------------------------
- # ● 円軌道計算
- #--------------------------------------------------------------------------
- def orbit
- orbit_data = @move_data[8].dup
- orbit_data[0] *= 100
- orbit_data[1] *= 100
- orbit_d = []
- for i in 0...@move_time / 2
- @orbit[i] = orbit_data[0]
- orbit_data[0] /= 2
- orbit_d[i] = orbit_data[1]
- orbit_data[1] /= 2
- end
- @orbit = @orbit + orbit_d.reverse!
- @orbit.reverse!
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- update_hit_anime if @anime_time != 0
- update_move if @move_time != 0
- update_weapon_move if @weapon_data != []
- update_position
- update_color
- self.visible = @battler.sv.weapon_visible
- super
- end
- #--------------------------------------------------------------------------
- # ● ヒット時の戦闘アニメ
- #--------------------------------------------------------------------------
- def update_hit_anime
- @anime_time -= 1
- @action_end = true if @anime_time == 0
- end
- #--------------------------------------------------------------------------
- # ● 移動の更新
- #--------------------------------------------------------------------------
- def update_move
- move_data_set if @move_horming && !@hit_position
- through_set(@move_time, @target_x, @target_y) if @move_time == 1 && !@hit_position
- @o += @orbit[@move_time - 1] if @orbit[@move_time - 1] != nil
- @position_x = (@position_x * (@move_time - 1) + @target_x) / @move_time
- @position_y = (@position_y * (@move_time - 1) + @target_y) / @move_time + @o
- reset_position
- set_animation(@move_data[1][0]) if @loop && !animation?
- @move_time -= 1
- return if @move_time != 0
- @action_end = true if !@action_end_cancel
- end
- #--------------------------------------------------------------------------
- # ● 武器の動きを更新
- #--------------------------------------------------------------------------
- def update_weapon_move
- pattern = update_pattern
- set_battler_position if @move_time == 0 && !@action_end_cancel
- @real_x = @position_x / 100 + @weapon_move_data[pattern][0] / 100
- @real_y = @position_y / 100 + @weapon_move_data[pattern][1] / 100
- @real_zoom_x = @weapon_zoom_data[pattern][0]
- @real_zoom_y = @weapon_zoom_data[pattern][1]
- self.angle = @weapon_angle_data[pattern]
- self.src_rect.set(@weapon_width * pattern, 0, @weapon_width, @weapon_height) if @weapon_data[1] == 2
- end
- #--------------------------------------------------------------------------
- # ● パターンを更新
- #--------------------------------------------------------------------------
- def update_pattern
- return @battler.sv.pattern_w if @count == nil
- @count -= 1
- return @pattern if @count != 0
- @count = @max_count
- @pattern += 1
- if !@repeat && @pattern == @max_pattern
- @pattern = @max_pattern - 1
- elsif @pattern == @max_pattern
- @pattern = 0
- end
- return @pattern
- end
- #--------------------------------------------------------------------------
- # ● 座標を更新
- #--------------------------------------------------------------------------
- def update_position
- self.x = (@real_x - $sv_camera.x) * $sv_camera.convert / 1000
- self.y = (@real_y - $sv_camera.y) * $sv_camera.convert / 1000
- self.x += $sv_camera.sx / 100 unless @battler.sv.h != 0 && @weapon_data != []
- self.y += $sv_camera.sy / 100 unless @battler.sv.h != 0 && @weapon_data != []
- self.z = @battler.sv.z + @z_plus - 10
- self.zoom_x = @real_zoom_x * $sv_camera.zoom
- self.zoom_y = @real_zoom_y * $sv_camera.zoom
- self.opacity = @battler.sv.opacity if @battler.sv.opacity_data[4]
- end
- #--------------------------------------------------------------------------
- # ● 貫通の処理
- #--------------------------------------------------------------------------
- def through_set(time, target_x, target_y)
- @hit_anime_id = N03.get_attack_anime_id(@move_data[1][1], @battler)
- @battler.sv.wait = N03.get_anime_time(@hit_anime_id) if @move_data[10][1]
- moving_x = (target_x / 100 - @position_x / 100) / time
- moving_y = (target_y / 100 - @position_y / 100) / time
- goal_x = $sv_camera.max_left - 100 if moving_x < 0
- goal_x = Graphics.width + $sv_camera.max_right + 100 if moving_x > 0
- goal_y = $sv_camera.max_top - 100 if moving_y < 0
- goal_y = Graphics.height + $sv_camera.max_bottom + 100 if moving_y > 0
- if goal_x == nil && goal_y == nil
- time = 0
- reset_position
- else
- time = move_calculation(moving_x, moving_y, goal_x, goal_y)
- end
- target_x = @position_x + moving_x * time * 100
- target_y = @position_y + moving_y * time * 100
- @pre_data = [time, target_x, target_y]
- @battler.sv.m_a_data.push([@move_data[11], @target_battler, @index, @auto_through_flag, []])
- @action_end_cancel = true
- @hit_position = [@real_x, @real_y, self.z]
- end
- #--------------------------------------------------------------------------
- # ● 到達時間試算
- #--------------------------------------------------------------------------
- def move_calculation(moving_x, moving_y, goal_x, goal_y)
- move_x = @position_x / 100
- move_y = @position_y / 100
- time = 0
- loop do
- move_x += moving_x
- move_y += moving_y
- time += 1
- return time if moving_x < 0 && move_x < goal_x
- return time if moving_x > 0 && move_x > goal_x
- return time if moving_y < 0 && move_y < goal_y
- return time if moving_y > 0 && move_y > goal_y
- end
- end
- #--------------------------------------------------------------------------
- # ● ミス時に消える処理から貫通処理に変換
- #--------------------------------------------------------------------------
- def through_change
- @action_end_cancel = false
- @through = true
- @move_time = @pre_data[0]
- @target_x = @pre_data[1]
- @target_y = @pre_data[2]
- @pre_data = nil
- end
- #--------------------------------------------------------------------------
- # ● SE とフラッシュのタイミング処理
- #--------------------------------------------------------------------------
- def animation_process_timing(timing)
- return if !@timing_targets
- se_flag = true
- se_flag = @se_flag if @se_flag != nil
- for target in @timing_targets
- target.sv.timing.push([se_flag, timing.dup])
- se_flag = false if @animation.position == 3
- end
- end
- #--------------------------------------------------------------------------
- # ● 色調の更新
- #--------------------------------------------------------------------------
- def update_color
- return if @battler.sv.color == []
- self.color.set(@battler.sv.color[0], @battler.sv.color[1], @battler.sv.color[2], @battler.sv.color[3])
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- def dispose
- super
- self.bitmap.dispose if self.bitmap != nil
- end
- end
- #==============================================================================
- # ■ Sprite_Battle_Picture
- #------------------------------------------------------------------------------
- # ピクチャ表示用のスプライトです。
- #==============================================================================
- class Sprite_Battle_Picture < Sprite
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_accessor :action_end # 終了フラグ
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(viewport = nil)
- super(viewport)
- @action_end = false
- self.ox = 0
- end
- #--------------------------------------------------------------------------
- # ● セット
- #--------------------------------------------------------------------------
- def set(battler)
- @battler = battler
- @data = @battler.sv.effect_data.shift
- @time = @data[4]
- @mirror = $sv_camera.mirror
- @mirror = false if !@data[8]
- self.opacity = @data[6][0]
- @s_x = @data[2][0] if @data[2] != []
- @s_x = Graphics.width - @data[2][0] if @data[2] != [] && @mirror
- @s_y = @data[2][1] if @data[2] != []
- @e_x = @data[3][0] if @data[3] != []
- @e_x = Graphics.width - @data[3][0] if @data[3] != [] && @mirror
- @e_y = @data[3][1] if @data[3] != []
- @s_x = self.x if @data[2] == []
- @s_y = self.y if @data[2] == []
- @e_x = self.x if @data[3] == []
- @e_y = self.y if @data[3] == []
- self.x = @s_x
- self.y = @s_y
- return @action_end = true if @time == 0
- @move_x = (@e_x * 1.0 - @s_x) / @time
- @move_y = (@e_y * 1.0 - @s_y) / @time
- self.z = @data[5]
- return set_plane(battler) if @data[7] != []
- self.bitmap = Cache.picture(@data[9]) if !bitmap or @data[9] != ""
- return @action_end = true if !bitmap
- self.mirror = @mirror
- self.ox = self.bitmap.width if @mirror
- end
- #--------------------------------------------------------------------------
- # ● プレーン移行
- #--------------------------------------------------------------------------
- def set_plane(battler)
- @viewport = Viewport.new(@data[2][0],@data[2][1],@data[7][0],@data[7][1]) if !@viewport
- viewport = @viewport
- @plane = Plane.new(viewport) if !@plane
- @plane.bitmap = Cache.picture(@data[9]) if !@plane.bitmap or @data[9] != ""
- return @action_end = true if !@plane.bitmap
- @plane.ox = @data[7][0]
- @plane.oy = @data[7][1]
- @plane.opacity = @data[6][0]
- @move_x = @remain_move[0] if @data[2] == @data[3]
- @move_y = @remain_move[1] if @data[2] == @data[3]
- @remain_move = [@move_x, @move_y]
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- @action_end = true if !@battler.sv.picture
- return if @time == 0
- return if @action_end
- @time -= 1
- return plane_update if @plane
- super
- self.x += @move_x
- self.y += @move_y
- self.opacity += @data[6][1]
- return if @time != 1
- self.x = @e_x
- self.y = @e_y
- @time = 0
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def plane_update
- @plane.ox += @move_x
- @plane.oy += @move_y
- @plane.opacity += @data[6][1]
- @time = @data[4] if @time == 0
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- def dispose
- bitmap.dispose if bitmap
- @plane.dispose if @plane
- @viewport.dispose if @viewport
- super
- end
- end
- #==============================================================================
- # ■ Sprite_Back_Picture
- #------------------------------------------------------------------------------
- # 周期ピクチャ用のスプライトです。
- #==============================================================================
- class Sprite_Back_Picture < Plane
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_accessor :action_end # 終了フラグ
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(viewport = nil, index)
- super(viewport)
- @index = index
- @real_x = 0
- @real_y = 0
- @real_opacity = 0
- @move_x = 0
- @move_y = 0
- @move_opacity = 0
- @time = 0
- @switche = 0
- @action_end = false
- end
- #--------------------------------------------------------------------------
- # ● セットアップ
- #--------------------------------------------------------------------------
- def setup(data)
- self.bitmap = Cache.picture(data[9])
- self.z = data[6]
- @switche = data[1]
- mirror = $sv_camera.mirror
- mirror = false if !data[8]
- @move_x = data[3][0]
- @move_x *= -1 if mirror
- @move_y = data[3][1]
- @time = data[4]
- @time = -1 if @time == 0
- @real_opacity = (data[5][0] + 1) * 100
- @move_opacity = data[5][1]
- @start_opacity = data[5][0]
- @shake_ok = data[7]
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- update_picture if @time != 0
- self.ox = $sv_camera.x - @real_x
- self.oy = $sv_camera.y - @real_y
- if @shake_ok
- self.ox -= $sv_camera.sx / 100
- self.oy -= $sv_camera.sy / 100
- end
- self.ox *= $sv_camera.zoom
- self.oy *= $sv_camera.zoom
- self.zoom_x = @zoom_x * $sv_camera.zoom
- self.zoom_y = @zoom_y * $sv_camera.zoom
- self.opacity = @real_opacity / 100
- @move_opacity *= -1 if self.opacity == 255 or self.opacity <= @start_opacity
- @switche
- @action_end = true if @switche > 0 && !$game_switches[@switche]
- @action_end = true if @switche < 0 && !$sv_camera.switches[@switche.abs]
- end
- #--------------------------------------------------------------------------
- # ● ピクチャの更新
- #--------------------------------------------------------------------------
- def update_picture
- @real_x += @move_x / 100
- @real_y += @move_y / 100
- @real_x = 0 if @real_x >= self.bitmap.width or @real_x <= -self.bitmap.width
- @real_y = 0 if @real_y >= self.bitmap.height or @real_y <= -self.bitmap.height
- @zoom_x = 1
- @zoom_y = 1
- @real_opacity += @move_opacity
- @time -= 1
- @time = -1 if @time < -100
- end
- end
- #==============================================================================
- # ■ Sprite_Back_Picture
- #------------------------------------------------------------------------------
- # ダメージ表示のスプライトです。
- #==============================================================================
- class Sprite_Damage < Sprite
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_reader :action_end # POP終了フラグ
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(viewport = nil, battler)
- super(viewport)
- @battler = battler
- @time = 0
- return @action_end = true if !@battler
- @direction = -1
- @direction *= -1 if @battler.actor?
- @direction *= -1 if $sv_camera.mirror
- set_state
- set_damage
- update
- end
- #--------------------------------------------------------------------------
- # ● ステート表示
- #--------------------------------------------------------------------------
- def set_state
- return if !N03::STATE_POP
- states = @battler.result.added_state_objects
- states.delete($data_states[@battler.death_state_id]) if @battler.result.hp_damage != 0
- return if states == []
- return if @battler.sv.add_state == @battler.result.added_state_objects
- @battler.sv.add_state = states.dup
- @st = []
- @st_base = []
- for i in 0...states.size
- @st[i] = Sprite.new
- bitmap_state(@st[i], states[i])
- @st_base[i] = []
- @st_base[i][0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100
- @st_base[i][1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
- @st[i].z = 1000 + i
- @st[i].opacity = 0
- end
- @time = @pop_time = 80
- end
- #--------------------------------------------------------------------------
- # ● ステート画像
- #--------------------------------------------------------------------------
- def bitmap_state(state, state_object)
- name = state_object.name
- state.bitmap = Cache.system("Iconset").dup
- state.src_rect.set(state_object.icon_index % 16 * 24, state_object.icon_index / 16 * 24, 24, 24)
- @state_height = 24
- end
- #--------------------------------------------------------------------------
- # ● ダメージ表示
- #--------------------------------------------------------------------------
- def hit_count
- for i in [email]0...@battler.sv.hit.size[/email]
- if @battler.sv.hit[i] == nil
- @hit = i
- return @battler.sv.hit[i] = @hit
- end
- end
- @hit = @battler.sv.hit.size
- @battler.sv.hit.push(@hit)
- end
- #--------------------------------------------------------------------------
- # ● ダメージ表示
- #--------------------------------------------------------------------------
- def set_damage
- return @action_end = true if !N03::DAMAGE_POP
- damage = @battler.result.hp_damage if @battler.result.hp_damage != 0
- damage = @battler.result.hp_drain if @battler.result.hp_drain != 0
- damage = @battler.result.mp_damage if @battler.result.mp_damage != 0
- damage = @battler.result.mp_drain if @battler.result.mp_drain != 0
- damage = @battler.result.tp_damage if @battler.result.tp_damage != 0
- if !damage or damage == 0
- @action_end = true if @st == nil
- return # ステートだけPOPする設定を考慮して@action_endは返さない
- end
- hit_count
- #@hit = @battler.sv.hit
- #@battler.sv.hit += 1 if damage != 0
- file = N03::DAMAGE_PLUS if damage > 0
- file = N03::DAMAGE_MINUS if damage < 0
- add_file = N03::DAMAGE_MP if @battler.result.mp_damage != 0
- add_file = N03::DAMAGE_TP if @battler.result.tp_damage != 0
- adjust_x = N03::DAMAGE_ADJUST
- @num = []
- @num_base = []
- damage = damage.abs
- max_num = damage.to_s.size
- max_num += 1 if add_file != nil
- for i in 0...max_num
- @num[i] = Sprite.new
- if add_file != nil && i == max_num - 1
- @num[i].bitmap = Cache.system(add_file)
- cw = (damage % (10 * 10 ** i))/(10 ** i)
- sw = 0 if sw == nil
- else
- @num[i].bitmap = Cache.system(file)
- cw = (damage % (10 * 10 ** i))/(10 ** i)
- sw = @num[i].bitmap.width / 10
- @num[i].src_rect.set(cw * sw, 0, sw, @num[i].bitmap.height)
- end
- @num_base[i] = []
- @num_base[i][0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)
- @num_base[i][1] = -(@num[i].bitmap.height / 3) - i * 2 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
- @num_base[i][0] -= @num[i].bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1
- @num[i].z = 1000 + i + @hit * 10
- end
- @time = @pop_time = 80
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- return if @time == 0
- for i in [email]0...@st.size[/email] do update_state_move(@st[i], i) end if @st != nil
- for i in [email]0...@num.size[/email] do update_num_move(@num[i], i) end if @num != nil
- @time -= 1
- @action_end = true if @time == 0
- end
- #--------------------------------------------------------------------------
- # ● ステート画像の更新
- #--------------------------------------------------------------------------
- def update_state_move(state, index)
- min = @pop_time - index * 2
- case @time
- when min-15..min
- @st_base[index][0] += @direction
- state.opacity += 25
- when min-80..min-50
- @st_base[index][0] += @direction
- state.opacity -= 25
- end
- state.x = (@st_base[index][0] - $sv_camera.x) * $sv_camera.zoom
- state.y = (@st_base[index][1] - $sv_camera.y) * $sv_camera.zoom
- end
- #--------------------------------------------------------------------------
- # ● 数値の更新
- #--------------------------------------------------------------------------
- def update_num_move(num, index)
- min = @pop_time - index * 2
- case @time
- when min-1..min
- @num_base[index][0] += @direction * @hit
- @num_base[index][1] -= 5 + @hit * 2
- when min-3..min-2
- @num_base[index][0] += @direction * @hit
- @num_base[index][1] -= 4 + @hit * 2
- when min-6..min-4
- @num_base[index][0] += @direction
- @num_base[index][1] -= 3 + @hit * 2
- when min-14..min-7
- @num_base[index][0] += @direction
- @num_base[index][1] += 2
- when min-17..min-15
- @num_base[index][1] -= 2 + @hit * 2
- when min-23..min-18
- @num_base[index][1] += 1
- when min-27..min-24
- @num_base[index][1] -= 1
- when min-30..min-28
- @num_base[index][1] += 1
- when min-33..min-31
- @num_base[index][1] -= 1
- when min-36..min-34
- @num_base[index][1] += 1
- end
- num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom
- num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom
- num.opacity = 256 - (12 - @time) * 32
- num.visible = false if @time == 0
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- def dispose
- @battler.sv.hit[@hit] = nil if @hit
- bitmap.dispose if bitmap
- for i in [email]0...@num.size[/email] do @num[i].dispose end if @num != nil
- for i in [email]0...@st.size[/email] do @st[i].dispose end if @st != nil
- super
- end
- end
- #==============================================================================
- # ■ Window_Skill_name
- #------------------------------------------------------------------------------
- # スキル名を表示するウィンドウです。
- #==============================================================================
- class Window_Skill_name < Window_Base
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(text)
- super(0, 0, Graphics.width, line_height + standard_padding * 2)
- draw_text(4, 0, Graphics.width - 64, line_height,text, 1)
- end
- end
- #==============================================================================
- # ■ Spriteset_Sideview
- #------------------------------------------------------------------------------
- # サイドビュー独自のスプライトをまとめたクラスです。
- #==============================================================================
- class Spriteset_Sideview
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(viewport)
- @viewport = viewport
- @weapons = []
- @pictures = []
- @back_pic = []
- @damage = []
- $sv_camera.setup
- N03.camera(nil, N03::BATTLE_CAMERA["回合开始前"].dup)
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- update_battler_data
- update_damage
- update_pictures
- update_back_pic
- update_weapons
- end
- #--------------------------------------------------------------------------
- # ● バトラーデータの更新
- #--------------------------------------------------------------------------
- def update_battler_data
- for battler in $game_party.battle_members + $game_troop.members
- weapon_end(battler) if battler.sv.weapon_end
- next if battler.sv.effect_data == []
- for effect_data in battler.sv.effect_data do set_effects(battler, effect_data) end
- end
- end
- #--------------------------------------------------------------------------
- # ● ダメージ画像の更新
- #--------------------------------------------------------------------------
- def update_damage
- for i in [email]0...@damage.size[/email]
- next if @damage[i] == nil
- @damage[i].update if @damage[i] != nil
- next if !@damage[i].action_end
- @damage[i].dispose
- @damage[i] = nil
- end
- end
- #--------------------------------------------------------------------------
- # ● ピクチャアクションの更新
- #--------------------------------------------------------------------------
- def update_pictures
- for i in [email]0...@pictures.size[/email]
- next if @pictures[i] == nil
- @pictures[i].update if @pictures[i] != nil
- next if !@pictures[i].action_end
- @pictures[i].dispose
- @pictures[i] = nil
- end
- end
- #--------------------------------------------------------------------------
- # ● 周期ピクチャの更新
- #--------------------------------------------------------------------------
- def update_back_pic
- set_back_pic if $sv_camera.program_picture != []
- for i in [email]0...@back_pic.size[/email]
- next if @back_pic[i] == nil
- @back_pic[i].update if @back_pic[i] != nil
- next if !@back_pic[i].action_end
- @back_pic[i].dispose
- @back_pic[i] = nil
- end
- end
- #--------------------------------------------------------------------------
- # ● 武器アクションの更新
- #--------------------------------------------------------------------------
- def update_weapons
- for i in [email]0...@weapons.size[/email]
- next if @weapons[i] == nil
- @weapons[i].update if @weapons[i] != nil
- next if !@weapons[i].action_end
- @weapons[i].dispose
- @weapons[i] = nil
- end
- end
- #--------------------------------------------------------------------------
- # ● ダメージ実行
- #--------------------------------------------------------------------------
- def set_damage_pop(target)
- for i in [email]0...@damage.size[/email]
- next if @damage[i] != nil
- return @damage[i] = Sprite_Damage.new(@viewport, target)
- end
- @damage.push(Sprite_Damage.new(@viewport, target))
- end
- #--------------------------------------------------------------------------
- # ● 周期ピクチャ実行
- #--------------------------------------------------------------------------
- def set_back_pic
- for data in $sv_camera.program_picture
- if @back_pic[data[2]] != nil
- @back_pic[data[2]].dispose
- @back_pic[data[2]] = nil
- end
- @back_pic[data[2]] = Sprite_Back_Picture.new(@viewport, data[2])
- @back_pic[data[2]].setup(data)
- end
- $sv_camera.program_picture = []
- end
- #--------------------------------------------------------------------------
- # ● エフェクト開始
- #--------------------------------------------------------------------------
- def set_effects(battler, effect_data)
- case effect_data[0]
- when "pic" ; set_pictures(battler, effect_data)
- when "wp" ; set_weapons(battler, true)
- when "m_a" ; set_weapons(battler, false)
- end
- end
- #--------------------------------------------------------------------------
- # ● ピクチャアクション実行
- #--------------------------------------------------------------------------
- def set_pictures(battler, effect_data)
- @pictures[effect_data[1]] = Sprite_Battle_Picture.new if @pictures[effect_data[1]] == nil
- @pictures[effect_data[1]].set(battler)
- end
- #--------------------------------------------------------------------------
- # ● 武器アクション実行
- #--------------------------------------------------------------------------
- def set_weapons(battler, weapon_flag, test = true)
- for i in [email]0...@weapons.size[/email]
- next if @weapons[i] != nil
- @weapons[i] = Sprite_Weapon.new(@viewport, i, battler)
- battler.sv.weapon_index.push(i) if weapon_flag
- return i
- end
- @weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))
- battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flag
- return @weapons.size - 1
- end
- #--------------------------------------------------------------------------
- # ● バトラーの武器アクション終了
- #--------------------------------------------------------------------------
- def weapon_end(battler)
- battler.sv.weapon_end = false
- for index in battler.sv.weapon_index
- weapon_index = battler.sv.weapon_index.shift
- @weapons[weapon_index].dispose if @weapons[weapon_index] != nil
- @weapons[weapon_index] = nil
- end
- battler.sv.weapon_index.compact!
- end
- #--------------------------------------------------------------------------
- # ● ヒット時の戦闘アニメ実行
- #--------------------------------------------------------------------------
- def set_hit_animation(battler, weapon_index, hit_targets, miss)
- weapon = @weapons[weapon_index]
- for target in hit_targets
- next @weapons[@hit_index].timing_battler_set(target) if @hit_index != nil
- @hit_index = set_weapons(battler, false, false)
- @weapons[@hit_index].set_hit_animation(weapon.hit_position, weapon.hit_anime_id, target)
- end
- @hit_index = nil
- if !weapon.through && !miss
- @weapons[weapon_index].dispose
- @weapons[weapon_index] = nil
- else
- @weapons[weapon_index].through_change
- end
- end
- #--------------------------------------------------------------------------
- # ● サイドビューデータの初期化
- #--------------------------------------------------------------------------
- def reset_sideview
- $sv_camera.reset
- for member in $game_troop.members + $game_party.battle_members do member.sv.reset end
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- def dispose
- dispose_effects(@weapons)
- dispose_effects(@pictures)
- dispose_effects(@back_pic)
- dispose_effects(@damage)
- reset_sideview
- end
- #--------------------------------------------------------------------------
- # ● エフェクト画像の解放
- #--------------------------------------------------------------------------
- def dispose_effects(effects)
- for i in 0...effects.size
- effects[i].dispose if effects[i] != nil
- effects[i] = nil
- end
- end
- end
- #==============================================================================
- # ■ Sprite_Battle_Back
- #------------------------------------------------------------------------------
- # 戦闘背景用のスプライトです。
- #==============================================================================
- class Sprite_Battle_Back < Plane
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize(viewport = nil, index, battleback_name)
- super(viewport)
- @index = index
- if @index == 1
- data = N03::FLOOR1_DATA[battleback_name]
- data = N03::FLOOR1_DATA["全Battlebacks1"] if data == nil
- elsif @index == 2
- data = N03::FLOOR2_DATA[battleback_name]
- data = N03::FLOOR2_DATA["全Battlebacks2"] if data == nil
- end
- data = data.dup
- @adjust_position = data[0]
- @zoom_x = data[1][0] / 100.0
- @zoom_y = data[1][1] / 100.0
- @shake_on = data[2]
- $game_switches[data[3]] = true if data[3] > 0
- $sv_camera.switches[data[3].abs] = true if data[3] < 0
- reset_scroll
- reset_back_data(battleback_name)
- end
- #--------------------------------------------------------------------------
- # ● 背景スクロールを初期化
- #--------------------------------------------------------------------------
- def reset_scroll
- @scroll_x = 0
- @scroll_y = 0
- @move_x = 0
- @move_y = 0
- end
- #--------------------------------------------------------------------------
- # ● 背景データを初期化
- #--------------------------------------------------------------------------
- def reset_back_data(battleback_name)
- @back_data = []
- @active_data = ["scroll",0, @move_x, @move_y, false, battleback_name,""]
- start_back_data(@active_data)
- end
- #--------------------------------------------------------------------------
- # ● 背景画像のセッティング
- #--------------------------------------------------------------------------
- def set_graphics(new_bitmap)
- self.bitmap = new_bitmap
- @base_x = (self.bitmap.width * @zoom_x - Graphics.width) / 2 + @adjust_position[0]
- @base_y = (self.bitmap.height * @zoom_y - Graphics.height) / 2 + @adjust_position[1]
- # 限界座標を取得
- max_top = 0
- max_bottom = self.bitmap.height * @zoom_y - Graphics.height
- max_left = 0
- max_right = self.bitmap.width * @zoom_x - Graphics.width
- exist = true
- exist = false if self.bitmap.height == 32 && self.bitmap.width == 32
- $sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y,exist])
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- return if !bitmap
- update_back_data
- update_scroll unless @move_x == 0 && @move_y == 0
- update_color
- update_position
- update_back_adjust if @bt_back != nil
- create_back_adjust if @bt_back == nil && !@active_data[10] && @scroll_x == 0 && @scroll_y == 0
- end
- #--------------------------------------------------------------------------
- # ● 背景データを更新
- #--------------------------------------------------------------------------
- def update_back_data
- delete = true if @active_data[1] > 0 && !$game_switches[@active_data[1]]
- delete = true if @active_data[1] < 0 && !$sv_camera.switches[@active_data[1].abs]
- return if !delete
- for i in [email]0...@back_data.size[/email]
- @back_data[i] = nil if @back_data[i][1] > 0 && !$game_switches[@back_data[i][1]]
- @back_data[i] = nil if @back_data[i][1] < 0 && !$sv_camera.switches[@back_data[i][1].abs]
- end
- @back_data.compact!
- next_back_data
- end
- #--------------------------------------------------------------------------
- # ● 次の背景データをセット
- #--------------------------------------------------------------------------
- def next_back_data
- @back_data.delete(@active_data[11]) if @active_data[11] != nil
- @back_data.push(@active_data[11]) if @active_data[11] != nil
- @active_data = nil
- data = @back_data.pop
- @back_data = [@active_data] if @back_data.size == 0
- start_back_data(data)
- end
- #--------------------------------------------------------------------------
- # ● 背景データを実行
- #--------------------------------------------------------------------------
- def start_back_data(data)
- return if back_data_remain(data)
- bt_back_dispose
- pre_active_data = @active_data
- @active_data[8] = [@back_name, @move_x, @move_y, @scroll_x, @scroll_y] if @active_data != nil
- @back_data.push(@active_data) if @active_data != nil
- @active_data = data.dup
- @active_data[5] = @back_name if @active_data[5] == ""
- @active_data[9] = set_back_adjust if @active_data[9] == nil
- back_data_scroll_on if @active_data[8] == nil && @active_data[9][0] == false
- set_remain_back_data if @active_data[8] != nil
- create_back(@active_data[5]) if @active_data[9][0] == false
- create_back_adjust if @active_data[10]
- @active_data[11] = pre_active_data if pre_active_data && @active_data[7] == false
- end
- #--------------------------------------------------------------------------
- # ● 背景データの保留
- #--------------------------------------------------------------------------
- def back_data_remain(data)
- remain = false
- remain = true if data[6] != "" && @active_data != nil && @active_data[9] != nil && @active_data[9][0] != false
- remain = true if @active_data != nil && @active_data[7] == false
- return remain if !remain
- @remain = true
- @back_data.push(data)
- return remain
- end
- #--------------------------------------------------------------------------
- # ● 背景変更補正データをセット
- #--------------------------------------------------------------------------
- def set_back_adjust
- bt_adjust = []
- sign = -1
- if @active_data[6] == ""
- reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
- bt_adjust = [false,false,0,0]
- return bt_adjust
- elsif @move_x != 0 or @active_data[3][0] != 0
- sign = 1 if @move_x < 0
- bt_adjust[0] = [self.bitmap.width * @zoom_x * sign, 0]
- bt_adjust[1] = [self.bitmap.width * @zoom_x * sign * 2, 0]
- elsif @move_y != 0 or @active_data[3][1] != 0
- sign = 1 if @move_y < 0
- bt_adjust[0] = [0, self.bitmap.height * @zoom_y * sign]
- bt_adjust[1] = [0, self.bitmap.height * @zoom_y * sign * 2]
- else
- reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
- bt_adjust = [false,false,0,0]
- return bt_adjust
- end
- bt_adjust[2] = [bt_adjust[0][0], bt_adjust[0][1]]
- return bt_adjust
- end
- #--------------------------------------------------------------------------
- # ● 背景スクロールデータを実行
- #--------------------------------------------------------------------------
- def back_data_scroll_on
- mirror = $sv_camera.mirror
- mirror = false if !@active_data[4]
- @move_x = @active_data[3][0]
- @move_x *= -1 if mirror
- @move_y = @active_data[3][1]
- end
- #--------------------------------------------------------------------------
- # ● 保持している背景データを実行
- #--------------------------------------------------------------------------
- def set_remain_back_data
- return back_data_scroll_on if @move_x != 0 or @move_y != 0
- create_back(@active_data[8][0])
- @move_x = @active_data[8][1]
- @move_y = @active_data[8][2]
- @scroll_x = @active_data[8][3]
- @scroll_y = @active_data[8][4]
- end
- #--------------------------------------------------------------------------
- # ● 背景画像の作成
- #--------------------------------------------------------------------------
- def create_back(back_name)
- return if back_name == @back_name or back_name == ""
- self.bitmap = Cache.battleback1(back_name) if @index == 1
- self.bitmap = Cache.battleback2(back_name) if @index == 2
- @back_name = back_name
- end
- #--------------------------------------------------------------------------
- # ● 背景変更補正画像の作成
- #--------------------------------------------------------------------------
- def create_back_adjust
- return if @active_data[9][0] == false
- @active_data[10] = true
- mirror = $sv_camera.mirror
- mirror = false if !@active_data[4]
- @bt_back = []
- @bt_back[0] = Sprite.new(viewport)
- @bt_back[0].bitmap = Cache.battleback1(@active_data[6]) if @index == 1
- @bt_back[0].bitmap = Cache.battleback2(@active_data[6]) if @index == 2
- @bt_back[0].mirror = mirror
- @bt_back[1] = Sprite.new(viewport)
- @bt_back[1].bitmap = Cache.battleback1(@active_data[5]) if @index == 1
- @bt_back[1].bitmap = Cache.battleback2(@active_data[5]) if @index == 2
- @bt_back[1].mirror = mirror
- end
- #--------------------------------------------------------------------------
- # ● 背景スクロールの更新
- #--------------------------------------------------------------------------
- def update_scroll
- @scroll_x += @move_x
- @scroll_y += @move_y
- @scroll_x = 0 if @scroll_x / 100 >= self.bitmap.width * @zoom_x or @scroll_x / 100 <= -self.bitmap.width * @zoom_x
- @scroll_y = 0 if @scroll_y / 100 >= self.bitmap.height * @zoom_y or @scroll_y / 100 <= -self.bitmap.height * @zoom_y
- end
- #--------------------------------------------------------------------------
- # ● 色調変更の更新
- #--------------------------------------------------------------------------
- def update_color
- color_set if $sv_camera.color_set[@index] != nil
- return if @color_data == nil
- @color_data[4] -= 1
- if @color_data[4] == 0 && @color_data[5] != 0
- @color_data[4] = @color_data[5]
- @color_data[5] = 0
- @color_data[6] = [0,0,0,0]
- elsif @color_data[4] == 0
- @remain_color_data = @color_data
- return @color_data = nil
- end
- for i in 0..3
- @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
- end
- self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
- end
- #--------------------------------------------------------------------------
- # ● 座標の更新
- #--------------------------------------------------------------------------
- def update_position
- self.ox = $sv_camera.x + @base_x - @scroll_x / 100
- self.oy = $sv_camera.y + @base_y - @scroll_y / 100
- self.ox -= $sv_camera.sx / 100 if @shake_on
- self.oy -= $sv_camera.sy / 100 if @shake_on
- self.zoom_x = @zoom_x * $sv_camera.zoom
- self.zoom_y = @zoom_y * $sv_camera.zoom
- self.ox *= $sv_camera.zoom
- self.oy *= $sv_camera.zoom
- self.z = @index * 10
- end
- #--------------------------------------------------------------------------
- # ● 背景変更補正画像を更新
- #--------------------------------------------------------------------------
- def update_back_adjust
- @active_data[9][0][0] = 0 if @scroll_x == 0
- @active_data[9][0][1] = 0 if @scroll_y == 0
- @active_data[9][1][0] -= @active_data[9][2][0] if @scroll_x == 0
- @active_data[9][1][1] -= @active_data[9][2][1] if @scroll_y == 0
- for i in [email]0...@bt_back.size[/email]
- @bt_back[i].x = -self.ox + @active_data[9][i][0] * $sv_camera.zoom
- @bt_back[i].y = -self.oy + @active_data[9][i][1] * $sv_camera.zoom
- @bt_back[i].zoom_x = self.zoom_x
- @bt_back[i].zoom_y = self.zoom_y
- @bt_back[i].z = self.z + 1
- @bt_back[i].color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
- end
- back_data_scroll_on if @active_data[9][0][0] == 0 && @active_data[9][0][1] == 0
- return unless @active_data[9][1][0] == 0 && @active_data[9][1][1] == 0
- bt_back_dispose
- create_back(@active_data[5])
- @active_data[9][0] = false
- next_back_data if @remain && @back_data.size != 1
- @remain = false
- end
- #--------------------------------------------------------------------------
- # ● 色調変更
- #--------------------------------------------------------------------------
- def color_set
- set = $sv_camera.color_set[@index]
- $sv_camera.color_set[@index] = nil
- set[4] = 1 if set[4] == 0
- @remain_color_data = [0,0,0,0] if @remain_color_data == nil
- @color_data = @remain_color_data
- @color_data[4] = set[4]
- @color_data[5] = set[5]
- @color_data[6] = set
- end
- #--------------------------------------------------------------------------
- # ● 背景変更補正画像の解放
- #--------------------------------------------------------------------------
- def bt_back_dispose
- for i in [email]0...@bt_back.size[/email] do @bt_back[i].dispose end if @bt_back != nil
- @bt_back = nil
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- def dispose
- bitmap.dispose if bitmap
- bt_back_dispose
- super
- end
- end
-
- #==============================================================================
- # ■ Battle_Camera
- #------------------------------------------------------------------------------
- # 戦闘カメラやバトルプログラムを扱うクラスです。
- #==============================================================================
- class Battle_Camera
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_reader :sx # シェイクX座標
- attr_reader :sy # シェイクY座標
- attr_reader :max_top # 上限界座標
- attr_reader :max_bottom # 下限界座標
- attr_reader :max_left # 左限界座標
- attr_reader :max_right # 右限界座標
- attr_accessor :switches # サイドビュー専用スイッチ
- attr_accessor :color_set # 色調変更データ
- attr_accessor :wait # 戦闘シーンの強制ウエイト
- attr_accessor :win_wait # 戦闘勝利前のウエイト
- attr_accessor :mirror # 画面反転フラグ
- attr_accessor :program_scroll # バトルプログラム 背景の自動スクロール
- attr_accessor :program_picture # バトルプログラム 周期ピクチャ
- attr_accessor :event # コモンイベント呼び出し
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- def initialize
- @switches = []
- @max_data = []
- @color_set = []
- @wait = 0
- @win_wait = false
- @mirror = false
- @event = false
- setup
- end
- #--------------------------------------------------------------------------
- # ● カメラX座標
- #--------------------------------------------------------------------------
- def x
- return @x / 100
- end
- #--------------------------------------------------------------------------
- # ● カメラY座標
- #--------------------------------------------------------------------------
- def y
- return @y / 100
- end
- #--------------------------------------------------------------------------
- # ● ズーム率
- #--------------------------------------------------------------------------
- def zoom
- return @zoom * 0.001
- end
- #--------------------------------------------------------------------------
- # ● ズーム率による座標変換
- #--------------------------------------------------------------------------
- def convert
- return @zoom
- end
- #--------------------------------------------------------------------------
- # ● カメラセットアップ
- #--------------------------------------------------------------------------
- def setup
- @x = 0
- @y = 0
- @sx = 0
- @sy = 0
- @zoom = 1000
- @time = 0
- @shake_time = 0
- program_setup
- end
- #--------------------------------------------------------------------------
- # ● カメラ初期化
- #--------------------------------------------------------------------------
- def reset
- @switches = []
- @max_data = []
- @color_set = []
- @wait = 0
- @win_wait = false
- @mirror = false
- program_setup(false)
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラムのセットアップ
- #--------------------------------------------------------------------------
- def program_setup(check = true)
- @played_program = []
- @program_switch = []
- @program_sound = []
- @program_scroll = []
- @program_se = []
- @program_shake = []
- @program_color = []
- @program_picture = []
- @program_base = N03::BATTLE_PROGRAM.values.dup
- program_check if check
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラムのチェック
- #--------------------------------------------------------------------------
- def program_check
- for data in @program_base
- if program_start?(data) && !@played_program.include?(data)
- @played_program.push(data.dup)
- @program_scroll.push(data.dup) if data[0] == "scroll"
- @program_picture.push(data.dup) if data[0] == "kpic"
- start_sound(data.dup) if data[0] == "sound"
- start_program_switch(data.dup) if data[0] == "switch"
- start_program_se(data.dup) if data[0] == "keep_se"
- start_program_shake(data.dup) if data[0] == "keep_sk"
- start_program_color(data.dup) if data[0] == "keep_c"
- else
- @played_program.delete(data) if !program_start?(data)
- @program_scroll.delete(data) if data[0] == "scroll"
- @program_picture.delete(data) if data[0] == "kpic"
- @program_switch.delete(data) if data[0] == "switch"
- @program_sound.delete(data) if data[0] == "sound"
- @program_se.delete(data) if data[0] == "keep_se"
- @program_shake.delete(data) if data[0] == "keep_sk"
- @program_color.delete(data) if data[0] == "keep_c"
- end
- end
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラムの開始
- #--------------------------------------------------------------------------
- def program_start?(data)
- start = false
- start = true if $game_switches[data[1].abs] && data[1] > 0
- start = true if @switches[data[1].abs] && data[1] < 0
- return start
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラム スイッチ操作の開始
- #--------------------------------------------------------------------------
- def start_program_switch(data)
- data[4] = data[4] + rand(data[5] + 1)
- data[4] = 1 if data[4] <= 0
- @program_switch.push(data)
- end
- #--------------------------------------------------------------------------
- # ● スイッチ操作の更新
- #--------------------------------------------------------------------------
- def update_program_switch
- for data in @program_switch
- data[4] -= 1
- next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]
- next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]
- next if data[4] != 0
- for id in data[2]
- $game_switches[id] = true if id > 0
- @switches[id.abs] = true if id < 0
- end
- for id in data[3]
- $game_switches[id] = false if id > 0
- @switches[id.abs] = false if id < 0
- end
- @program_switch.delete(data)
- program_check
- end
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラム BGM/BGSの開始
- #--------------------------------------------------------------------------
- def start_sound(data)
- @program_sound.push(data)
- name = data[5]
- case data[2]
- when "se"
- Audio.se_play("Audio/SE/" + name, data[4], data[3])
- when "bgm"
- name = RPG::BGM.last.name if data[5] == ""
- Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])
- when "bgs"
- name = RPG::BGS.last.name if data[5] == ""
- Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])
- end
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラム 周期SEの開始
- #--------------------------------------------------------------------------
- def start_program_se(data)
- data[3] = [data[2], data[3]]
- data[2] = data[3][0] + rand(data[3][1] + 1)
- @program_se.push(data)
- Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]
- end
- #--------------------------------------------------------------------------
- # ● 周期SEの更新
- #--------------------------------------------------------------------------
- def update_program_se
- for data in @program_se
- data[2] -= 1
- next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]
- next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]
- next if data[2] != 0
- Audio.se_play("Audio/SE/" + data[7], data[5], data[4])
- data[2] = data[3][0] + rand(data[3][1] + 1)
- end
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラム 周期シェイクの開始
- #--------------------------------------------------------------------------
- def start_program_shake(data)
- data[3] = [data[2], data[3]]
- data[2] = data[3][0] + rand(data[3][1] + 1)
- @program_shake.push(data)
- shake(data[4], data[5], data[6]) if data[7]
- end
- #--------------------------------------------------------------------------
- # ● 周期シェイクの更新
- #--------------------------------------------------------------------------
- def update_program_shake
- for data in @program_shake
- data[2] -= 1
- next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]
- next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]
- next if data[2] != 0
- shake(data[4], data[5], data[6])
- data[2] = data[3][0] + rand(data[3][1] + 1)
- end
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラム 周期色調変更の開始
- #--------------------------------------------------------------------------
- def start_program_color(data)
- data[3] = [data[2], data[3]]
- data[2] = data[3][0] + rand(data[3][1] + 1)
- data[7] = true if data[4] == 0 or data[4] == 4
- case data[4]
- when 1 ;data[4] = $game_troop.members
- when 2 ;data[4] = $game_party.battle_members
- when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members
- else ;data[4] = []
- end
- @program_color.push(data)
- return if !data[6]
- for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
- @color_set[1] = data[5] if data[7]
- @color_set[2] = data[5] if data[7]
- end
- #--------------------------------------------------------------------------
- # ● 周期色調変更の更新
- #--------------------------------------------------------------------------
- def update_program_color
- for data in @program_color
- data[2] -= 1
- next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]
- next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]
- next if data[2] != 0
- for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
- @color_set[1] = data[5] if data[7]
- @color_set[2] = data[5] if data[7]
- data[2] = data[3][0] + rand(data[3][1] + 1)
- end
- end
- #--------------------------------------------------------------------------
- # ● トランジション実行
- #--------------------------------------------------------------------------
- def perform_transition(data)
- Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])
- end
- #--------------------------------------------------------------------------
- # ● 背景からカメラの限界値を取得 data = [max_top, max_bottom, max_left, max_right]
- #--------------------------------------------------------------------------
- def setting(index, data)
- @max_data[index - 1] = data
- return if index != 2
- setup
- # カメラの中心座標
- @center_x = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100
- @center_y = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100
- # 上下左右の移動限界距離
- @max_top = [@max_data[0][5], @max_data[1][5]].min * -1
- @max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
- @max_left = [@max_data[0][4], @max_data[1][4]].min * -1
- @max_right = [@max_data[0][3], @max_data[1][3]].min + @max_left
- exist_data = @max_data[0] if !@max_data[1][6]
- exist_data = @max_data[1] if !@max_data[0][6]
- @max_top = exist_data[5] * -1 if exist_data != nil
- @max_bottom = exist_data[1] + @max_top if exist_data != nil
- @max_left = exist_data[4] * -1 if exist_data != nil
- @max_right = exist_data[3] + @max_left if exist_data != nil
- @max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]
- @max_width = @max_right - @max_left + Graphics.width
- @max_height = @max_bottom - @max_top + Graphics.height
- # ズームアウト限界値
- max_zoom_x = 100 * Graphics.width / @max_width
- max_zoom_y = 100 * Graphics.height / @max_height
- @max_zoom_out = [max_zoom_x, max_zoom_y].max
- end
- #--------------------------------------------------------------------------
- # ● カメラ移動
- #--------------------------------------------------------------------------
- def move(target_x, target_y, zoom, time, screen = true)
- # 戦闘背景以上のサイズまでズームアウトしないよう調整
- @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max
- target_x *= -1 if screen && @mirror
- # ズーム分の中心座標補正
- if screen && @target_zoom != 1
- target_x = target_x + @center_x
- target_y = target_y + @center_y
- end
- adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
- adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
- adjust_x = 0 if adjust_x.nan?
- adjust_y = 0 if adjust_y.nan?
- adjust_x = @center_x if !screen && adjust_x == 0
- adjust_y = @center_y if !screen && adjust_y == 0
- @target_x = target_x - adjust_x.to_i
- @target_y = target_y - adjust_y.to_i
- @target_zoom = (@target_zoom * 1000).to_i
- @zoom = @zoom.to_i
- limit_test
- # 時間0の場合は即実行
- return @time = time.abs if time != 0
- @time = 1
- update
- end
- #--------------------------------------------------------------------------
- # ● 限界座標の試算
- #--------------------------------------------------------------------------
- def limit_test
- new_width = @max_width * @target_zoom / 1000
- new_height = @max_height * @target_zoom / 1000
- new_max_right = @max_right - (@max_width - new_width)
- new_max_bottom = @max_bottom - (@max_height - new_height)
- # 画面の移動先が限界の場合、限界座標をセット
- if @target_x < @max_left * 100
- @target_x = @max_left * 100
- end
- if @target_x > new_max_right * 100
- @target_x = new_max_right * 100
- end
- if @target_y < @max_top * 100
- @target_y = @max_top * 100
- end
- if @target_y > new_max_bottom * 100
- @target_y = new_max_bottom * 100
- end
- end
- #--------------------------------------------------------------------------
- # ● 画面のシェイク
- #--------------------------------------------------------------------------
- def shake(power, speed, time)
- @shake_x = power[0] * 100
- @shake_y = power[1] * 100
- @power_time_base = @power_time = speed
- @shake_time = time
- update_shake
- end
- #--------------------------------------------------------------------------
- # ● シェイクの更新
- #--------------------------------------------------------------------------
- def update_shake
- @sx = (@sx * (@power_time - 1) + @shake_x) / @power_time
- @sy = (@sy * (@power_time - 1) + @shake_y) / @power_time
- @power_time -= 1
- @shake_time -= 1
- return @sx = @sy = 0 if @shake_time == 0
- return if @power_time != 0
- @power_time = @power_time_base
- @shake_x = @shake_x * -4 / 5
- @shake_y = @shake_y * -4 / 5
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update
- update_shake if @shake_time != 0
- update_program
- return if @time == 0
- @x = (@x * (@time - 1) + @target_x) / @time
- @y = (@y * (@time - 1) + @target_y) / @time
- @zoom = (@zoom * (@time - 1) + @target_zoom) / @time
- @time -= 1
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- def update_program
- update_program_switch if @program_switch != []
- update_program_se if @program_se != []
- update_program_shake if @program_shake != []
- update_program_color if @program_color != []
- end
- end
- #==============================================================================
- # ■ Scene_Battle
- #------------------------------------------------------------------------------
- # バトル画面の処理を行うクラスです。
- #==============================================================================
- class Scene_Battle < Scene_Base
- #--------------------------------------------------------------------------
- # ● フレーム更新(基本)
- #--------------------------------------------------------------------------
- alias update_basic_scene_battle_n03 update_basic
- def update_basic
- update_basic_scene_battle_n03
- $sv_camera.update
- $sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait
- camera_wait
- end
- #--------------------------------------------------------------------------
- # ● カメラウェイト
- #--------------------------------------------------------------------------
- def camera_wait
- process_event if $sv_camera.event
- $sv_camera.event = false if $sv_camera.event
- while $sv_camera.wait != 0
- Graphics.update
- Input.update
- update_all_windows
- $game_timer.update
- $game_troop.update
- $sv_camera.update
- @spriteset.update
- update_info_viewport
- update_message_open
- $sv_camera.wait -= 1 if $sv_camera.wait > 0
- $sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?
- BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0
- end
- end
- #--------------------------------------------------------------------------
- # ● カメラウェイトのセット
- #--------------------------------------------------------------------------
- def set_camera_wait(time)
- $sv_camera.wait = time
- camera_wait
- end
- #--------------------------------------------------------------------------
- # ● エフェクト実行が終わるまでウェイト ★再定義
- #--------------------------------------------------------------------------
- def wait_for_effect
- end
- #--------------------------------------------------------------------------
- # ● ターン開始
- #--------------------------------------------------------------------------
- alias turn_start_scene_battle_n03 turn_start
- def turn_start
- turn_start_scene_battle_n03
- N03.camera(nil, N03::BATTLE_CAMERA["回合开始后"].dup)
- end
- #--------------------------------------------------------------------------
- # ● ターン終了
- #--------------------------------------------------------------------------
- alias turn_end_scene_battle_n03 turn_end
- def turn_end
- turn_end_scene_battle_n03
- for member in $game_troop.members + $game_party.members
- N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])
- member.sv.result_damage = [0,0]
- @spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0
- end
- set_camera_wait(N03::TURN_END_WAIT)
- N03.camera(nil, N03::BATTLE_CAMERA["回合开始前"].dup) if $game_party.inputable?
- @log_window.clear
- end
- #--------------------------------------------------------------------------
- # ● スキル/アイテムの使用 ★再定義
- #--------------------------------------------------------------------------
- def use_item
- item = @subject.current_action.item
- display_item(item)
- @subject.use_item(item)
- refresh_status
- @targets = @subject.current_action.make_targets.compact
- @targets = [@subject] if @targets.size == 0
- set_substitute(item)
- for time in item.repeats.times do play_sideview(@targets, item) end
- end_reaction(item)
- display_end_item
- end
- #--------------------------------------------------------------------------
- # ● スキル/アイテム名の表示
- #--------------------------------------------------------------------------
- def display_item(item)
- return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG
- @log_window.off
- @skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)
- end
- #--------------------------------------------------------------------------
- # ● スキル/アイテム名の表示終了
- #--------------------------------------------------------------------------
- def display_end_item
- @skill_name_window.dispose if @skill_name_window != nil
- @skill_name_window = nil
- set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0
- @log_window.clear if N03::BATTLE_LOG
- end
- #--------------------------------------------------------------------------
- # ● 反撃/魔法反射/身代わり処理
- #--------------------------------------------------------------------------
- def end_reaction(item)
- end_substitute if @substitute != nil
- set_reflection(item) if @reflection_data != nil
- set_counter_attack if @counter_attacker != nil
- end
- #--------------------------------------------------------------------------
- # ● 反撃の発動 ★再定義
- #--------------------------------------------------------------------------
- def invoke_counter_attack(target, item)
- return if @subject.sv.counter_id != 0
- @counter_attacker = [] if @counter_attacker == nil
- return apply_item_effects(apply_substitute(target, item), item) if !target.movable?
- @log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG
- target.sv.counter_id = target.sv.counter_skill_id
- @counter_attacker.push(target)
- end
- #--------------------------------------------------------------------------
- # ● 魔法反射の発動 ★再定義
- #--------------------------------------------------------------------------
- def invoke_magic_reflection(target, item)
- return if @subject.sv.reflection_id != 0
- @log_window.add_text(sprintf(Vocab::MagicReflection, target.name)) if N03::BATTLE_LOG
- target.sv.reflection_id = target.sv.reflection_anime_id
- end
- #--------------------------------------------------------------------------
- # ● 身代わりの適用 ★再定義
- #--------------------------------------------------------------------------
- def apply_substitute(target, item)
- return target if @substitute == nil
- return target if !check_substitute(target, item)
- return @substitute
- end
- #--------------------------------------------------------------------------
- # ● 身代わりセット
- #--------------------------------------------------------------------------
- def set_substitute(item)
- @substitute = N03.get_enemy_unit(@subject).substitute_battler
- return if @substitute == nil
- s_targets = []
- for i in [email]0...@targets.size[/email]
- next if @targets[i] == @substitute
- next if !check_substitute(@targets[i], item)
- @log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets[i].name))
- @targets[i].sv.start_action(@targets[i].sv.substitute_receiver_start_action)
- s_targets.push(@targets[i])
- @targets[i] = @substitute
- end
- return @substitute = nil if s_targets == []
- @substitute.sv.set_target(s_targets)
- @substitute.sv.start_action(@substitute.sv.substitute_start_action)
- end
- #--------------------------------------------------------------------------
- # ● 身代わり終了
- #--------------------------------------------------------------------------
- def end_substitute
- for member in @substitute.sv.target_battler
- member.sv.start_action(member.sv.substitute_receiver_end_action)
- end
- @substitute.sv.start_action(@substitute.sv.substitute_end_action)
- @substitute = nil
- end
- #--------------------------------------------------------------------------
- # ● 反撃
- #--------------------------------------------------------------------------
- def set_counter_attack
- pre_subject = @subject
- for attacker in @counter_attacker
- @subject = attacker
- item = $data_skills[attacker.sv.counter_skill_id]
- play_sideview([pre_subject], item)
- end
- # 同一カウンター者を考慮してカウンターIDの初期化はアクション後に実行
- for attacker in @counter_attacker do attacker.sv.counter_id = 0 end
- @subject = pre_subject
- @counter_attacker = nil
- end
- #--------------------------------------------------------------------------
- # ● 魔法反射
- #--------------------------------------------------------------------------
- def set_reflection(item)
- @log_window.back_to(1)
- for data in @reflection_data
- @subject.sv.damage_action(@subject, item)
- N03.set_damage_anime_data([@subject], @subject, data)
- apply_item_effects(@subject, item)
- @spriteset.set_damage_pop(@subject)
- end
- set_camera_wait(N03.get_anime_time(@reflection_data[0][0]))
- @reflection_data = nil
- end
- #--------------------------------------------------------------------------
- # ● サイドビューアクション実行
- #--------------------------------------------------------------------------
- def play_sideview(targets, item)
- @subject.sv.set_target(targets)
- return if @subject.sv.attack_action(item) == nil
- return if !@subject.movable?
- return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)
- @subject.sv.start_action(@subject.sv.attack_action(item))
- @subject.sv.unshift_action(@subject.sv.flash_action) if @subject.flash_flg
- @subject.sv.active = true
- @subject.sv.command_action = false
- loop do
- update_basic
- data = @subject.sv.play_data
- @targets = N03.s_targets(@subject) if data[0] == "second_targets_set"
- N03.targets_set(@subject) if data[0] == "targets_set"
- @immortal = N03.immortaling if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)
- @immortal = N03.unimmortaling if data[0] == "collapse"
- next set_move_anime(item) if @subject.sv.m_a_data != []
- set_damage(item) if @subject.sv.set_damage
- break N03.derived_skill(@subject) if @subject.sv.derivation_skill_id != 0
- break if @subject.sv.action_end or @subject.hidden?
- end
- @immortal = N03.unimmortaling if @immortal
- end
- #--------------------------------------------------------------------------
- # ● ダメージの実行
- #--------------------------------------------------------------------------
- def set_damage(item)
- targets = @targets
- targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0
- for target in targets do damage_anime(targets.dup, target, item) end
- @subject.sv.set_damage = false
- @subject.sv.damage_anime_data = []
- end
- #--------------------------------------------------------------------------
- # ● ダメージ戦闘アニメ処理
- #--------------------------------------------------------------------------
- def damage_anime(targets, target, item)
- @log_window.back_to(1) if @log_window.line_number == 5
- return if item.scope != 9 && item.scope != 10 && target.dead?
- @miss = false
- invoke_item(target,item)
- if target.result.missed
- target.sv.miss_action(@subject, item)
- return @miss = true
- elsif target.result.evaded or target.sv.counter_id != 0
- target.sv.evasion_action(@subject, item)
- return @miss = true
- elsif target.sv.reflection_id != 0
- N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])
- target.sv.reflection_id = 0
- @reflection_data = [] if @reflection_data == nil
- return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])
- end
- target.sv.damage_action(@subject, item)
- N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject
- @spriteset.set_damage_pop(target)
- @spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0
- N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []
- end
- #--------------------------------------------------------------------------
- # ● 飛ばしアニメ処理
- #--------------------------------------------------------------------------
- def set_move_anime(item)
- for data in @subject.sv.m_a_data
- @subject.sv.damage_anime_data = data[4]
- hit_targets = []
- for target in data[1]
- damage_anime(data[1], target, item) if data[0]
- hit_targets.push(target) if !@miss
- end
- @miss = false if !data[3]
- @spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)
- end
- @subject.sv.set_damage = false
- @subject.sv.m_a_data = []
- end
- end
- #==============================================================================
- # ■ DataManager
- #------------------------------------------------------------------------------
- # データベースとゲームオブジェクトを管理するモジュールです。
- #==============================================================================
- module DataManager
- #--------------------------------------------------------------------------
- # ● 各種ゲームオブジェクトの作成 ★再定義
- #--------------------------------------------------------------------------
- def self.create_game_objects
- $game_temp = Game_Temp.new
- $game_system = Game_System.new
- $game_timer = Game_Timer.new
- $game_message = Game_Message.new
- $game_switches = Game_Switches.new
- $game_variables = Game_Variables.new
- $game_self_switches = Game_SelfSwitches.new
- $game_actors = Game_Actors.new
- $game_party = Game_Party.new
- $game_troop = Game_Troop.new
- $game_map = Game_Map.new
- $game_player = Game_Player.new
- $sv_camera = Battle_Camera.new
- end
- end
- #==============================================================================
- # ■ BattleManager
- #------------------------------------------------------------------------------
- # 戦闘の進行を管理するモジュールです。
- #==============================================================================
- module BattleManager
- #--------------------------------------------------------------------------
- # ● エンカウント時の処理 ★再定義
- #--------------------------------------------------------------------------
- def self.on_encounter
- @preemptive = (rand < rate_preemptive)
- @surprise = (rand < rate_surprise && !@preemptive)
- $sv_camera.mirror = @surprise if N03::BACK_ATTACK
- end
- #--------------------------------------------------------------------------
- # ● 勝利の処理 ★再定義
- #--------------------------------------------------------------------------
- def self.process_victory
- $sv_camera.win_wait = true
- end
- #--------------------------------------------------------------------------
- # ● 勝利
- #--------------------------------------------------------------------------
- def self.victory
- $sv_camera.win_wait = false
- N03.camera(nil, N03::BATTLE_CAMERA["战斗结束时"].dup)
- for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end
- play_battle_end_me
- replay_bgm_and_bgs
- $game_message.add(sprintf(Vocab::Victory, $game_party.name))
- display_exp
- gain_gold
- gain_drop_items
- gain_exp
- SceneManager.return
- battle_end(0)
- return true
- end
- #--------------------------------------------------------------------------
- # ● 逃走の処理 ★再定義
- #--------------------------------------------------------------------------
- def self.process_escape
- $game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))
- success = @preemptive ? true : (rand < @escape_ratio)
- Sound.play_escape
- if success
- process_abort
- for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end
- else
- @escape_ratio += 0.1
- $game_message.add('\.' + Vocab::EscapeFailure)
- $game_party.clear_actions
- for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end
- end
- wait_for_message
- return success
- end
- #--------------------------------------------------------------------------
- # ● 次のコマンド入力へ ★再定義
- #--------------------------------------------------------------------------
- def self.next_command
- begin
- if !actor || !actor.next_command
- $game_party.battle_members[@actor_index].sv.command_action = true
- @actor_index += 1
- if @actor_index >= $game_party.members.size
- for member in $game_party.battle_members.reverse
- break member.sv.start_action(member.sv.command_a) if member.inputable?
- end
- return false
- end
- end
- end until actor.inputable?
- actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?
- if pre_actor
- pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?
- end
- return true
- end
- #--------------------------------------------------------------------------
- # ● 前のコマンド入力へ ★再定義
- #--------------------------------------------------------------------------
- def self.prior_command
- begin
- if !actor || !actor.prior_command
- $game_party.battle_members[@actor_index].sv.command_action = false
- @actor_index -= 1
- if @actor_index < 0
- for member in $game_party.battle_members
- break member.sv.start_action(member.sv.command_a) if member.inputable?
- end
- return false
- end
- end
- end until actor.inputable?
- actor.make_actions if actor.inputable?
- actor.sv.start_action(actor.sv.command_b) if actor.inputable?
- after_actor.sv.start_action(after_actor.sv.command_a) if after_actor != nil && after_actor.inputable?
- return true
- end
- #--------------------------------------------------------------------------
- # ● コマンド入力前のアクターを取得
- #--------------------------------------------------------------------------
- def self.pre_actor
- return if @actor_index == 0
- $game_party.members[@actor_index - 1]
- end
- #--------------------------------------------------------------------------
- # ● コマンド入力後のアクターを取得
- #--------------------------------------------------------------------------
- def self.after_actor
- $game_party.members[@actor_index + 1]
- end
- #--------------------------------------------------------------------------
- # ● 戦闘行動者を前に追加
- #--------------------------------------------------------------------------
- def self.unshift_action_battlers(battler)
- @action_battlers.unshift(battler)
- end
- end
- #==============================================================================
- # ■ Game_Battler
- #------------------------------------------------------------------------------
- # スプライトや行動に関するメソッドを追加したバトラーのクラスです。
- #==============================================================================
- class Game_Battler < Game_BattlerBase
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_reader :sv # サイドビューデータ
- attr_accessor :flash_flg # 閃きフラグ
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- alias initialize_game_battler_n03 initialize
- def initialize
- initialize_game_battler_n03
- @sv = SideView.new(self)
- end
- #--------------------------------------------------------------------------
- # ● 現在の戦闘行動を除去
- #--------------------------------------------------------------------------
- alias remove_current_action_game_battler_n03 remove_current_action
- def remove_current_action
- return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0
- remove_current_action_game_battler_n03
- end
- #--------------------------------------------------------------------------
- # ● ターン終了処理
- #--------------------------------------------------------------------------
- alias on_turn_end_game_battler_n03 on_turn_end
- def on_turn_end
- on_turn_end_game_battler_n03
- @sv.add_state = []
- @sv.result_damage = [@result.hp_damage, @result.mp_damage]
- end
- #--------------------------------------------------------------------------
- # ● パラメータ条件比較 data = [種別, 数値, 判別]
- #--------------------------------------------------------------------------
- def comparison_parameter(data)
- return true if data[0][0] == 0
- kind = data[0]
- num = data[1]
- select = data[2]
- case kind
- when 1 ; par = level
- when 2 ; par = mhp
- when 3 ; par = mmp
- when 4 ; par = hp
- when 5 ; par = mp
- when 6 ; par = tp
- when 7 ; par = atk
- when 8 ; par = self.def
- when 9 ; par = mat
- when 10 ; par = mdf
- when 11 ; par = agi
- when 12 ; par = luk
- end
- if num < 0
- case kind
- when 4 ; num = mhp * num / 100
- when 5 ; num = mmp * num / 100
- when 6 ; num = max_tp * num / 100
- end
- num = num.abs
- end
- case select
- when 0 ; return par == num
- when 1 ; return par < num
- when 2 ; return par > num
- end
- end
- #--------------------------------------------------------------------------
- # ● 装備条件比較 data = [装備種別, タイプID]
- #--------------------------------------------------------------------------
- def comparison_equip(data)
- kind = data[0]
- items = weapons if kind == 0
- items = armors if kind == 1
- for item in items
- for id in data[1]
- return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]
- return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]
- return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs
- return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs
- end
- end
- return false
- end
-
- end
- #==============================================================================
- # ■ Game_Actor
- #------------------------------------------------------------------------------
- # アクターを扱うクラスです。
- #==============================================================================
- class Game_Actor < Game_Battler
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_reader :actor_id # ID
- #--------------------------------------------------------------------------
- # ● ID
- #--------------------------------------------------------------------------
- def id
- return @actor_id
- end
- #--------------------------------------------------------------------------
- # ● スプライトを使うか? ★再定義
- #--------------------------------------------------------------------------
- def use_sprite?
- return true
- end
- #--------------------------------------------------------------------------
- # ● ダメージ効果の実行 ★再定義
- #--------------------------------------------------------------------------
- def perform_damage_effect
- return if !N03::ACTOR_DAMAGE
- $game_troop.screen.start_shake(5, 5, 10)
- @sprite_effect_type = :blink
- Sound.play_actor_damage
- end
-
- end
- #==============================================================================
- # ■ Game_Enemy
- #------------------------------------------------------------------------------
- # 敵キャラを扱うクラスです。
- #==============================================================================
- class Game_Enemy < Game_Battler
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_reader :enemy_id # ID
- #--------------------------------------------------------------------------
- # ● ID
- #--------------------------------------------------------------------------
- def id
- return @enemy_id
- end
- #--------------------------------------------------------------------------
- # ● レベル
- #--------------------------------------------------------------------------
- def level
- return @sv.level
- end
- #--------------------------------------------------------------------------
- # ● ダメージ効果の実行 ★再定義
- #--------------------------------------------------------------------------
- def perform_damage_effect
- return if !N03::ENEMY_DAMAGE
- @sprite_effect_type = :blink
- Sound.play_enemy_damage
- end
- #--------------------------------------------------------------------------
- # ● 武器
- #--------------------------------------------------------------------------
- def weapons
- weapon1 = $data_weapons[@sv.enemy_weapon1_id]
- weapon2 = $data_weapons[@sv.enemy_weapon2_id]
- return [weapon1, weapon2]
- end
- #--------------------------------------------------------------------------
- # ● 防具
- #--------------------------------------------------------------------------
- def armors
- return [$data_armors[@sv.enemy_shield_id]]
- end
- #--------------------------------------------------------------------------
- # ● 二刀流の判定
- #--------------------------------------------------------------------------
- def dual_wield?
- return $data_weapons[@sv.enemy_weapon2_id] != nil
- end
- #--------------------------------------------------------------------------
- # ● バトラー画像変更
- #--------------------------------------------------------------------------
- def graphics_change(battler_name)
- @battler_name = battler_name
- end
- #--------------------------------------------------------------------------
- # ● 通常攻撃 アニメーション ID の取得
- #--------------------------------------------------------------------------
- def atk_animation_id1
- return weapons[0].animation_id if weapons[0]
- return weapons[1] ? 0 : 1
- end
- #--------------------------------------------------------------------------
- # ● 通常攻撃 アニメーション ID の取得(二刀流:武器2)
- #--------------------------------------------------------------------------
- def atk_animation_id2
- return weapons[1] ? weapons[1].animation_id : 0
- end
- end
- #==============================================================================
- # ■ Sprite_Base
- #------------------------------------------------------------------------------
- # アニメーションの表示処理を追加したスプライトのクラスです。
- #==============================================================================
- class Sprite_Base < Sprite
- #--------------------------------------------------------------------------
- # ● アニメーションの座標更新 (ホーミングあり)
- #--------------------------------------------------------------------------
- def update_animation_position_horming
- return if @action_end_cancel
- ani_ox_set if @horming
- camera_zoom = $sv_camera.zoom
- camera_zoom = 1 if @move_anime
- kind = 1
- kind = -1 if @ani_mirror && !@anime_no_mirror
- cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data
- for i in 0..15
- @ani_sprites[i].x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 1] != nil
- @ani_sprites[i].y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 2] != nil
- end
- end
- #--------------------------------------------------------------------------
- # ● アニメーション元の座標をセット
- #--------------------------------------------------------------------------
- def ani_ox_set
- if !SceneManager.scene_is?(Scene_Battle)
- @real_x = x
- @real_y = y
- end
- @ani_ox = @real_x - ox + width / 2
- @ani_oy = @real_y - oy + height / 2
- @ani_oy -= height / 2 if @animation.position == 0
- @ani_oy += height / 2 if @animation.position == 2
- end
- #--------------------------------------------------------------------------
- # ● アニメーションの更新
- #--------------------------------------------------------------------------
- alias update_animation_sprite_base_n03 update_animation
- def update_animation
- update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3
- update_animation_sprite_base_n03
- end
- #--------------------------------------------------------------------------
- # ● アニメーションの原点設定 ★再定義
- #--------------------------------------------------------------------------
- def set_animation_origin
- return ani_ox_set if @animation.position != 3
- if viewport == nil
- @ani_ox = Graphics.width / 2
- @ani_oy = Graphics.height / 2
- else
- @ani_ox = viewport.rect.width / 2
- @ani_oy = viewport.rect.height / 2
- end
- end
- #--------------------------------------------------------------------------
- # ● アニメーションスプライトの設定 ★再定義
- #--------------------------------------------------------------------------
- def animation_set_sprites(frame)
- camera_zoom = 1
- camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)
- camera_x = $sv_camera.x
- camera_y = $sv_camera.y
- camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)
- plus_z = 5
- plus_z = 1000 if @animation.position == 3
- plus_z = -17 if @plus_z != nil && @plus_z == false
- plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3
- cell_data = frame.cell_data
- @ani_sprites.each_with_index do |sprite, i|
- next unless sprite
- pattern = cell_data[i, 0]
- if !pattern || pattern < 0
- sprite.visible = false
- next
- end
- sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
- sprite.visible = true
- sprite.src_rect.set(pattern % 5 * 192,
- pattern % 100 / 5 * 192, 192, 192)
- if @ani_mirror && !@anime_no_mirror
- sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom
- sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
- sprite.angle = (360 - cell_data[i, 4])
- sprite.mirror = (cell_data[i, 5] == 0)
- else
- sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom
- sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
- sprite.angle = cell_data[i, 4]
- sprite.mirror = (cell_data[i, 5] == 1)
- end
- sprite.z = self.z + plus_z + i
- sprite.ox = 96
- sprite.oy = 96
- sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0
- sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0
- sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
- sprite.blend_type = cell_data[i, 7]
- end
- end
- #--------------------------------------------------------------------------
- # ● 子スプライトフラグ
- #--------------------------------------------------------------------------
- def set(battler, horming, camera_zoom, no_mirror)
- @battler = battler
- @next = true
- self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)
- self.ox = bitmap.width / 2
- self.oy = bitmap.height
- @horming = horming
- @anime_camera_zoom = camera_zoom
- @anime_no_mirror = no_mirror
- @battler.sv.reset_anime_data
- end
- #--------------------------------------------------------------------------
- # ● 子スプライト座標セット
- #--------------------------------------------------------------------------
- def set_position(z, zoom_x, zoom_y, real_x, real_y)
- self.z = z
- self.zoom_x = zoom_x
- self.zoom_y = zoom_y
- @real_x = real_x
- @real_y = real_y
- end
- #--------------------------------------------------------------------------
- # ● 他スプライトへのタイミング処理
- #--------------------------------------------------------------------------
- def other_process_timing(timing)
- se_flag = true
- se_flag = @se_flag if @se_flag != nil
- @battler.sv.timing.push([se_flag, timing.dup])
- end
- #--------------------------------------------------------------------------
- # ● 他バトラーへのタイミング処理
- #--------------------------------------------------------------------------
- def target_battler_process_timing(timing)
- for target in @timing_targets
- target.sv.timing.push([false, timing.dup])
- end
- end
- #--------------------------------------------------------------------------
- # ● SE とフラッシュのタイミング処理
- #--------------------------------------------------------------------------
- alias animation_process_timing_sprite_base_n03 animation_process_timing
- def animation_process_timing(timing)
- target_battler_process_timing(timing) if @timing_targets && @timing_targets != []
- return other_process_timing(timing) if @next != nil
- animation_process_timing_sprite_base_n03(timing)
- end
- #--------------------------------------------------------------------------
- # ● アニメーションの解放
- #--------------------------------------------------------------------------
- alias dispose_animation_sprite_base_n03 dispose_animation
- def dispose_animation
- dispose_animation_sprite_base_n03
- end
- end
- #==============================================================================
- # ■ Sprite_Battler
- #------------------------------------------------------------------------------
- # バトラー表示用のスプライトです。
- #==============================================================================
- class Sprite_Battler < Sprite_Base
- #--------------------------------------------------------------------------
- # ● 公開インスタンス変数
- #--------------------------------------------------------------------------
- attr_accessor :removing # パーティ離脱中
- #--------------------------------------------------------------------------
- # ● オブジェクト初期化
- #--------------------------------------------------------------------------
- alias initialize_sprite_battler_n03 initialize
- def initialize(viewport, battler = nil)
- initialize_sprite_battler_n03(viewport, battler)
- @real_x = @real_y = 0
- update_bitmap if @battler != nil
- end
- #--------------------------------------------------------------------------
- # ● アニメーションの開始 ★再定義
- #--------------------------------------------------------------------------
- def start_animation(animation, mirror = false)
- return next_animation(animation, mirror) if animation?
- @animation = animation
- if @animation
- @horming = @battler.sv.anime_horming
- @anime_camera_zoom = @battler.sv.anime_camera_zoom
- @anime_no_mirror = @battler.sv.anime_no_mirror
- @timing_targets = @battler.sv.timing_targets
- @plus_z = @battler.sv.anime_plus_z
- @battler.sv.reset_anime_data
- @ani_mirror = mirror
- set_animation_rate
- @ani_duration = @animation.frame_max * @ani_rate + 1
- load_animation_bitmap
- make_animation_sprites
- set_animation_origin
- end
- end
- #--------------------------------------------------------------------------
- # ● 次のアニメを開始
- #--------------------------------------------------------------------------
- def next_animation(animation, mirror)
- @next_anime = [] if @next_anime == nil
- @next_anime.push(Sprite_Base.new(viewport))
- @next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)
- @next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)
- @next_anime[@next_anime.size - 1].start_animation(animation, mirror)
- end
- #--------------------------------------------------------------------------
- # ● 影グラフィック作成
- #--------------------------------------------------------------------------
- def create_shadow
- reset_shadow
- return if @battler.sv.shadow == false
- @shadow = Sprite.new(viewport) if @shadow == nil
- @shadow.bitmap = Cache.character(@battler.sv.shadow)
- @shadow.ox = @shadow.bitmap.width / 2
- @shadow.oy = @shadow.bitmap.height / 2
- end
- #--------------------------------------------------------------------------
- # ● 影グラフィック初期化
- #--------------------------------------------------------------------------
- def reset_shadow
- return if @shadow == nil
- @shadow.dispose
- @shadow = nil
- end
- #--------------------------------------------------------------------------
- # ● 転送元ビットマップの更新 ★再定義
- #--------------------------------------------------------------------------
- def update_bitmap
- update_bitmap_enemy if !@battler.actor?
- update_bitmap_actor if @battler.actor?
- update_src_rect if @battler != nil
- update_color if @battler != nil
- end
- #--------------------------------------------------------------------------
- # ● 転送元ビットマップ:エネミー
- #--------------------------------------------------------------------------
- def update_bitmap_enemy
- if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
- @battler_name = @battler.battler_name
- @battler_hue = @battler.battler_hue
- @battler_graphic_file_index = @battler.sv.graphic_file_index
- @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
- self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)
- @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
- create_shadow
- init_visibility
- @battler_id = @battler.id
- end
- end
- #--------------------------------------------------------------------------
- # ● 転送元ビットマップ:アクター
- #--------------------------------------------------------------------------
- def update_bitmap_actor
- if @battler.character_name != @battler_name or @battler.character_index != @battler_index
- @battler_name = @battler.character_name
- @battler_index = @battler.character_index
- @battler_graphic_file_index = @battler.sv.graphic_file_index
- @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
- self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)
- @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
- create_shadow
- init_visibility
- @battler_id = @battler.id
- end
- end
- #--------------------------------------------------------------------------
- # ● 可視状態の初期化 ★再定義
- #--------------------------------------------------------------------------
- def init_visibility
- @battler_visible = @battler.alive?
- @battler_visible = true if @battler.sv.state(1) != "敌消失"
- @battler_visible = false if @battler.hidden?
- @battler.sv.opacity = 0 unless @battler_visible
- self.opacity = 0 unless @battler_visible
- self.opacity = 255 if @battler_visible
- @battler.sv.weapon_visible = @battler_visible
- end
- #--------------------------------------------------------------------------
- # ● 転送元矩形の更新
- #--------------------------------------------------------------------------
- def update_src_rect
- return if @battler.sv.collapse
- if @battler_graphic_file_index != @battler.sv.graphic_file_index
- @battler_graphic_file_index = @battler.sv.graphic_file_index
- self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?
- self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?
- @battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)
- end
- anime_off if @battler.sv.anime_off
- self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
- self.opacity = @battler.sv.opacity if @battler_visible
- set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []
- end
- #--------------------------------------------------------------------------
- # ● 位置の更新 ★再定義
- #--------------------------------------------------------------------------
- def update_position
- @real_x = @battler.sv.x / 100
- @real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100
- self.x = @real_x - $sv_camera.x
- self.y = @real_y - $sv_camera.y
- self.z = @battler.sv.z - @battler.sv.c / 100
- if @battler.sv.h <= 0
- self.x += $sv_camera.sx / 100
- self.y += $sv_camera.sy / 100
- end
- self.x *= $sv_camera.zoom
- self.y *= $sv_camera.zoom
- end
- #--------------------------------------------------------------------------
- # ● 原点の更新 ★再定義
- #--------------------------------------------------------------------------
- def update_origin
- return if !bitmap or @battler.sv.collapse
- self.ox = @battler.sv.ox
- self.oy = @battler.sv.oy
- self.angle = @battler.sv.angle
- self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom
- self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom
- self.mirror = @battler.sv.mirror if !@graphic_mirror_flag
- self.mirror = !@battler.sv.mirror if @graphic_mirror_flag
- end
- #--------------------------------------------------------------------------
- # ● 影グラフィックの更新
- #--------------------------------------------------------------------------
- def update_shadow
- @shadow.visible = @battler.sv.shadow_visible
- @shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]
- @shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]
- @shadow.x = @real_x - $sv_camera.x
- @shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y
- @shadow.z = @battler.sv.z - 10
- @shadow.zoom_x = $sv_camera.zoom
- @shadow.zoom_y = $sv_camera.zoom
- @shadow.x += $sv_camera.sx / 100
- @shadow.y += $sv_camera.sy / 100
- @shadow.x *= $sv_camera.zoom
- @shadow.y *= $sv_camera.zoom
- @shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
- end
- #--------------------------------------------------------------------------
- # ● ふきだしの更新
- #--------------------------------------------------------------------------
- def update_balloon
- if @battler.sv.balloon_data == [] && @balloon
- @balloon_data = []
- @balloon.dispose
- return @balloon = nil
- elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data
- @balloon_data = @battler.sv.balloon_data
- @balloon = Sprite.new(self.viewport)
- @balloon.bitmap = Cache.system("Balloon")
- @balloon.zoom_x = @balloon_data[3]
- @balloon.zoom_y = @balloon_data[3]
- @balloon.ox = 32 if @battler.sv.mirror
- @balloon.oy = 16
- @balloon_count = 0
- end
- return if !@balloon
- @balloon.opacity = self.opacity
- @balloon.x = self.x
- @balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom
- @balloon.z = self.z + 20
- @balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0
- @balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
- @balloon_count += 1
- @balloon_count = 0 if @balloon_count == @balloon_data[2] * 7
- end
- #--------------------------------------------------------------------------
- # ● 色調変更の更新
- #--------------------------------------------------------------------------
- def update_color
- color_set if @battler.sv.color_set != []
- return if @color_data == nil
- @color_data[4] -= 1
- if @color_data[4] == 0 && @color_data[5] != 0
- @color_data[4] = @color_data[5]
- @color_data[5] = 0
- @color_data[6] = [0,0,0,0]
- elsif @color_data[4] == 0
- @remain_color_data = @color_data
- @battler.sv.color = @color_data.dup
- return @color_data = nil
- end
- for i in 0..3
- @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
- end
- @battler.sv.color = @color_data.dup
- self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
- end
- #--------------------------------------------------------------------------
- # ● 残像の更新
- #--------------------------------------------------------------------------
- def update_mirage
- if @battler.sv.mirage == [] && @mirages
- @mirage_data = []
- for mirage in @mirages do mirage.dispose end
- return @mirages = nil
- elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data
- @mirage_data = @battler.sv.mirage
- @mirages = []
- for i in 0...@mirage_data[1] do @mirages[i] = Sprite.new(self.viewport) end
- @mirage_count = 0
- end
- return if !@mirages
- @mirage_count += 1
- @mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size
- for i in [email]0...@mirages.size[/email]
- mirage_body(@mirages[i], @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]
- end
- end
- #--------------------------------------------------------------------------
- # ● 残像本体
- #--------------------------------------------------------------------------
- def mirage_body(body, opacity)
- body.bitmap = self.bitmap.dup
- body.x = self.x
- body.y = self.y
- body.ox = self.ox
- body.oy = self.oy
- body.z = self.z - 20
- body.mirror = self.mirror
- body.angle = self.angle
- body.opacity = opacity * self.opacity / 255
- body.zoom_x = self.zoom_x
- body.zoom_y = self.zoom_y
- body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
- body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
- end
- #--------------------------------------------------------------------------
- # ● 次のアニメを更新
- #--------------------------------------------------------------------------
- def update_next_anime
- return if !@next_anime
- for anime in @next_anime
- anime.update
- anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming
- anime.dispose if !anime.animation?
- @next_anime.delete(anime) if !anime.animation?
- end
- end
- #--------------------------------------------------------------------------
- # ● フレーム更新
- #--------------------------------------------------------------------------
- alias update_sprite_battler_n03 update
- def update
- @battler.sv.update if @battler
- update_sprite_battler_n03
- update_next_anime
- update_shadow if @battler && @shadow
- update_mirage if @battler
- update_balloon if @battler
- update_remove if @battler && @removing && @battler.sv.change_up
- end
- #--------------------------------------------------------------------------
- # ● 戦闘アニメ消去
- #--------------------------------------------------------------------------
- def anime_off
- @battler.sv.anime_off = false
- dispose_animation
- for anime in @next_anime do anime.dispose_animation end if @next_anime
- end
- #--------------------------------------------------------------------------
- # ● バトラー入れ替え
- #--------------------------------------------------------------------------
- def remove
- @battler.sv.start_action(@battler.sv.remove_action)
- $sv_camera.wait = 40
- @battler.sv.add_action("eval('set_change')")
- @removing = true
- end
- #--------------------------------------------------------------------------
- # ● バトラー入れ替えの更新
- #--------------------------------------------------------------------------
- def update_remove
- @battler.sv.change_up = false
- @removing = false
- @battler = nil
- end
- #--------------------------------------------------------------------------
- # ● バトラー加入
- #--------------------------------------------------------------------------
- def join(join_battler)
- $sv_camera.wait = 30
- @battler = join_battler
- @battler_name = @battler.character_name
- @battler_index = @battler.character_index
- @battler_graphic_file_index = @battler.sv.graphic_file_index
- self.bitmap = Cache.character(@battler_name)
- @battler.sv.setup(self.bitmap.width, self.bitmap.height, true)
- create_shadow
- init_visibility
- end
- #--------------------------------------------------------------------------
- # ● 通常の設定に戻す ★再定義
- #--------------------------------------------------------------------------
- def revert_to_normal
- self.blend_type = 0
- self.opacity = 255
- end
- #--------------------------------------------------------------------------
- # ● 崩壊エフェクトの更新
- #--------------------------------------------------------------------------
- alias update_collapse_sprite_battler_n03 update_collapse
- def update_collapse
- return if @battler.sv.state(1) != "敌消失"
- update_collapse_sprite_battler_n03
- @battler.sv.weapon_visible = false
- end
- #--------------------------------------------------------------------------
- # ● ボス崩壊エフェクトの更新 ★再定義
- #--------------------------------------------------------------------------
- def update_boss_collapse
- @effect_duration = @battler.sv.ch if @effect_duration >= @battler.sv.ch
- alpha = @effect_duration * 120 / @battler.sv.ch
- self.ox = @battler.sv.cw / 2 + @effect_duration % 2 * 4 - 2
- self.blend_type = 1
- self.color.set(255, 255, 255, 255 - alpha)
- self.opacity = alpha
- self.src_rect.y -= 1
- Sound.play_boss_collapse2 if @effect_duration % 20 == 19
- end
- #--------------------------------------------------------------------------
- # ● 別スプライトからのタイミング処理
- #--------------------------------------------------------------------------
- def set_process_timing(timing_data)
- for data in timing_data
- set_timing(data[0],data[1])
- end
- @battler.sv.timing = []
- end
- #--------------------------------------------------------------------------
- # ● タイミング処理
- #--------------------------------------------------------------------------
- def set_timing(se_flag, data)
- @ani_rate = 4
- data.se.play if se_flag
- case data.flash_scope
- when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)
- when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport
- when 3 ;self.flash(nil, data.flash_duration * @ani_rate)
- end
- end
- #--------------------------------------------------------------------------
- # ● 色調変更
- #--------------------------------------------------------------------------
- def color_set
- set = @battler.sv.color_set
- @battler.sv.color_set= []
- set[4] = 1 if set[4] == 0
- @remain_color_data = [0,0,0,0] if @remain_color_data == nil
- @color_data = @remain_color_data
- @color_data[4] = set[4]
- @color_data[5] = set[5]
- @color_data[6] = set
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- alias dispose_sprite_battler_n03 dispose
- def dispose
- dispose_sprite_battler_n03
- @shadow.dispose if @shadow != nil
- @balloon.dispose if @balloon != nil
- for mirage in @mirages do mirage.dispose end if @mirages != nil
- for anime in @next_anime do anime.dispose end if @next_anime
- end
- end
- #==============================================================================
- # ■ Spriteset_Battle
- #------------------------------------------------------------------------------
- # バトル画面のスプライトをまとめたクラスです。
- #==============================================================================
- class Spriteset_Battle
- #--------------------------------------------------------------------------
- # ● 戦闘背景(床)スプライトの作成 ★再定義
- #--------------------------------------------------------------------------
- def create_battleback1
- @back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)
- @back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil
- @back1_sprite.z = 0
- end
- #--------------------------------------------------------------------------
- # ● 戦闘背景(壁)スプライトの作成 ★再定義
- #--------------------------------------------------------------------------
- def create_battleback2
- @back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)
- @back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil
- @back2_sprite.z = 1
- end
- #--------------------------------------------------------------------------
- # ● アクタースプライトの作成 ★再定義
- #--------------------------------------------------------------------------
- def create_actors
- @actor_sprites = []
- for i in 0...$game_party.max_battle_members
- @actor_sprites[i] = Sprite_Battler.new(@viewport1, $game_party.members[i])
- end
- @effect_sprites = Spriteset_Sideview.new(@viewport1)
- end
- #--------------------------------------------------------------------------
- # ● アクタースプライトの更新 ★再定義
- #--------------------------------------------------------------------------
- def update_actors
- @actor_sprites.each_with_index do |sprite, i|
- sprite_join($game_party.members[i], sprite) if sprite.battler == nil && sprite.battler != $game_party.members[i]
- sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members[i]
- sprite.update
- end
- @effect_sprites.update
- update_program
- end
- #--------------------------------------------------------------------------
- # ● メンバーを加える
- #--------------------------------------------------------------------------
- def sprite_join(member, sprite)
- for sp in @actor_sprites
- sp.update_remove if member == sp.battler && !sp.battler.sv.change_up
- end
- sprite.join(member)
- end
- #--------------------------------------------------------------------------
- # ● バトルプログラムの更新
- #--------------------------------------------------------------------------
- def update_program
- return if $sv_camera.program_scroll == []
- for data in $sv_camera.program_scroll
- @back1_sprite.start_back_data(data) if data[2] == 1
- @back2_sprite.start_back_data(data) if data[2] == 2
- end
- $sv_camera.program_scroll = []
- end
- #--------------------------------------------------------------------------
- # ● ヒット時の戦闘アニメ実行
- #--------------------------------------------------------------------------
- def set_hit_animation(battler, weapon_index, hit_targets, miss)
- @effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)
- end
- #--------------------------------------------------------------------------
- # ● ダメージPOP
- #--------------------------------------------------------------------------
- def set_damage_pop(target)
- @effect_sprites.set_damage_pop(target)
- end
- #--------------------------------------------------------------------------
- # ● 解放
- #--------------------------------------------------------------------------
- alias dispose_spriteset_battle_n03 dispose
- def dispose
- dispose_spriteset_battle_n03
- @effect_sprites.dispose
- end
-
-
-
- end
- #==============================================================================
- # ■ Window_BattleLog
- #------------------------------------------------------------------------------
- # 戦闘の進行を実況表示するウィンドウです。
- #==============================================================================
- class Window_BattleLog < Window_Selectable
- #--------------------------------------------------------------------------
- # ● ウェイト ★再定義
- #--------------------------------------------------------------------------
- def wait
- end
- #--------------------------------------------------------------------------
- # ● ウェイトとクリア ★再定義
- #--------------------------------------------------------------------------
- def wait_and_clear
- $sv_camera.wait = 10
- end
- #--------------------------------------------------------------------------
- # ● 行動結果の表示 ★再定義
- #--------------------------------------------------------------------------
- def display_action_results(target, item)
- if target.result.used
- last_line_number = line_number
- display_critical(target, item)
- display_damage(target, item)
- display_affected_status(target, item)
- display_failure(target, item)
- end
- off if !N03::BATTLE_LOG
- end
- #--------------------------------------------------------------------------
- # ● ウインドウ非表示
- #--------------------------------------------------------------------------
- def off
- @back_sprite.visible = self.visible = false
- end
- end
- #==============================================================================
- # ■ Game_Interpreter
- #------------------------------------------------------------------------------
- # イベントコマンドを実行するインタプリタです。
- #==============================================================================
- class Game_Interpreter
- #--------------------------------------------------------------------------
- # ● スイッチの操作
- #--------------------------------------------------------------------------
- alias command_121_game_interpreter_n03 command_121
- def command_121
- command_121_game_interpreter_n03
- $sv_camera.program_check
- end
- end
复制代码
|
|