VX-横版-敌人死亡..还会出现残影.如何克服?谢谢

lsu666666 · 发表于 2011-6-26 04:24:18

本帖最后由 lsu666666 于 2011-6-26 04:38 编辑

这是战斗开始画面2之敌人
[img=545,321][/img]

打死一只之后剩下一只敌人

[img=545,321][/img]

过几秒钟..画面还会出现已经死亡的敌人残影
[img=545,321][/img]

大约不到1秒钟又消失了
[img=545,321][/img]
请教高手应该如何克服这问题......谢谢

以下是我安装的横版战斗脚本代码

Sideview Ver3.3

#==============================================================================
# ■ module N01 for Sideview Ver3.3
#------------------------------------------------------------------------------
# 　
#原版的网址 http://rpgex.sakura.ne.jp/home/sozai/sozai_top.html#VXブー
#
# 横版战斗系统设定项目。
#==============================================================================
module N01
#--------------------------------------------------------------------------
# ● 设定
#--------------------------------------------------------------------------
# 主人公初期位置　第一人第二人第三人第四人
# X轴 Y轴 X轴 Y轴 X轴 Y轴 X轴 Y轴
ACTOR_POSITION = [[415,120],[435,150],[455,180],[475,210]]
# 战斗成员最大数(可改动人数) 当人数变动时，上方的坐标也要相应变动
MAX_MEMBER = 4
# 战斗中行动结束后、到下个角色行动开始之间的等待时间。
ACTION_WAIT = 10
# 敌方溃败(被击破时的退场)前的等待时间
COLLAPSE_WAIT = 12
# 胜利前的等待时间
WIN_WAIT = 70
# 战斗背景在画面中位置的设定 FLOOR = [ X轴, Y轴, 透明度]
FLOOR = [ 0, 96,128]
# 未装备武器地情况下攻击时显示的动画ID
NO_WEAPON = 82
# 二刀流设定当双手装备武器时一次攻击的伤害数值。数值为%
# 　通常攻击技能、物品
TWO_SWORDS_STYLE = [ 50, 100]
# 状态扩张・自动复活的动画ID
RESURRECTION = 41
# 伤害数字图片的文件名(横向等距的从零到九依次排列的图片)
DAMAGE_GRAPHICS = "Number+"
# 回复数字图片的文件名
RECOVER_GRAPHICS = "Number-"
# 显示数值时的文字间隔
NUM_INTERBAL = -3
# 显示数值时的显示时间
NUM_DURATION = 68
# 伤害窗口关闭、只显示文字时的情况是true
NON_DAMAGE_WINDOW = false
# 伤害窗口中所显示的词语。如果不想显示的情况请""这样消除掉引号中内容即可。
POP_DAMAGE0 = "" # 伤害数值为0时(数字0将不被显示)
POP_MISS = "MISS！" # 攻击因攻击者原因没有击中时　　
POP_EVA = "MISS！" # 攻击因被被攻击者躲开时　
POP_CRI = "会心一击！" # 会心一击
POP_MP_DAM = "伤害MP" # 受到MP的伤害时
POP_MP_REC = "回复MP" # 回复MP时
# 阴影效果　使用的话是true不使用时是false
SHADOW = true
# 识别步行效果　在战斗中人物使用步行效果的话是true不使用时是false
# false的情况下、一定要使用自己的行走图，不要使用脚本范例中的。
# 还有，No1之后的图片大小要统一(不是全人物统一，单一人物的统一即可)
WALK_ANIME = true
# 角色战斗图中用图的动画动作格数（横分割数）
ANIME_PATTERN = 3
# 角色战斗图中用图的动画种类数（纵分割数）
ANIME_KIND = 4
# 背后攻击(偷袭时的画面反转)　使用的话是true不使用的是false
BACK_ATTACK = true
# 背后攻击时战斗背景不反转的情况是false
BACK_ATTACK_NON_BACK_MIRROR = true
# 将背后攻击设置为无效时偷袭效果依然发挥。
# 全部都是装备上所需装备时、发挥技能时，才会有效果。
# 防止背后攻击的武器ID　举例) = [1]　多数时的举例) = [1,2]
NON_BACK_ATTACK_WEAPONS = []
# 防止背后攻击的盾ID
NON_BACK_ATTACK_ARMOR1 = []
# 防止背后攻击的头部防具ID
NON_BACK_ATTACK_ARMOR2 = []
# 防止背后攻击的身体防具ID
NON_BACK_ATTACK_ARMOR3 = []
# 防止背后攻击的装饰品ID
NON_BACK_ATTACK_ARMOR4 = []
# 防止背后攻击的技能ID
NON_BACK_ATTACK_SKILLS = []
# 一定会发生背后攻击的开关No(会优先于防止)
BACK_ATTACK_SWITCH = []
#==============================================================================
# ■ 单独战斗动作
#------------------------------------------------------------------------------
# 　使用的是连贯动作，这里的单独是没有意义的。
#==============================================================================
# 这里的单独动作名，请不要重复。
# 与连贯动作名重复没有问题。
ANIME = {
#--------------------------------------------------------------------------
# ● 角色动画的设定
#--------------------------------------------------------------------------
# 文件No…使用战斗动作图的号码。
# 0的情况是使用行走图对应。
# 1以后的是像"人物行走图文件名+_1"这样，参照文件名后的附加数字
# 来判别的。例)$拉尔夫_1　的文件名No是1
# 战斗动作图全部都是从人物行走图文件夹内读取。
#
# 种类…战斗动作图的分隔纵列。从上开始0到3依次。
# 速度…动画的更新速度。数值越低更新速度越快。
# 循环… [0=往复循环] [1=循环一次] [2=不循环]
# 等待…不循环(2)的情况下、到动画显示结束的等待时间。
# 固定…如果动画不作固定的情况、指定分割号码(横向位置)。不固定的情况是-1。反向再生是-2。
# Z轴…在面前显示的话是正数。相较通常情况靠前的显示。
# 影…表示阴影效果的话是true、不表示为false
# 武器…武器表示的情况填入武器动作名。不表示的情况为""。
# 目标动画名文件No 种类速度循环等待固定 Z轴影武器
"待机" => [ 0, 1, 15, 0, 0, -1, 0, true,"" ],
"待机(固定)" => [ 0, 1, 10, 2, 0, 1, 0, true,"" ],
"向右(固定)" => [ 0, 2, 10, 1, 2, 1, 0, true,"" ],
"伤害" => [ 0, 3, 4, 2, 0, -1, 0, true,"" ],
"无法战斗" => [ 0, 3, 10, 1, 8, 0, 0, true,"" ],
"前进" => [ 0, 1, 1, 1, 0, -1, 0, true,"" ],
"后退" => [ 0, 2, 2, 1, 0, -1, 0, true,"" ],
"头上显示" => [ 0, 1, 2, 1, 0, -1, 600, true,"" ],
"武器挥动攻击" => [ 0, 1, 1, 2, 0, -1, 2, true,"纵挥动"],
"武器挥动攻击L" => [ 0, 1, 1, 2, 0, -1, 2, true,"纵挥动L"],
"武器挥动攻击缓" => [ 0, 1, 6, 2, 0, -1, 2, true,"纵挥动"],
"武器下旋转" => [ 0, 1, 2, 2, 0, -1, 2, true,"下旋转"],
"武器上旋转" => [ 0, 1, 2, 2, 0, -1, 2, true,"上旋转"],
"举起武器" => [ 0, 1, 2, 2, 28, -1, 2, true,"举起"],
#--------------------------------------------------------------------------
# ● 武器动作　让武器图像动起来的方法
#--------------------------------------------------------------------------
# 这里使用的武器动作名、必须是上面角色动画中设置的武器动作名。
# X轴…横向移动距离。
# Y轴…纵向移动距离。
# Z轴…如果让此动作显示时武器在人物前方写作true。
# 初始角度…武器在动作前的最初角度。半圆的0～360度。复数情况为反半圆。
# 完毕角度…动作完毕时的角度。
# 原点…武器旋转时的原点。[0…中心] [1…左上] [2…右上] [3…左下] [4…右下]
# 反转…当为true时，动作前武器的图像将会显示为反转的。
# X扩…X轴放大率、武器横向放大率。1是同等、2是2倍、0.5是1/2。
# Y扩…Y轴放大率、武器纵向放大率。1是同等、2是2倍、0.5是1/2。
# 调X…略微调整X轴。这里的数字是调整武器初期的X坐标。
# 调Y…略微调整Y轴。这里的数字是调整武器初期的Y坐标。
# 二刀…限定于二刀流为true、将以二刀流来显示左边武器动作的武器画像。
# 如果不是二刀流的情况会自动跳过角色动画。
# 武器动作名　　 X轴 Y轴 Z轴初始角度完毕角度原点反转 X扩 Y扩调X 调Y 二刀
"纵挥动" => [ 6, 8,false,-135, 45, 4,false, 1, 1, -4, -6,false],
"纵挥动L" => [ 6, 8,false,-135, 45, 4,false, 1, 1, -4, -6, true],
"下旋转" => [ 6, 8,false, 270, 45, 4,false, 1, 1, -4, -6,false],
"上旋转" => [ 6, 8,false, 45,-100, 4,false, 1, 1, -4, -6,false],
"举起" => [ 6, -4,false, 90, -45, 4,false, 1, 1, -4, -6,false],
#--------------------------------------------------------------------------
# ● 角色移动敌方的X轴移动是以相反的复数计算。
#--------------------------------------------------------------------------
# 目标…坐标移动的参照 [0=自身现在的位置] [1=目标] [2=窗口] [3=初期位置]
# X轴…从对像所看X坐标。绝对值就算是最低时也会比时间高
# Y轴…从对像所看Y坐标。绝对值就算是最低时也会比时间高
# 时间…移动时间。数值越大越缓慢。这里是用距离除以时间所得每格行动距离。
# 加速…正数是加速、负数是减速。这里是每格行动的加速或减速。
# 跳跃…跳跃轨道。正数是向下跳、负数是向上跳。0是不跳。
# 动画…这里的移动所使用的角色动画名。
# 目标 X轴 Y轴时间加速跳跃动画
"不能移动" => [ 0, 0, 0, 1, 0, 0, "待机(固定)"],
"到战斗开始的位置" => [ 0, 54, 0, 1, 0, 0, "前进"],
"一步向前移动" => [ 3, -32, 0, 18, -1, 0, "前进"],
"一步向后移动" => [ 0, 32, 0, 8, -1, 0, "前进"],
"四人攻击移动1" => [ 2, 444, 96, 18, -1, 0, "前进"],
"四人攻击移动2" => [ 2, 444, 212, 18, -1, 0, "前进"],
"四人攻击移动3" => [ 2, 384, 64, 18, -1, 0, "前进"],
"四人攻击移动4" => [ 2, 384, 244, 18, -1, 0, "前进"],
"被伤害" => [ 0, 32, 0, 4, -1, 0, "伤害"],
"推动" => [ 0, 12, 0, 1, 1, 0, "伤害"],
"我方逃走" => [ 0, 300, 0,300, 1, 0, "后退"],
"逃走失败" => [ 0, 48, 0, 16, 1, 0, "后退"],
"胜利的跳跃" => [ 0, 0, 0, 20, 0, -5, "前进"],
"目标移动" => [ 1, 0, 0, 18, -1, 0, "前进"],
"目标高速移动" => [ 1, 0, -12, 8, 0, -2, "前进"],
"目标向前移动" => [ 1, 24, 0, 12, -1, 0, "前进"],
"目标向前高速移动" => [ 1, 24, 0, 1, 0, 0, "前进"],
"目标右前移动" => [ 1, 96, 32, 16, -1, 0, "前进"],
"目标左前移动" => [ 1, 96, -32, 16, -1, 0, "前进"],
"一步向前跳跃" => [ 0, -32, 0, 8, -1, -4, "前进"],
"一步向后跳跃" => [ 0, 32, 0, 8, -1, -4, "后退"],
"跳跃到目标" => [ 1, 12, -12, 12, -1, -6, "前进"],
"投掷我方" => [ 0, -24, 0, 16, 0, -2, "前进"],
"强力踩踏" => [ 1, 12, -32, 12, -1, -6, "头上显示"],
"一步向前跳跃敲击" => [ 0, -32, 0, 12, -1, -2, "武器挥动攻击"],
"向前跳跃敲击" => [ 1, 12, 0, 12, -1, -5, "武器挥动攻击缓"],
"对后方给予提高" => [ 1, 12, 0, 16, 0, -3, "武器挥动攻击"],
"原地跳跃敲击" => [ 1, 0, 0, 16, 0, -5, "武器挥动攻击"],
"拔出" => [ 1, -96, 0, 16, 2, 0, "武器挥动攻击"],
"右拔出" => [ 1, -96, 32, 16, 2, 0, "武器挥动攻击"],
"左拔出" => [ 1, -96, -32, 16, 2, 0, "武器挥动攻击"],
"右拔出2" => [ 1,-128, 48, 16, 2, 0, "武器挥动攻击"],
"左拔出2" => [ 1,-128, -48, 16, 2, 0, "武器挥动攻击"],
#--------------------------------------------------------------------------
# ● 角色漂浮角色与影子脱离
#--------------------------------------------------------------------------
# 判别…用来判别的、请全部统一填入"float"。
# 始高…开始漂浮的高度。负数情况是在影子之上、正数是在影子下方。
# 终高…漂浮完毕的高度。因为动作系需要使用这个数值，请不要变动。
# 时间…漂浮过程所用时间。
# 动画…漂浮时候所用的角色动画名。
# 　判别始高终高时间动画
"低空漂浮中" => ["float", -22, -20, 2, "待机(固定)"],
"低空漂浮中2" => ["float", -20, -18, 2, "待机(固定)"],
"低空漂浮中3" => ["float", -18, -20, 2, "待机(固定)"],
"低空漂浮中4" => ["float", -20, -22, 2, "待机(固定)"],
"跳跃停止" => ["float", 0, -80, 4, "待机(固定)"],
"跳跃着地" => ["float", -80, 0, 4, "待机(固定)"],
"抬起" => ["float", 0, -30, 4, "待机(固定)"],
#--------------------------------------------------------------------------
# ● 坐标初始化　返回到原始位置的移动设置
#--------------------------------------------------------------------------
# 判别…用来判别的、请全部统一填入"reset"。
# 时间…返回过程所用时间。即使是同样的时间如果距离远的情况下移动速度也会发生变化。
# 加速…正数为加速、负数为减速。这里是每格行动的加速或减速。
# 跳跃…跳跃轨道。正数为向下跳、负数为向上跳。0是不跳。
# 动画…这里移动时使用的角色动画名。
# 　判别时间加速跳跃动画
"坐标初始化" => ["reset", 16, 0, 0, "前进"],
"后退初始化" => ["reset", 16, 0, 0, "后退"],
#--------------------------------------------------------------------------
# ● 强制动作　被动形成的目标动作
#--------------------------------------------------------------------------
# 识别…被动形成的动作是单独还是连贯。"单独"时直接填入单独即可。
# "连贯"时请填入连贯。
#
# 对像…获取是指动作的对象。0是目标、除他以外的处于那个状态No
# 的全部角色视为对象。
# 数值前有负号的就会习得此数字绝对值的数字对应的技能ID上的技能
# 除自身以外的主人公作为对像(主人公限定)
# 指定引取的情况(成员位置)、引取值填入1000。
# 指定的引取是自身不在的情况(无法战斗或是逃走时)
# 从零号开始顺次参照、所有角色界不在为时，行动中段。
#
# 恢复…动作后返回原始坐标的目标动作名。
# 不返回的情况以这样""不填任何东西即可。
# 动作名…强制动作的动作名。识别是单独的话、使用单独动作名。
# 连贯的话就用连贯动作名（组合动作）。
# 识别对像恢复动作名
"轻微吹动" => ["单独", 0, "坐标初始化", "推动"],
"右旋转" => ["单独", 0, "坐标初始化", "右旋转一周"],
"纵向压扁" => ["单独", 0, "坐标初始化", "纵向缩小"],
"中弹1" => ["单独", 0, "坐标初始化", "从对像到自身1"],
"举起我方" => ["单独", 0, "", "抬起"],
"吴莉嘉连同攻击" => ["连贯", 18, "坐标初始化", "吴莉嘉合体攻击1"],
"四人攻击1" => ["连贯", -101, "坐标初始化", "四人合体攻击1"],
"四人攻击2" => ["连贯", -102, "坐标初始化", "四人合体攻击2"],
"四人攻击3" => ["连贯", -103, "坐标初始化", "四人合体攻击3"],
"将我方投掷飞出" => ["连贯", 1000, "坐标初始化", "可以投掷"],
#--------------------------------------------------------------------------
# ● 目标变更改变现在角色作为目标对象的
#--------------------------------------------------------------------------
# ※只是改变战斗动作上的目标、战斗的目标不改变。
# 只能是实行战斗中的角色执行。
# 判别…因为使用于判别、请全部统一填入"target"。
#
# 对像…被变更目标的对象。0是目标、改变这个目标以外处于那个状态No中
# 角色的全部对象。
# 数值前有负号的就会习得此数字绝对值的数字对应的技能ID上的技能（我方队员为对像）。
# 指定引取的情况(成员位置)、引取值填入1000。
# 指定的引取是自身不在的情况(无法战斗或是逃走时)
# 从零号开始顺次参照。
#
# 变更处…变更处内容 0=自身 1=自身的目标　
# 2=成为自身的目标后、再将自己的目标变为变更对像
# 3=将已变更为自身的目标返还(必须是在实行过2的情况下下)
# 目标变更名判别对像变更先
"以自身为目标" => ["target", 0, 0],
"二人攻击目标统一" => ["target", 18, 1],
"四人攻击目标统一" => ["target", 19, 1],
"选择投掷角色" => ["target", 1000, 2],
"投掷目标组合" => ["target", 1000, 3],
#--------------------------------------------------------------------------
# ● 技能连发中断动作后、其他技能被连发出来
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"der"。
# 确率…连发的成功率、0～100之间。如果没有被连发、剩下的动作继续执行。
# 习得…如果连发的技能没有被习得也可以实行的话是true
# 技能ID…连发的技能的ID
# 连发名判别确率习得技能ID
"回复连发" => ["der", 100, true, 91],
"适当连发" => ["der", 100, true, 92],
#--------------------------------------------------------------------------
# ● 动作条件设定条件、满足条件以后将停止所有行动
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"nece"。
# 对像…用于条件参照的对象。[0=自分] [1=目标] [2=敌全体] [3=我方全体]
# 内容… [0=状态] [1=参数] [2=开关] [3=变量] [4=习得技能]
#
# 条件…填入符合上边内容确定的项目的数值。
# [0]状态…状态ID
# [1]参数…[0=现HP] [1=现MP] [2=攻击力] [3=防御力] [4=精神力] [5=敏捷性]
# [2]开关…游戏中的开关No
# [3]变量…游戏中的变量No
# [4]习得技能…习得特定技能的条件、将那个技能的ID编号填入。
#
# 补足…补足上边的条件。
# [0]状态…成为条件的被施加状态的人数。
# 符号为正号时是需要此号码对应条件，负号时为不需要。
# [1]参数…参数的数值。对像为复数时，将取平均值。
# 符号为正的数值以上、以及负的数值以下作为条件。
# [2]开关…开关ON为条件是 true、OFF为条件是 false
# [3]变量…符号为正的数值以上、以及负的数值以下作为条件。
# [4]习得技能…作为条件的技能所习得的人数。
# 连发名判别对像内容条件补足
"二人攻击条件确认" => ["nece", 3, 0, 18, 1],
"四人攻击条件确认" => ["nece", 3, 0, 19, 3],
"漂浮状态确认" => ["nece", 0, 0, 17, 1],
"是否已变身成猫"=> ["nece", 0, 0, 20, 1],
"死亡确认" => ["nece", 1, 0, 1, 1],
#--------------------------------------------------------------------------
# ● 角色旋转　画像旋转。与反转不同、武器动作不能被反映
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"angle"。
# 时间…旋转过程所需时间。
# 初始角度…旋转开始时的角度。指定于0～360度之间。正数为正半圆、负数为反半圆。
# 完毕角度…旋转完毕时的角度。指定于0～360度之间。跟上边所记相同，但敌人的设定是与其相反的。
# 回复…true是在完毕的同时恢复到通常角度。false是保持最后着动作。
# 　判别时间初始角度完毕角度回复
"倒下" => ["angle", 1, -90, -90,false],
"右旋转一周" => ["angle", 48, 0,-360,false],
"左高速旋转" => ["angle", 6, 0, 360,false],
#--------------------------------------------------------------------------
# ● 角色放大缩小　武器动作不能被反映
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"zoom"。
# 时间…放大缩小过程所需时间。
# X扩…横向的放大率。1.0是等倍、0.5是原有的一半。
# Y扩…纵向的放大率。1.0是等倍、0.5是原有的一半。
# 回复…true是在完毕的同时还原成等倍。false是保持完毕时的样子。
# 放大缩小时会一时变更当前对象的原点、在恢复的时候复原。
# 　判别时间 X扩 Y扩回复
"横向缩小" => ["zoom", 16, 0.5, 1.0, true],
"纵向缩小" => ["zoom", 16, 1.0, 0.5, true],
#--------------------------------------------------------------------------
# ● 战斗动画　显示数据库的战斗动画
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"anime"。
# ID…动画ID。-1时将显示武器或者技能上设定的动画的伤害。
# -2时技能也变成武器上所带的动画。
# 对像… [0=自身] [1=目标]
# 反转…true时动画地画像将被反转。
# 等待…一直在动画显示完毕都存在的话是true。
# 二刀用…true时将实行二刀流的动画。动画ID为-1时通常攻击的情况
# 设定成显示为左手武器的动画。技能是技能动画的在实行。
# 判别 ID 对像反转等待二刀用
"对像动画" => ["anime", -1, 1, false,false, false],
"对像动画等待"=> ["anime", -1, 1, false, true, false],
"对像动画武器" => ["anime", -2, 1, false,false, false],
"对像动画L" => ["anime", -1, 1, false,false, true],
"打击动画" => ["anime", 1, 1, false,false, false],
"斩击/必杀技1" => ["anime", 11, 1, false,false, false],
#--------------------------------------------------------------------------
# ● 动画飞出　让战斗动画飞出去。飞行道具、远距离攻击用
#--------------------------------------------------------------------------
# ID…数据库里设定的动画ID。0是不显示动画。
# 对像…飞出的对象 [0=目标] [1=敌全体的中心] [2=我方全体的中心] [4=自身]
# 类型…[0=碰撞时消失] [1=直线贯穿]
# 时间…动画飞出去时候的移动时间。数值越大速度越缓慢。
# 轨道…动画飞出去时候的轨道。填入数值的话是走抛物线。正数为向下的抛物线、负数为向上。
# 调X…略微调整X轴。改变飞出时的初期X坐标。敌方的情况是自动的反向运算。
# 调Y…略微调整Y轴。改变飞出时的初期Y坐标。
# 始…动画飞出时的开始位置。[0=自身] [1=对像] [2=不能移动]
# Z坐标…动画或者武器在角色面前显示的话是true
# 武器…填入下面贴附的武器、技能动作名。如果不是用为""
# 判别 ID 对像类型时间轨道调X 调Y 始 Z坐标武器
"魔法发动动画" => ["m_a", 44, 4, 0, 52, 0, 0, 0, 2,false,""],
"从对像到自身1" => ["m_a", 4, 0, 0, 24, 0, 0, 0, 1,false,""],
"开始武器投掷" => ["m_a", 0, 0, 0, 18, -24, 0, 0, 0,false,"旋转投掷"],
"放弃武器投掷" => ["m_a", 0, 0, 0, 18, 24, 0, 0, 1,false,"旋转投掷"],
"全体动画单体化"=> ["m_a", 80, 1, 0, 64, 0, 0, 0, 2, true,""],
#--------------------------------------------------------------------------
# ● 动画飞出时贴附的武器图像动画　专用于上面的武器飞出
#--------------------------------------------------------------------------
# 让贴附的武器图片动。这个画像可以和和武器动作的画像区分使用。
# 那样的情况贴附的图像请去武器设定。
# 初始角度…动作前的最初角度。前半圆0～360度。
# 完毕角度…动作后的角度。前半圆0～360度。
# 时间…旋转过程需要的时间。越小越快。动作到消失前持续保持旋转。
# 武器动作名　　初始角度完毕角度时间
"旋转投掷" => [ 0, 360, 8],
#--------------------------------------------------------------------------
# ● 动画飞出时贴附的技能画像动画　专用于上边的动画飞出
#--------------------------------------------------------------------------
# 让贴附的技能图片动。能够贴附的图像在技能设定上。
# 初始角度…动作前的最初角度。前半圆0～360度。
# 完毕角度…动作后的角度。前半圆0～360度。
# 时间…旋转过程所需要的时间。越小越快。动作到消失前持续保持旋转。
# 判别…用于判别、请全部统一填入"skill"。
# 武器动作名　　初始角度完毕角度时间判别
"石投掷" => [ 0, 360, 8, "skill"],
#--------------------------------------------------------------------------
# ● 状态动画　显示事件使用的状态ICON
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"balloon"。
# 种类…状态的种类(纵位置)在0～9之间。
# 形式…动画更新方法、在完毕时消失。[0=单线] [1=往返]
# 状态名　　判别种类形式
"异常状态/通用" => ["balloon", 6, 1],
"异常状态/危急" => ["balloon", 5, 1],
"异常状态/睡眠" => ["balloon", 9, 1],
#--------------------------------------------------------------------------
# ● 声效
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"sound"。
# 种别…效果音为"se" BGM为"bgm" BGS为"bgs"
# 速度…速度、50～150之间。音量…音量　不管哪个都要默认为100。
# 文件名…播放的文件名。""时不改变任何BGM和BGS的设定。
# SE名判别种别速度音量 SE文件名
"absorb1" => ["sound", "se", 80, 100, "absorb1"],
#--------------------------------------------------------------------------
# ● 变更游戏整体速度动作的慢放化
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"fps"。
# 游戏速度…60是默认的数值、比这个值低的时候就会放慢。　
# ※这个指令也可以直接变更FPS。请注意处理。
# 变更名判别游戏速度
"缓慢再生" => ["fps", 20],
"通常再生" => ["fps", 60],
#--------------------------------------------------------------------------
# ● 赋予状态
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"sta+"。
# 对像…[0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=除自身以外的我方全体]
# 状态ID…赋予的状态ID编号。“不能抵抗”状态以外为抵抗。
# 赋予的状态名判别对像状态ID
"赋予二人攻击状态" => ["sta+", 0, 18],
"赋予四人攻击状态" => ["sta+", 0, 19],
"猫" => ["sta+", 0, 20],
#--------------------------------------------------------------------------
# ● 状态解除
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"sta-"。
# 对像…[0=自分] [1=目标] [2=敌全体] [3=我方全体] [4=除自身以外的我方全体]
# 状态ID…解除的状态ID编号
# 赋予的状态名判别对像状态ID
"解除二人攻击状态" => ["sta-", 3, 18],
"解除四人攻击状态" => ["sta-", 3, 19],
#--------------------------------------------------------------------------
# ● 角色画像文件变更只能使用于主人公们
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"change"。
# 复原…战斗后也显示为变化的是false。行走图也将变化。
# 文件名…变更为的文件名。因为要改变识别处，请不要用文件名加"_1"后缀的方式。
# 变更名判别复原文件名
"变身成猫" => ["change", true,"$cat"],
"解除变身" => ["change", true,"$ylva"],
#--------------------------------------------------------------------------
# ● 图片显示一名角色对应显示一枚图片
#--------------------------------------------------------------------------
# 始X…移动开始位置。从画面所看的X坐标。图片是以左上为原点。
# 始Y…移动开始位置。从画面所看的Y坐标。
# 终X…移动完毕X坐标。
# 终Y…移动完毕Y坐标。
# 时间…移动时间。数值越大越缓慢。这里是用距离除以时间所得每格行动距离。
# Z轴…相较HP窗口靠前显示的话为true
# 图片文件名…图片文件夹内的文件名。
# 判别始X 始Y 终X 终Y 时间 Z轴图片文件名
"特写1开始" => ["pic",-280, 48, 0, 64, 14,false,"Actor2-3"],
"特写1完毕" => ["pic", 0, 48, 550, 64, 12,false,"Actor2-3"],
#--------------------------------------------------------------------------
# ● 游戏开关的设置
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"switch"。
# 开关No…设置哪个开关
# ON/OFF…将开关ON时是true、OFF时是false
#
# 开关设置名判别开关No ON/OFF
"开关No1/ON" => ["switch", 1, true],
#--------------------------------------------------------------------------
# ● 游戏变量的设置
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"variable"。
# 变量No…设置哪个开关
# 设置…[0=代入] [1=加法] [2=减法] [3=乘法] [4=除法] [5=剩余]
# 设置数值…指定成为演算对象的数值。
#
# 变量设置名　　判别变量No 设置设置数值
"变量No1/+1" => ["variable", 1, 1, 1],
#--------------------------------------------------------------------------
# ● 脚本运行的设置
#--------------------------------------------------------------------------
# 判别…用于判别、请全部统一填入"script"。
#
# 使动作被添加到建议的脚本中。样品p = 1可以添加任何自己想要设置的脚本。
# 功能中、不能处理文字列。
#
# 　　设置名　　判别
"检测程序" => ["script", "
p = 1
"],
#--------------------------------------------------------------------------
# ● 其他　没有设定项目。这里所使用的名称请不要改动。
#--------------------------------------------------------------------------
# 消去图片…消除显示的图片。
# 残像ON…留下角色轨迹中的残像。持续连贯动作中的残像。
# 残像OFF…消除残像。
# 反转…反转画像。是再次被反转回去，还是坐标不复原保持着反转后的样子。
# 待机不能移动…行动后、不做待机动作。
# 击倒许可…目标的HP变成0时、在这个时机可以被击倒。
# 如果这段没有的话，怪会在所有动作完成时被击倒。
# 限定于二刀…只是这个下面的单独动作、限定于二刀来处理。
# 如果不是二刀的话将会跳过、直接执行下一个单独动作。
# 非限定于二刀…与上边相反，只有在不是二刀的情况下个动作才会有效。
# 单独处理开始…在全体攻击处理成单独时、是播放行动的开始记号。
# 单独处理完毕…在全体攻击处理成单独时、是播放行动的完毕记号。
# 变更初期位置…原坐标(初期位置)变成现在的位置。
# 解除变更初期位置…将变更初期位置还原。
# 解除主动…当作战斗行动完毕、下一个角色开始行动。
# 击倒许可设置也被含在其中、在这之后的所有动作都不会再对对像做出伤害。
# 完毕…行动完毕。就算没有这里，在所有动作完毕后也会自动识别成完毕。
"消去图片" => ["消去图片"],
"残像ON" => ["残像ON"],
"残像OFF" => ["残像OFF"],
"反转" => ["反转"],
"待机不能移动"=> ["待机不能移动"],
"击倒许可" => ["击倒许可"],
"限定于二刀" => ["限定于二刀"],
"非限定于二刀" => ["非限定于二刀"],
"单独处理开始" => ["单独处理开始"],
"单独处理完毕" => ["单独处理完毕"],
"变更初期位置" => ["变更初期位置"],
"解除变更初期位置"=> ["解除变更初期位置"],
"解除主动" => ["解除主动"],
"完毕" => ["完毕"]
#--------------------------------------------------------------------------
# ● 等待相关
#--------------------------------------------------------------------------
# 单独动作上只有数值时、将会直接判定为等待时间。
# 总之，请不要用只有数字的单独动作名。
# 等待是到下一个动作执行前的等待时间、角色动画的更新不会被停止
}
#==============================================================================
# ■ 连贯动作
#------------------------------------------------------------------------------
# 　将上边的单独动作组合起来、这里是实际做出的动作。
#==============================================================================
# 这里的连贯动作名将是下面主人公或者敌方所指定用的。
# 行动会从左到右依次进行。
ACTION = {
#------------------------------- 待机系 -----------------------------------------
# 连贯动作名行动
"战斗开始" => ["到战斗开始的位置","坐标初始化"],
"待机" => ["待机"],
"危急待机" => ["不能移动","待机(固定)","异常状态/危急","22"],
"异常状态待机" => ["不能移动","待机(固定)","异常状态/通用","22"],
"睡眠待机" => ["不能移动","待机(固定)","异常状态/睡眠","22"],
"漂浮待机" => ["待机(固定)","6","低空漂浮中","4",
"低空漂浮中2","4","低空漂浮中3","4",
"低空漂浮中4","4"],
"气绝" => ["倒下","无法战斗"],
"伤害" => ["被伤害","坐标初始化"],
"逃走" => ["我方逃走"],
"敌方逃走" => ["我方逃走","坐标初始化"],
"逃走失败" => ["逃走失败","待机(固定)","8","坐标初始化"],
"选择指令" => ["一步向前移动"],
"选择指令后" => ["坐标初始化"],
"防御" => ["待机(固定)","4","漂浮状态确认","低空漂浮中",
"2","低空漂浮中2","2","低空漂浮中3","2",
"低空漂浮中4","2"],
"回避" => ["一步向后跳跃","一步向后跳跃","待机(固定)","16",
"坐标初始化"],
"敌方回避" => ["一步向后跳跃","待机(固定)","16","坐标初始化"],
"胜利" => ["待机(固定)","16","向右(固定)","胜利的跳跃",
"待机(固定)","待机不能移动","是否已变身成猫",
"魔法发动动画","解除变身","待机(固定)","待机不能移动",],
"坐标复原" => ["坐标初始化"],
#------------------------------- 强制系 ----------------------------------------
"吴莉嘉合体攻击1" => ["2","目标左前移动","待机(固定)",
"魔法发动动画","武器下旋转","举起武器",
"48","右拔出","64","后退初始化"],
"四人合体攻击1" => ["2","四人攻击移动2","待机(固定)","魔法发动动画",
"武器下旋转","举起武器","90",
"左拔出","96","后退初始化"],
"四人合体攻击2" => ["2","四人攻击移动3","待机(固定)","魔法发动动画",
"武器下旋转","举起武器","60","右拔出2","右旋转",
"对像动画","128","后退初始化"],
"四人合体攻击3" => ["2","四人攻击移动4","待机(固定)","魔法发动动画",
"武器下旋转","举起武器","34","左拔出2","右旋转",
"对像动画","144","后退初始化"],
"可以投掷" => ["右旋转一周","4","目标高速移动","一步向后跳跃","4",
"待机(固定)","一步向后跳跃","待机(固定)","32"],
#--------------------------- 基本アクション系 ----------------------------------
"通常攻击" => ["目标向前移动","武器挥动攻击","对像动画等待",
"12","武器挥动攻击L","对像动画L","限定于二刀","16",
"击倒许可","后退初始化"],
"敌方无武器的攻击" => ["目标向前移动","武器挥动攻击","对像动画等待",
"击倒许可","后退初始化"],
"使用通用技能" => ["一步向前移动","待机(固定)","魔法发动动画",
"武器下旋转","举起武器","武器挥动攻击",
"对像动画等待","击倒许可","24","坐标初始化"],
"通用技能单独处理"=> ["一步向前移动","魔法发动动画","武器下旋转","举起武器",
"单独处理开始","武器挥动攻击","对像动画","24",
"单独处理完毕","击倒许可","坐标初始化"],
"使用物品" => ["目标向前移动","待机(固定)","24","对像动画等待",
"击倒许可","坐标初始化"],
#------------------------------ スキル系 ---------------------------------------
"多段攻击" => ["残像ON","向前跳跃敲击","武器挥动攻击L","对像动画武器",
"待机(固定)","16","对像动画武器","武器下旋转",
"武器上旋转","4","原地跳跃敲击","武器挥动攻击L",
"对像动画武器","待机(固定)","16","对像动画武器",
"反转","武器挥动攻击","武器挥动攻击L","12","反转",
"原地跳跃敲击","武器挥动攻击L","对像动画武器",
"一步向后跳跃","一步向后跳跃","待机(固定)",
"对像动画武器","拔出","武器挥动攻击L","击倒许可",
"残像OFF","16","后退初始化"],
"多段随机攻击"=> ["向前跳跃敲击","武器挥动攻击L","对像动画武器","待机(固定)","16",
"向前跳跃敲击","武器挥动攻击L","对像动画武器","待机(固定)","16",
"向前跳跃敲击","武器挥动攻击L","对像动画武器","待机(固定)","16",
"向前跳跃敲击","武器挥动攻击L","对像动画武器","击倒许可","坐标初始化"],
"高速多段攻击" => ["目标向前移动","武器挥动攻击","轻微吹动","对像动画武器",
"目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对像动画武器",
"目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对像动画武器",
"目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对像动画武器",
"目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对像动画武器",
"目标向前高速移动","武器挥动攻击","轻微吹动","武器挥动攻击L","对像动画武器",
"击倒许可","12","坐标初始化"],
"二人同时攻击" => ["二人攻击条件确认","二人攻击目标统一","吴莉嘉连同攻击",
"目标右前移动","待机(固定)","魔法发动动画","武器下旋转",
"举起武器","48","斩击/必杀技1","左拔出","64","对像动画",
"击倒许可","后退初始化","解除二人攻击状态"],
"二人同时攻击准备" => ["赋予二人攻击状态"],
"四人同时攻击" => ["四人攻击条件确认","四人攻击目标统一","四人攻击1",
"四人攻击2","四人攻击3","四人攻击移动1","待机(固定)",
"魔法发动动画","武器下旋转","举起武器","90",
"斩击/必杀技1","右拔出","64","对像动画等待",
"击倒许可","后退初始化","合体攻击解除"],
"四人同时攻击准备" => ["赋予四人攻击状态"],
"武器投掷" => ["一步向前移动","武器挥动攻击","absorb1","待机(固定)",
"开始武器投掷","12","对像动画武器","击倒许可",
"放弃武器投掷","坐标初始化"],
"单独全体远距离攻击"=> ["一步向前跳跃","跳跃停止","单独处理开始",
"以自身为目标","武器挥动攻击","中弹1","8",
"对像动画武器","单独处理完毕","击倒许可",
"跳跃着地","坐标初始化"],
"全体远距离攻击" => ["以自身为目标","武器挥动攻击","中弹1","20",
"对像动画等待","击倒许可"],
"回复连发" => ["目标向前移动","对像动画","武器挥动攻击",
"16","死亡确认","回复连发","坐标初始化"],
"适当连发" => ["逃走失败","魔法发动动画","武器下旋转","举起武器",
"8","对像动画","适当连发","坐标初始化"],
"特写" => ["待机(固定)","魔法发动动画","特写1开始",
"75","特写1完毕","8","目标向前移动",
"武器挥动攻击","对像动画等待","击倒许可",
"消去图片","后退初始化"],
"踩踏攻击" => ["跳跃到目标","打击动画","纵向压扁","一步向后跳跃",
"强力踩踏","打击动画","纵向压扁","一步向后跳跃",
"强力踩踏","对像动画","纵向压扁","一步向后跳跃",
"一步向后跳跃","击倒许可","待机(固定)","8","后退初始化"],
"全体攻击1" => ["一步向前移动","待机(固定)","魔法发动动画","武器下旋转",
"举起武器","全体动画单体化","武器挥动攻击","48",
"对像动画等待","击倒许可","坐标初始化"],
"变身成猫" => ["一步向前跳跃","待机(固定)","魔法发动动画","32",
"变身成猫","待机(固定)","猫","32","一步向后跳跃"],
"人体投掷" => ["选择投掷角色","目标移动","举起我方","4",
"absorb1","投掷目标组合","将我方投掷飞出",
"投掷我方","待机(固定)","对像动画","坐标初始化",
"待机(固定)","32"],
#-------------------------------------------------------------------------------
"完毕" => ["完毕"]}
end
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　设定主人公的基本动作类
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● 从主人公ID中确定空手时的动作（无武器时）
#--------------------------------------------------------------------------
# when 1 ←这个数字是主人公ID
# return "通常攻击" ←填入对应的连贯动作名
def non_weapon
case @actor_id
when 1
return "通常攻击"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "通常攻击"
end
#--------------------------------------------------------------------------
# ● 通常待机
#--------------------------------------------------------------------------
def normal
case @actor_id
when 1
return "待机"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "待机"
end
#--------------------------------------------------------------------------
# ● 危急（HP1/4以下）
#--------------------------------------------------------------------------
def pinch
case @actor_id
when 1
return "危急待机"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "危急待机"
end
#--------------------------------------------------------------------------
# ● 防御
#--------------------------------------------------------------------------
def defence
case @actor_id
when 1
return "防御"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "防御"
end
#--------------------------------------------------------------------------
# ● 伤害　对像动画时、取得命中时的动作
#--------------------------------------------------------------------------
def damage_hit
case @actor_id
when 1
return "伤害"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "伤害"
end
#--------------------------------------------------------------------------
# ● 回避　对像动画时、取得没命中时的动作
#--------------------------------------------------------------------------
def evasion
case @actor_id
when 1
return "回避"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "回避"
end
#--------------------------------------------------------------------------
# ● 选择指令前动作
#--------------------------------------------------------------------------
def command_b
case @actor_id
when 1
return "选择指令"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "选择指令"
end
#--------------------------------------------------------------------------
# ● 选择指令后动作
#--------------------------------------------------------------------------
def command_a
case @actor_id
when 1
return "选择指令后"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "选择指令后"
end
#--------------------------------------------------------------------------
# ● 逃走成功
#--------------------------------------------------------------------------
def run_success
case @actor_id
when 1
return "逃走"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "逃走"
end
#--------------------------------------------------------------------------
# ● 逃走失败
#--------------------------------------------------------------------------
def run_ng
case @actor_id
when 1
return "逃走失败"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "逃走失败"
end
#--------------------------------------------------------------------------
# ● 胜利
#--------------------------------------------------------------------------
def win
case @actor_id
when 1
return "胜利"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "胜利"
end
#--------------------------------------------------------------------------
# ● 进入战斗时的动作
#--------------------------------------------------------------------------
def first_action
case @actor_id
when 1
return "战斗开始"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "战斗开始"
end
#--------------------------------------------------------------------------
# ● 动作被中断时的恢复动作
#--------------------------------------------------------------------------
def recover_action
case @actor_id
when 1
return "坐标复原"
end
# 上述主人公ID以外的其他主人公全部使用的连贯动作名
return "坐标复原"
end
#--------------------------------------------------------------------------
# ● 影图像在人物行走图文件夹中读取
#--------------------------------------------------------------------------
# return "shadow00" ←在这里填入想要设定的话像文件名
def shadow
case @actor_id
when 1
return "shadow00"
end
# 上述主人公ID以外的其他主人公全部使用的影图像
return "shadow00"
end
#--------------------------------------------------------------------------
# ● 略微调整影图像的位置
#--------------------------------------------------------------------------
# return [横坐标, 纵坐标]
def shadow_plus
case @actor_id
when 1
return [ 0, 4]
end
# 上述主人公ID以外的其他主人公全部使用的位置
return [ 0, 4]
end
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　敌方的基本动作设定
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# ● 从敌方ID来确定未装备武器时的通常攻击动作
#--------------------------------------------------------------------------
# when 1 ←这里的数字是敌方ID编号
# return "敌方无武器的攻击" ←请填入对应的连贯动作名
def base_action
case @enemy_id
when 1
return "敌方无武器的攻击"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "敌方无武器的攻击"
end
#--------------------------------------------------------------------------
# ● 通常待机
#--------------------------------------------------------------------------
def normal
case @enemy_id
when 1
return "待机"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "待机"
end
#--------------------------------------------------------------------------
# ● 危急（HP1/4以下）
#--------------------------------------------------------------------------
def pinch
case @enemy_id
when 1
return "待机"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "待机"
end
#--------------------------------------------------------------------------
# ● 防御
#--------------------------------------------------------------------------
def defence
case @enemy_id
when 1
return "防御"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "防御"
end
#--------------------------------------------------------------------------
# ● 伤害　对像动画时、取得命中时的动作
#--------------------------------------------------------------------------
def damage_hit
case @enemy_id
when 1
return "伤害"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "伤害"
end
#--------------------------------------------------------------------------
# ● 回避　对像动画时、取得未命中时的动作
#--------------------------------------------------------------------------
def evasion
case @enemy_id
when 1
return "敌方回避"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "敌方回避"
end
#--------------------------------------------------------------------------
# ● 逃走
#--------------------------------------------------------------------------
def run_success
case @enemy_id
when 1
return "敌方逃走"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "敌方逃走"
end
#--------------------------------------------------------------------------
# ● 进入战斗时的动作
#--------------------------------------------------------------------------
def first_action
case @enemy_id
when 1
return "战斗开始"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "战斗开始"
end
#--------------------------------------------------------------------------
# ● 动作被中断时的恢复动作
#--------------------------------------------------------------------------
def recover_action
case @enemy_id
when 1
return "坐标复原"
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动作
return "坐标复原"
end
#--------------------------------------------------------------------------
# ● 影图像在人物行走图文件夹中读取
#--------------------------------------------------------------------------
# return "shadow01" ←在这里填入想要设定的话像文件名。
def shadow
case @enemy_id
when 1
return "shadow01"
when 30
return ""
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID影图像
return "shadow01"
end
#--------------------------------------------------------------------------
# ● 略微调整影图像的位置
#--------------------------------------------------------------------------
# return [横坐标, 纵坐标]
def shadow_plus
case @enemy_id
when 1
return [ 0, -8]
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID位置
return [ 0, 0]
end
#--------------------------------------------------------------------------
# ● 敌方武器设定在动作和动画时，武器也被显示。
#--------------------------------------------------------------------------
# return 1 ←这个数字是武器ID。0的话将被判别为空手。
# 只有在敌方动画NO的时候画像才被显示。
def weapon
case @enemy_id
when 1
return 0
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID
return 0
end
#--------------------------------------------------------------------------
# ● 战斗配置的略微调整在这里可以设置数据库中所不能设置的广范围坐标
#--------------------------------------------------------------------------
# return [ 0, 0] => [X坐标、Y坐标] 这个数值从数据库上的配置上变化
def position_plus
case @enemy_id
when 1
return [0, 0]
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID坐标调整
return [ 0, 0]
end
#--------------------------------------------------------------------------
# ● 敌方击倒(击破时的退场)方式
#--------------------------------------------------------------------------
# 被击倒画像残留的为1、普通为2、BOSS型为3
def collapse_type
case @enemy_id
when 1
return 2
when 30 #敌方ID为30,BOSS型击倒!
return 3
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID击倒方式
return 2
end
#--------------------------------------------------------------------------
# ● 敌方行动回数 1回合做几次行动
#--------------------------------------------------------------------------
# 回数确率补正
# return [ 2, 100, 50]
#
# 回数…最大的行动回数
# 确率…下次行动能否成功的成功率。数值为％
# 补正…速度修正。行动的每次数值％后得出的值
def action_time
case @enemy_id
when 1
return [ 1, 100, 100]
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID行动回数
return [ 1, 100, 100]
end
#--------------------------------------------------------------------------
# ● 敌方动画
#--------------------------------------------------------------------------
# 敌方被作成动画？　true是是跟主人公同等对待。
# [设定方法]
# 1.敌方的动画画像变成行走图
# 2.数据库的敌方角色名、参照着行走图文件名填写
def anime_on
case @enemy_id
when 1,2,3,4
return true
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动画设定
return false
end
#--------------------------------------------------------------------------
# ● 敌方动画时的自动反转
#--------------------------------------------------------------------------
# 如果想自动反转上面设定为NO的敌方画像和武器动画时为true
def action_mirror
case @enemy_id
when 1,2,3,4
return true
end
# 上述敌方ID以外的其他敌方队员全部使用的武器ID动画设定
return false
end
end
module RPG
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　设定状态动作。
#==============================================================================
class State
#--------------------------------------------------------------------------
# ● 指定ID　根据状态改变通常待机、危急时的动作。
#--------------------------------------------------------------------------
# when 1 ←这个数字是状态ID
# return "气绝" ←填入对应的连贯动作名
def base_action
case @id
when 1 # 无法战斗（HP0）时。最优先。
return "气绝"
when 2,3,4,5,7
return "异常状态待机"
when 6
return "睡眠待机"
when 17
return "漂浮待机"
end
# 上述状态ID以外的其他状态全部使用的连贯动作
return "待机"
end
#--------------------------------------------------------------------------
# ● 扩张设定　从状态ID确定扩张设定。可以重复。
#--------------------------------------------------------------------------
# "自动复活/50"…无法战斗时自动复活。不要解除无法战斗。
# /后的数字是回复时的HP(最大值的比例％)回复后状态会自动解除
# "魔法反弹/39"…反弹魔法(物理攻击以外)技能。/后填入反射时显示的动画ID编号
# "物理反弹/39"…反弹物理攻击(包含物理技能)。/后填入反射时显示的动画ID编号
# "魔法无效/39"…魔法(物理攻击以外)技能无效化。/后填入无效时显示的动画ID编号
# "物理无效/39"…物理攻击(包含物理技能)无效化。/后填入无效时显示的动画ID编号
# "成本吸收"…受到技能时将他的成本还原到自身。数值不显示。
# "0回合解除"…按照行动顺序的回合数解除状态。
# "敌方除外"…让敌方不显示这个状态
# "无POP"…附加这个状态时、伤害窗口上不显示状态名
# "不显示ICON"…在状态窗口上不显示状态ICON
# "禁止状态动作"…附加这个状态时不会改变人物待机状态
# "连续伤害"…调用下面的连续伤害
# "无"…无扩张
def extension
case @id
when 1 # 无法战斗
return ["无POP","敌方除外"]
when 2 # 毒
return ["敌方除外"]
when 18
return ["0回合解除","不显示ICON"]
when 19
return ["0回合解除","不显示ICON"]
when 20
return ["不显示ICON","禁止状态动作"]
end
# 上记のID以外すべてに适用される扩张设定
return ["无"]
end
#--------------------------------------------------------------------------
# ● 连续伤害扩张设置　包含连续回复
#--------------------------------------------------------------------------
# when 1 ←这个数字是状态ID。上面的只有填写了"连续伤害"的扩张才会有这个效果
# 　　　　可以多数设置。例)[["hp",0,5,true],["mp",0,5,true]]
#
# 　对像定数比例 POP 无法战斗许可
# return [["hp", 0, 10, true, true]]
#
# 对像…比例伤害对象是 HP的话为"hp" MP为"mp"
# 定数…这个数值直接是伤害值。如果是负数时便成为回复。数值上多少会有些误差
# 比例…对象的最大值的比例伤害。数值以％计算。数值上多少会有些误差
# POP…在战斗画面上显示数值是true
# 无法战斗许可…许可HP0的情况是true
def slip_extension
case @id
when 2 # 毒
return [["hp", 0, 10, true, true]]
end
return []
end
end
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　设置武器动作
#==============================================================================
class Weapon
#--------------------------------------------------------------------------
# ● 动作指定　从装备着的武器ID来决定通常攻击的动作。
#--------------------------------------------------------------------------
# when 1 ←这个数字是武器ID
# return "通常攻击" ←请填入对应的连贯动作名
def base_action
case @id
when 1
return "通常攻击"
end
# 上述ID以外的其他全部使用的动作
return "通常攻击"
end
#--------------------------------------------------------------------------
# ● 图像指定　从装备着的武器ID来决定通常攻击的动作。
#--------------------------------------------------------------------------
# return "001-Weapon01" ←请填入对应的武器图像的文件名
# 武器图像请放入人物行走图文件夹中
# 使用ICON时、在ID上没有的全部使用ICON来表示
# 特定的武器想要让他们不显示的话请用空白的图像。
def graphic
case @id
when 1
return ""
end
# 使用上述ID以外的全ICON画像
return ""
end
#--------------------------------------------------------------------------
# ● 飞出动画中贴附武器图像　自人物行走图文件夹中读取
#--------------------------------------------------------------------------
# 飞出动画用武器画像另行设定。显示弓和箭之类的。
# 在这里没有被设置的武器会和上面的图像作相同处理。
def flying_graphic
case @id
when 1
return ""
end
# 上述ID以外一律使用的图像
return ""
end
end
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　技能动作设定。
#==============================================================================
class Skill
#--------------------------------------------------------------------------
# ● 从技能ID决定动作。
#--------------------------------------------------------------------------
def base_action
case @id
when 84
return "武器投掷"
when 85
return "多段攻击"
when 86
return "高速多段攻击"
when 87
return "单独全体远距离攻击"
when 88
return "全体远距离攻击"
when 89
return "多段随机攻击"
when 90
return "回复连发"
when 91
return "适当连发"
when 92
return "通常攻击"
when 93
return "特写"
when 94
return "踩踏攻击"
when 95
return "全体攻击1"
when 96
return "通用技能单独处理"
when 97
return "变身成猫"
when 98
return "二人同时攻击"
when 99
return "二人同时攻击准备"
when 100
return "四人同时攻击"
when 101
return "四人同时攻击准备"
when 102
return "四人同时攻击准备"
when 103
return "四人同时攻击准备"
when 104
return "人体投掷"
end
# 上述ID以外的其他全部使用的动作
return "使用通用技能"
end
#--------------------------------------------------------------------------
# ● 扩张设定　从技能ID决定扩张设定。可以重复。
#--------------------------------------------------------------------------
# "必中"…攻击绝对不会被回避
# "HP消费"…将MP消费改为HP消费
# "%成本MAX"…技能成本变为以最大MP(HP)的比例取值。例)MAXMP500的成本10是消费MP50
# "%成本NOW"…技能成本变为以现在MP(HP)的比例取值。例)现MP100的成本10是消费MP10
# "无视反射"…无视魔法、物理技能反射和无效化状态
# "%伤害MAX/30"…伤害计算变为以对象的最大HP(MP)的比例取值。/后的数值为%值伤害
# "%伤害NOW/30"…伤害计算变为以对象的现在HP(MP)的比例取值。/后的数值为%值伤害
# "成本威力"…根据使用者的最大MP(HP)判别消费MP(HP)的比例威力。MAX消费是原本威力、MAX10%是原有威力的1/10
# "现HP威力"…根据使用者的最大HP改变现在HP的比例威力。MAX是原本威力、MAX10%是原有威力的1/10
# "现MP威力"…根据使用者的最大MP改变现在MP的比例威力。MAX是原本威力、MAX10%是原有威力的1/10
# "MP消耗减半无效"…防具上的定义“MP消耗减半”被无效化
# "不显示HELP"…动作时、帮助窗口上不显示技能名
# "全区域"…目标范围为敌我方全体
# "随机目标"…目标内随机选择一个对像
# "自身以外"…在目标内将自己排除
# "伤害动作禁止"…不显示伤害命中时的动作
# "行动前无闪光"…行动时角色不发光
# "无"…无扩张
def extension
case @id
when 86
return ["伤害动作禁止"]
when 89
return ["随机目标"]
when 94
return ["伤害动作禁止"]
when 96
return ["全域"]
when 98
return ["伤害动作禁止"]
when 99
return ["不显示HELP","行动前无闪光"]
when 100
return ["伤害动作禁止"]
when 101
return ["不显示HELP","行动前无闪光"]
when 102
return ["不显示HELP","行动前无闪光"]
when 103
return ["不显示HELP","行动前无闪光"]
end
# 上述ID以外的其他全部使用的扩张设定
return ["无"]
end
#--------------------------------------------------------------------------
# ● 飞出动画上贴附的画像　自人物行走图文件夹中读取
#--------------------------------------------------------------------------
# 指定技能ID的画像
def flying_graphic
case @id
when 1
return ""
end
# 上述ID以外为画像未使用
return ""
end
end
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　物品动作设定。
#==============================================================================
class Item
#--------------------------------------------------------------------------
# ● 根据物品ID决定动作。
#--------------------------------------------------------------------------
def base_action
case @id
when 1
return "使用物品"
end
# 上述ID以外的其他全部使用的动作
return "使用物品"
end
#--------------------------------------------------------------------------
# ● 扩张设定　根据物品ID决定扩张设定。可以重复。
#--------------------------------------------------------------------------
# "必中"…攻击绝对不会被回避
# "反射无视"…无视魔法、物理反射和无效化状态
# "不显示HELP"…帮助窗口上不显示物品名
# "全区域"…目标范围为敌我全体
# "随机目标"…目标内中随机选择一个对像
# "自身以外"…目标内中将自身排除
# "伤害动作禁止"…不显示伤害命中时的动作
# "行动前无闪光"…行动时角色不发光
# "无"…无扩张
def extension
case @id
when 1
return ["无"]
end
# 上述ID以外的其他全部使用的扩张设定
return ["无"]
end
end
end

复制代码

#==============================================================================
# ■ Sprite_Battler Ver3.3
#------------------------------------------------------------------------------
# 　角色用於現實的戰鬥動作。
#==============================================================================
class Sprite_Battler < Sprite_Base
#--------------------------------------------------------------------------
# ● 初期化
#--------------------------------------------------------------------------
def initialize(viewport, battler = nil)
super(viewport)
@battler = battler
@battler_visible = false
@effect_type = 0 # 效果的種類
@effect_duration = 0 # 效果的殘留時間
@move_x = 0 # 已變化的X坐標的累計
@move_y = 0 # 已變化的Y坐標的累計
@move_z = 0 # 已變化的Z坐標的累計
@distanse_x = 0 # X坐標的移動距離
@distanse_y = 0 # Y坐標的移動距離
@moving_x = 0 #１單位所相當的X坐標移動距離
@moving_y = 0 #１單位所相當的Y坐標移動距離
@move_speed_x = 0 # X坐標的移動速度
@move_speed_y = 0 # Y坐標的移動速度
@move_speed_plus_x = 0 # X坐標在加減速時的補充移動速度
@move_speed_plus_y = 0 # Y坐標在加減速時的補充移動速度
@move_boost_x = 0 # X坐標加速度
@move_boost_y = 0 # Y坐標加速度
@jump_time = 0 # 跳躍時間
@jump_time_plus = 0 # 跳躍時間補充
@jump_up = 0 # 跳躍上升
@jump_down = 0 # 跳躍下降
@jump_size = 0 # 跳躍高度
@float_time = 0 # 漂浮時間
@float_up = 0 # 1單位所相當於的浮遊高度
@jump_plus = 0 # 根據跳躍補充影位置
@angle = 0 # 旋轉角度
@angling = 0 # 1單位所相當於的旋轉角度
@angle_time = 0 # 旋轉時間
@angle_reset = 0 # 是否初始化角度
@zoom_x = 0 # 橫向放大率
@zoom_y = 0 # 縱向放大率
@zooming_x = 0 # 1單位所相當於的橫向放大率
@zooming_y = 0 # 1單位所相當於的縱向放大率
@zoom_time = 0 # 放大時間
@zoom_reset = 0 # 是否初始化放大
@target_battler = [] # 目標角色情報
@now_targets = [] # 目標角色記憶
@pattern = 0 # 橫圖片位置（更新位置）
@pattern_back = false # 循環標誌
@wait = 0 # 到下個動作的等待時間
@unloop_wait = 0 # 非循環系動畫完畢時的等待時間
@action = [] # 行動
@anime_kind = 0 # 縱圖片位置（動畫種類位置）
@anime_speed = 0 # 圖片更新速度
@frame = 0 # 被消費圖片更新時間
@anime_loop = 0 # 循環方式
@anime_end = false # 角色的動畫是否完畢
@anime_freeze = false # 是否是固定動畫
@anime_freeze_kind = false # 固定圖案位置
@anime_moving = false # 是否在飛出動畫中
@base_width = N01::ANIME_PATTERN # 圖片的橫分割數
@base_height = N01::ANIME_KIND # 圖片的縱分割數
@width = 0 # 橫矩形
@height = 0 # 縱矩形
@picture_time = 0 # 圖片顯示時間
@individual_targets = [] # 單獨處理的保持目標
@balloon_duration = 65 # 飛出動畫時間
@reverse = false # 動畫的反向再生標誌
# 角色不存在的時候將中斷處理
return @battler_visible = false if @battler == nil
# 角色是主人公時、或者敵方動畫為NO時
@anime_flug = true if @battler.actor?
@anime_flug = true if [email protected]? && @battler.anime_on
end
#--------------------------------------------------------------------------
# ● 角色作成
#--------------------------------------------------------------------------
def make_battler
# 初期配置的取得
@battler.base_position
# 色相通過角色認別
@battler_hue = @battler.battler_hue
# 角色是主人公時、或者敵方動畫為NO時
if @anime_flug
# 準備武器
@weapon_R = Sprite_Weapon.new(viewport,@battler)
# 取得我方人物名、敵人角色名
@battler_name = @battler.character_name if @battler.actor?
@battler_name = @battler.battler_name unless @battler.actor?
# 敵方角色是主人公時、或者敵方動畫為NO時為NO的時候畫像被角色是主人公時、或者敵方動畫為NO時
self.mirror = true if [email protected]? && @battler.action_mirror
# 是不是利用行圖片圖來改變轉送前的矩形尺寸的認識處
self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
# 獲取轉送前的矩形
@width = self.bitmap.width / @base_width
@height = self.bitmap.height / @base_height
# 矩形設定
@sx = @pattern * @width
@sy = @anime_kind * @height
# 角色本體的描繪
self.src_rect.set(@sx, @sy, @width, @height)
# 不作動畫的角色時
else
# bitmap的獲取、設定
@battler_name = @battler.battler_name
self.bitmap = Cache.battler(@battler_name, @battler_hue)
@width = bitmap.width
@height = bitmap.height
end
# 偷襲時畫像角色是主人公時、或者敵方動畫為NO時
if $back_attack && @battler.actor?
self.mirror = true
elsif $back_attack && [email protected]?
self.mirror = true
self.mirror = false if @battler.action_mirror
else
self.mirror = false
self.mirror = true if [email protected]? && @battler.action_mirror
end
# ....
@weapon_R.mirroring if self.mirror && @weapon_R != nil
# 位置初期化
@battler.reset_coordinate
# 決定原點
self.ox = @width / 2
self.oy = @height * 2 / 3
# 設定偷襲時的坐標
update_move
# 準備飛出動畫的精靈
@move_anime = Sprite_MoveAnime.new(viewport,battler)
# 準備圖片用精靈
@picture = Sprite.new
# 作成傷害精靈
@damage = Sprite_Damage.new(viewport,battler)
end
#--------------------------------------------------------------------------
# ● 影作成
#--------------------------------------------------------------------------
def make_shadow
@shadow.dispose if @shadow != nil
@battler_hue = @battler.battler_hue
@shadow = Sprite.new(viewport)
@shadow.z = self.z - 4
@shadow.visible = false
# 準備角色的影子精靈
@shadow.bitmap = Cache.character(@battler.shadow)
@shadow_height = @shadow.bitmap.height
# 影位置的稍微調整
@shadow_plus_x = @battler.shadow_plus[0] - @width / 2
@shadow_plus_y = @battler.shadow_plus[1]
# 配合角色畫像的大小使用影畫像
@shadow.zoom_x = @width * 1.0 / @shadow.bitmap.width
# 更新
update_shadow
end
#--------------------------------------------------------------------------
# ● 解放
#--------------------------------------------------------------------------
def dispose
self.bitmap.dispose if self.bitmap != nil
@weapon_R.dispose if @weapon_R != nil
@move_anime.dispose if @move_anime != nil
@picture.dispose if @picture != nil
@shadow.dispose if @shadow != nil
@damage.dispose if @damage != nil
@balloon.dispose if @balloon != nil
mirage_off
# 畫像變更
@battler.graphic_change(@before_graphic) if @before_graphic != nil
super
end
#--------------------------------------------------------------------------
# ● 傷害動作 action = [動畫ID,角色是主人公時、或者敵方動畫為NO時標誌,反方向許可]
#--------------------------------------------------------------------------
def damage_action(action)
damage = @battler.hp_damage
damage = @battler.mp_damage if @battler.mp_damage != 0
# 如果HP和MP兩個同時做出傷害
if @battler.hp_damage != 0 && @battler.mp_damage != 0
@battler.double_damage = true
damage = @battler.hp_damage
end
# 吸收攻擊使HP為0的處理
if action[0] == "absorb"
absorb = true
action[0] = nil
end
# 只有在命中時動畫才被執行
unless @battler.evaded or @battler.missed or action[0] == nil
@battler.animation_id = action[0]
@battler.animation_mirror = action[1]
end
# 執行傷害動畫
start_action(@battler.damage_hit) if damage > 0 && action[2]
# 攻擊沒有命中時執行迴避動畫
if @battler.evaded or @battler.missed
start_action(@battler.evasion) if action[2]
Sound.play_evasion
end
@damage.damage_pop unless absorb or action[3] != nil
end
#--------------------------------------------------------------------------
# ● 傷害數值POP
#--------------------------------------------------------------------------
def damage_pop(damage)
@damage.damage_pop(damage)
end
#--------------------------------------------------------------------------
# ● 戰鬥開始行動
#--------------------------------------------------------------------------
def first_action
# 檢查能否行動、只有在不能的情況下那個狀態的動作開始
action = @battler.first_action unless @battler.restriction >= 4
action = $data_states[@battler.state_id].base_action if @battler.states[0] != nil && @battler.restriction >= 4
start_action(action)
# 影用意
make_shadow if N01::SHADOW
end
#--------------------------------------------------------------------------
# ● 動作開始
#--------------------------------------------------------------------------
def start_action(kind)
# 初期化各種動作
reset
#記錄現在取得的待機動作
stand_by
# 決定新的動作內容
@action = N01::ACTION[kind].dup
# 從行動配列的前頭開始移動
active = @action.shift
# 自動完畢
@action.push("完畢")
# 確定現在的動作
@active_action = N01::ANIME[active]
# 等待設定
@wait = active.to_i if @active_action == nil
# 單獨動作開始
action
end
#--------------------------------------------------------------------------
# ● 強制單獨動作開始
#--------------------------------------------------------------------------
def start_one_action(kind,back)
# 初期化各種動作
reset
# 記錄現在取得的待機動作
stand_by
# 設置坐標初始化動作
@action = [back]
# 自動完畢
@action.push("完畢")
# 確定現在的動作
@active_action = N01::ANIME[kind]
# 單獨動作開始
action
end
#--------------------------------------------------------------------------
# ● 到下一個動作
#--------------------------------------------------------------------------
def next_action
# 等待中時取消
return @wait -= 1 if @wait > 0
# 或者全部圖片動畫沒有被完成時取消
return if @anime_end == false
# 最後的圖片顯示等待
return @unloop_wait -= 1 if @unloop_wait > 0
# 從行動配列的前頭開始移動
active = @action.shift
# 確定現在的動作
@active_action = N01::ANIME[active]
# 等待設定
@wait = active.to_i if @active_action == nil
# 單獨動作開始
action
end
#--------------------------------------------------------------------------
# ● 待機動作
#--------------------------------------------------------------------------
def stand_by
# 到通常待機
@repeat_action = @battler.normal
# HP為1/4時顯示危急表情
@repeat_action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
# 防禦中
@repeat_action = @battler.defence if @battler.guarding?
# 如果什麼狀態都沒有時完畢
return if @battler.state_id == nil
for state in @battler.states.reverse
# 動作禁止的狀態時跳過處理
next if state.extension.include?("禁止狀態動作")
# 敵方被動作禁止狀態時跳過處理
next if @battler.is_a?(Game_Enemy) && state.extension.include?("敵方除外")
# 狀態的表情
@repeat_action = state.base_action
end
end
#--------------------------------------------------------------------------
# ● 待機動作的插入
#--------------------------------------------------------------------------
def push_stand_by
action = @battler.normal
action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
action = @battler.defence if @battler.guarding?
for state in @battler.states.reverse
# 動作禁止的狀態時跳過處理
next if state.extension.include?("禁止狀態動作")
# 敵方被動作禁止狀態時跳過處理
next if @battler.is_a?(Game_Enemy) && state.extension.include?("敵方除外")
# 狀態的表情
action = state.base_action
end
@repeat_action = action
# 插入
@action.delete("完畢")
act = N01::ACTION[action].dup
for i in 0...act.size
@action.push(act[i])
end
@action.push("完畢")
@anime_end = true
end
#--------------------------------------------------------------------------
# ● 各種變化的初期化
#--------------------------------------------------------------------------
def reset
self.zoom_x = self.zoom_y = 1
self.oy = @height * 2 / 3
@angle = self.angle = 0
@anime_end = true
@non_repeat = false
@anime_freeze = false
@unloop_wait = 0
end
#--------------------------------------------------------------------------
# ● 跳躍的初期化
#--------------------------------------------------------------------------
def jump_reset
@battler.jump = @jump_time = @jump_time_plus = @jump_up = @jump_down = 0
@jump_size = @jump_plus = @float_time = @float_up = 0
end
#--------------------------------------------------------------------------
# ● 受取目標情報
#--------------------------------------------------------------------------
def get_target(target)
# 單獨處理中是中止(全區域中自身被捲
return if @battler.individual
@target_battler = target
end
#--------------------------------------------------------------------------
# ● 動作情報在角色中收藏
#--------------------------------------------------------------------------
def send_action(action)
@battler.play = 0
@battler.play = action if @battler.active
end
#--------------------------------------------------------------------------
# ● 角色追加
#--------------------------------------------------------------------------
def battler_join
if @battler.exist? && !@battler_visible
# 從戰鬥不能的復活時的處理被跳過
if @battler.revival && @anime_flug
return @battler.revival = false
elsif @battler.revival && !@anime_flug
@battler.revival = false
self.visible = true
return
end
@anime_flug = true if @battler.actor?
@anime_flug = true if [email protected]? && @battler.anime_on
make_battler
first_action
end
end
#--------------------------------------------------------------------------
# ● 圖片更新　※再定義
#--------------------------------------------------------------------------
def update
super
# 角色不存在時跳過
return self.bitmap = nil if @battler == nil
# 追加角色
battler_join
# 到下一個動作
next_action
# 動畫圖像更新
update_anime_pattern
# 目標更新
update_target
# 強制更新
update_force_action
# 坐標更新
update_move
# 影更新
update_shadow if @shadow != nil
# 武器更新
@weapon_R.update if @weapon_action
# 漂浮更新
update_float if @float_time > 0
# 旋轉更新
update_angle if @angle_time > 0
# 放大縮小更新
update_zoom if @zoom_time > 0
# 殘像更新
update_mirage if @mirage_flug
# 圖片更新
update_picture if @picture_time > 0
# 飛出動畫更新
update_move_anime if @anime_moving
# 飛出動畫更新（圖片動畫）
update_balloon if @balloon_duration <= 64
# 傷害精靈更新
@damage.update if @damage != nil
setup_new_effect
update_effect
update_battler_bitmap
end
#--------------------------------------------------------------------------
# ● 動畫圖像更新
#--------------------------------------------------------------------------
def update_anime_pattern
# 更新時間在到之前跳過
return @frame -= 1 if @frame != 0
# 只有在必要的時候更新武器動畫
@weapon_R.action if @weapon_action && @weapon_R != nil
# 動畫到最後是檢查是否是循環
if @pattern_back
# 往返循環
if @anime_loop == 0
# 反向再生
if @reverse
@pattern += 1
if @pattern == @base_width - 1
@pattern_back = false
@anime_end = true
end
# 通常再生
else
@pattern -= 1
if @pattern == 0
@pattern_back = false
@anime_end = true
end
end
# 單程或者是不循環時
else
@anime_end = true
if @anime_loop == 1
@pattern = 0 if !@reverse
@pattern = @base_width - 1 if @reverse
@pattern_back = false
end
end
# 推進動畫
else
if @reverse
@pattern -= 1
@pattern_back = true if @pattern == 0
else
@pattern += 1
@pattern_back = true if @pattern == @base_width - 1
end
end
# 初期化更新時間
@frame = @anime_speed
# 動畫固定時，固定橫矩形
return if @anime_freeze
# 設定轉送處的矩形
return unless @anime_flug
@sx = @pattern * @width
@sy = @anime_kind * @height
self.src_rect.set(@sx, @sy, @width, @height)
end
#--------------------------------------------------------------------------
# ● 動畫圖像更新
#--------------------------------------------------------------------------
def update_target
# 目標確認
return if @battler.force_target == 0
# 單獨處理中中止(全區域中自身被捲入時目標情報是不是)
return if @battler.individual
@target_battler = @battler.force_target[1]
@battler.force_target = 0
end
#--------------------------------------------------------------------------
# ● 強制動作更新 action = [識別,復原,實行動作]
#--------------------------------------------------------------------------
def update_force_action
# 確認強制動作
action = @battler.force_action
return if action == 0
@battler.force_action = 0
# 主動中不能插入
return if @battler.active
# 擊倒時就那樣直接連接行動
return collapse_action if action[0] == "N01collapse"
# 單獨時就那樣直接連接
return start_one_action(action[2],action[1]) if action[0] == "單獨"
# 通用作為動作對待
start_action(action[2])
# 有無坐標復原
return if action[1] == ""
# 完畢位置替換成重複動作
@action.delete("完畢")
@action.push(action[1])
@action.push("完畢")
end
#--------------------------------------------------------------------------
# ● 坐標更新
#--------------------------------------------------------------------------
def update_move
# 補完加減速中距離的增減
if @move_speed_plus_x > 0
# 計算移動
@move_x += @moving_x
# 實行移動
@battler.move_x = @move_x
@move_speed_plus_x -= 1
elsif @move_speed_x > 0
# 加速時
if @move_boost_x != 0
@moving_x += @move_boost_x
end
# 計算移動
@move_x += @moving_x
# 實行移動
@battler.move_x = @move_x
@move_speed_x -= 1
end
# 補完加減速中距離的增減
if @move_speed_plus_y > 0
# 計算移動
@move_y += @moving_y
# 實行移動
@battler.move_y = @move_y
@move_speed_plus_y -= 1
elsif @move_speed_y > 0
# 加速時
if @move_boost_y != 0
@moving_y += @move_boost_y
end
# 計算移動
@move_y += @moving_y
# 實行移動
@battler.move_y = @move_y
@move_speed_y -= 1
end
# 跳躍上升
if @jump_up != 0
# 計算移動
@jump_plus += @jump_up
# 實行移動
@battler.jump = @jump_plus
@jump_up = @jump_up / 2
@jump_time -= 1
# 如果跳躍到了頂點時
if @jump_time == 0 or @jump_up == @jump_sign
@jump_down = @jump_up * 2 * @jump_sign * @jump_sign2
@jump_time_plus += @jump_time * 2
@jump_up = 0
return
end
end
# 跳躍下降
if @jump_down != 0
if @jump_time_plus != 0
@jump_time_plus -= 1
elsif @jump_down != @jump_size
# 計算移動
@jump_plus += @jump_down
# 實行移動
@battler.jump = @jump_plus
@jump_down = @jump_down * 2
if @jump_down == @jump_size
if @jump_flug
@jump_flug = false
else
# 計算移動
@jump_plus += @jump_down
# 實行移動
@battler.jump = @jump_plus
@jump_down = @jump_size = 0
end
end
end
end
# 設定精靈的坐標
self.x = @battler.position_x
self.y = @battler.position_y
self.z = @battler.position_z
end
#--------------------------------------------------------------------------
# ● 影更新
#--------------------------------------------------------------------------
def update_shadow
@shadow.opacity = self.opacity
@shadow.x = @battler.position_x + @shadow_plus_x
@shadow.y = @battler.position_y + @shadow_plus_y - @jump_plus
@shadow.z = @battler.position_z - 4
end
#--------------------------------------------------------------------------
# ● 漂浮更新
#--------------------------------------------------------------------------
def update_float
@float_time -= 1
@jump_plus += @float_up
@battler.jump = @jump_plus
end
#--------------------------------------------------------------------------
# ● 旋轉更新
#--------------------------------------------------------------------------
def update_angle
# 實行旋轉
@angle += @angling
self.angle = @angle
@angle_time -= 1
# 旋轉時間結束時項目初始化
return @angle = 0 if @angle_time == 0
# 如果有復原標誌時角度返回0
self.angle = 0 if @angle_reset
end
#--------------------------------------------------------------------------
# ● 擴大縮小更新
#--------------------------------------------------------------------------
def update_zoom
# 實行擴大縮小
@zoom_x += @zooming_x
@zoom_y += @zooming_y
self.zoom_x = @zoom_x
self.zoom_y = @zoom_y
@zoom_time -= 1
# 擴大縮小時間結束時項目初始化
return if @zoom_time != 0
@zoom_x = @zoom_y = 0
self.oy = @height * 2 / 3
# 如果有復原標誌時還原
self.zoom_x = self.zoom_y = 1 if @zoom_reset
end
#--------------------------------------------------------------------------
# ● 殘像更新
#--------------------------------------------------------------------------
def update_mirage
# 殘像最大能顯示3個、2格圖片中更新
mirage(@mirage0) if @mirage_count == 1
mirage(@mirage1) if @mirage_count == 3
mirage(@mirage2) if @mirage_count == 5
@mirage_count += 1
@mirage_count = 0 if @mirage_count == 6
end
#--------------------------------------------------------------------------
# ● 圖片更新
#--------------------------------------------------------------------------
def update_picture
@picture_time -= 1
@picture.x += @moving_pic_x
@picture.y += @moving_pic_y
end
#--------------------------------------------------------------------------
# ● 飛出動畫更新
#--------------------------------------------------------------------------
def update_move_anime
@move_anime.update
@anime_moving = false if @move_anime.finish?
@move_anime.action_reset if @move_anime.finish?
end
#--------------------------------------------------------------------------
# ● 崩壞效果的更新　※再定義
#--------------------------------------------------------------------------
def update_collapse
normal_collapse if @collapse_type == 2
boss_collapse1 if @collapse_type == 3
end
#--------------------------------------------------------------------------
# ● 飛出動畫更新（圖片動畫）
#--------------------------------------------------------------------------
def update_balloon
@balloon_duration -= 1 if @balloon_duration > 0 && !@balloon_back
@balloon_duration += 1 if @balloon_back
if @balloon_duration == 64
@balloon_back = false
@balloon.visible = false
elsif @balloon_duration == 0
@balloon.visible = false if @balloon_loop == 0
@balloon_back = true if @balloon_loop == 1
end
@balloon.x = self.x
@balloon.y = self.y
@balloon.z = 10
@balloon.opacity = self.opacity
sx = 7 * 32 if @balloon_duration < 12
sx = (7 - (@balloon_duration - 12) / 8) * 32 unless @balloon_duration < 12
@balloon.src_rect.set(sx, @balloon_id * 32, 32, 32)
end
#--------------------------------------------------------------------------
# ● 轉送處bitmap的更新 ※再定義
#--------------------------------------------------------------------------
def update_battler_bitmap
if @battler.actor?
if @battler.character_name != @battler_name or @battler.battler_hue != @battler_hue
@battler_name = @battler.character_name
@battler_hue = @battler.battler_hue
end
else
if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
@battler_name = @battler.battler_name
@battler_hue = @battler.battler_hue
end
if [email protected]?
self.opacity = 0 if @effect_duration == 0 && @battler.collapse_type != 1
end
end
end
#--------------------------------------------------------------------------
# ● 實行動作
#--------------------------------------------------------------------------
def action
return if @active_action == nil
action = @active_action[0]
# 反轉時
return mirroring if action == "反轉"
# 旋轉時
return angling if action == "angle"
# 擴大縮小時
return zooming if action == "zoom"
# 殘像ON時
return mirage_on if action == "殘像ON"
# 殘像OFF時
return mirage_off if action == "殘像OFF"
# 圖片表示時
return picture if action == "pic"
# 圖片消去時
return @picture.visible = false && @picture_time = 0 if action == "消去圖片"
# 圖片文件變更時
return graphics_change if action == "change"
# 戰鬥動畫表示時
return battle_anime if action == "anime"
# 飛出動畫表示時（圖片動畫）
return balloon_anime if action == "balloon"
# BGM/BGS/SE演奏時
return sound if action == "sound"
# 遊戲開關操作時
return $game_switches[@active_action[1]] = @active_action[2] if action == "switch"
# 遊戲變量操作時
return variable if action == "variable"
# 二刀限定時
return two_swords if action == "二刀限定"
# 非二刀限定時
return non_two_swords if action == "非二刀限定"
# 動作條件時
return necessary if action == "nece"
# 技能連發時
return derivating if action == "der"
# 單獨處理開始時
return individual_action if action == "個別處理開始"
# 單獨處理完畢時
return individual_action_end if action == "個別處理完畢"
# 待機不能移動場合
return non_repeat if action == "待機不能移動"
# 變更初期位置時
return @battler.change_base_position(self.x, self.y) if action == "變更初期位置"
# 解除變更初期位置
return @battler.base_position if action == "變更初期位置解除"
# 變更目標時
return change_target if action == "target"
# 目標的擊倒許可
return send_action(action) if action == "擊倒許可"
# 解除主動
return send_action(action) if action == "解除主動"
# 賦予狀態時
return state_on if action == "sta+"
# 解除狀態時
return state_off if action == "sta-"
# 變更遊戲整體的行進速度時
return Graphics.frame_rate = @active_action[1] if action == "fps"
# 漂浮時
return floating if action == "float"
# 腳本操作時
return eval(@active_action[1]) if action == "script"
# 強制動作時
return force_action if @active_action.size == 4
# 坐標初始化時
return reseting if @active_action.size == 5
# 移動時
return moving if @active_action.size == 7
# 角色動畫時
return battler_anime if @active_action.size == 9
# 動畫飛時
return moving_anime if @active_action.size == 11
# 完畢時
return anime_finish if action == "完畢"
end
#--------------------------------------------------------------------------
# ● 實行反轉
#--------------------------------------------------------------------------
def mirroring
# 如果已經反轉就還原
if self.mirror
self.mirror = false
# 武器動畫也反映
@weapon_R.mirroring if @anime_flug
else
self.mirror = true
# 武器動畫也反映
@weapon_R.mirroring if @anime_flug
end
end
#--------------------------------------------------------------------------
# ● 實行旋轉
#--------------------------------------------------------------------------
def angling
# 初期化跳躍
jump_reset
# 情報確認
@angle_time = @active_action[1]
start_angle = @active_action[2]
end_angle = @active_action[3]
@angle_reset = @active_action[4]
# 襲擊時時逆轉
start_angle *= -1 if $back_attack
end_angle *= -1 if $back_attack
# 敵方被逆轉
start_angle *= -1 if @battler.is_a?(Game_Enemy)
end_angle *= -1 if @battler.is_a?(Game_Enemy)
# 時間要是0以下時立即到最後角度
if @angle_time <= 0
self.angle = end_angle
return @angle_time = 0
end
# 從旋轉時間計算一格相當於的角度
@angling = (end_angle - start_angle) / @angle_time
# 不能整除的剩餘到初期角度
@angle = (end_angle - start_angle) % @angle_time + start_angle
end
#--------------------------------------------------------------------------
# ● 實行放大縮小
#--------------------------------------------------------------------------
def zooming
# 初期化跳躍
jump_reset
# 情報確認
@zoom_time = @active_action[1]
zoom_x = @active_action[2] - 1
zoom_y = @active_action[3] - 1
@zoom_reset = @active_action[4]
@zoom_x = @zoom_y = 1
# 時間是0以下時跳過
return @zoom_time = 0 if @zoom_time <= 0
# 從放大時間中計算一格相當於的放大率
@zooming_x = zoom_x / @zoom_time
@zooming_y = zoom_y / @zoom_time
end
#--------------------------------------------------------------------------
# ● 殘像開始
#--------------------------------------------------------------------------
def mirage_on
# 戰鬥不能時不表現殘像
return if @battler.dead?
@mirage0 = Sprite.new(self.viewport)
@mirage1 = Sprite.new(self.viewport)
@mirage2 = Sprite.new(self.viewport)
@mirage_flug = true
@mirage_count = 0
end
#--------------------------------------------------------------------------
# ● 殘像表示
#--------------------------------------------------------------------------
def mirage(body)
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
body.mirror = self.mirror
body.angle = @angle
body.opacity = 160
body.zoom_x = self.zoom_x
body.zoom_y = self.zoom_y
body.src_rect.set(@sx, @sy, @width, @height) if @anime_flug
body.src_rect.set(0, 0, @width, @height) unless @anime_flug
end
#--------------------------------------------------------------------------
# ● 殘像完畢
#--------------------------------------------------------------------------
def mirage_off
@mirage_flug = false
@mirage0.dispose if @mirage0 != nil
@mirage1.dispose if @mirage1 != nil
@mirage2.dispose if @mirage2 != nil
end
#--------------------------------------------------------------------------
# ● 圖片表示
#--------------------------------------------------------------------------
def picture
# 確認移動開始位置
pic_x = @active_action[1]
pic_y = @active_action[2]
# 確認移動完畢位置
pic_end_x = @active_action[3]
pic_end_y = @active_action[4]
@picture_time = @active_action[5]
# 用時間除、計算一個相當於的移動速度
@moving_pic_x = (pic_end_x - pic_x)/ @picture_time
@moving_pic_y = (pic_end_y - pic_y)/ @picture_time
# 不能整除時到最初上加算
plus_x = (pic_end_x - pic_x)% @picture_time
plus_y = (pic_end_y - pic_y)% @picture_time
# 圖片表示
@picture.bitmap = Cache.picture(@active_action[7])
@picture.x = pic_x + plus_x
@picture.y = pic_y + plus_y
# Z坐標調整
@picture.z = 1
@picture.z = 1000 if @active_action[6]
@picture.visible = true
end
#--------------------------------------------------------------------------
# ● 圖像文件變更
#--------------------------------------------------------------------------
def graphics_change
# 主人公限定
return if @battler.is_a?(Game_Enemy)
# 圖像變更
@battler_name = @active_action[2]
# 是否使用步行圖像中改變轉送處的矩形
self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
# 獲取轉送處的矩形
@width = self.bitmap.width / @base_width
@height = self.bitmap.height / @base_height
# 如果想讓戰鬥後的人物圖也顯示為變更
@before_graphic = @battler.character_name if @active_action[1]
@battler.graphic_change(@active_action[2])
end
#--------------------------------------------------------------------------
# ● 顯示戰鬥動畫 [判別,ID,對像,反轉,等待,二刀標誌]
#--------------------------------------------------------------------------
def battle_anime
# 取消敵人的二刀標誌動畫處理
return if @active_action[5] && [email protected]?
# 不是二刀的角色，取消二刀標誌動畫處
return if @active_action[5] && @battler.weapons[1] == nil
# 如果二刀為右手（上面設置過）無武器
if @battler.actor?
return if !@active_action[5] && @battler.weapons[0] == nil && @battler.weapons[1] != nil
end
anime_id = @active_action[1]
# 偷襲時動畫畫像被反轉
if $back_attack
mirror = true if @active_action[3] == false
mirror = false if @active_action[3]
end
# 武器和技能動畫時
if anime_id < 0
# 用行動的種類分歧動畫處
if @battler.action.skill? && anime_id != -2
anime_id = @battler.action.skill.animation_id
elsif @battler.action.item? && anime_id != -2
anime_id = @battler.action.item.animation_id
else
# 沒有武器時使用空手動畫
anime_id = N01::NO_WEAPON
if @battler.actor?
weapon_id = @battler.weapon_id
anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
# 二刀動畫時
anime_id = @battler.atk_animation_id2 if @active_action[5]
else
weapon_id = @battler.weapon
anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
end
end
# 等待設定
@wait = $data_animations[anime_id].frame_max * 4 if $data_animations[anime_id] != nil && @active_action[4]
waitflug = true
# 顯示傷害動畫時、為了先計算出傷害計
damage_action = [anime_id, mirror, true]
return @battler.play = ["對像動畫",damage_action] if @battler.active
end
# 實行動畫
if @active_action[2] == 0 && $data_animations[anime_id] != nil
@battler.animation_id = anime_id
@battler.animation_mirror = mirror
elsif $data_animations[anime_id] != nil
for target in @target_battler
target.animation_id = anime_id
target.animation_mirror = mirror
end
end
# 等待設定
@wait = $data_animations[anime_id].frame_max * 4 if $data_animations[anime_id] != nil && @active_action[4] && !waitflug
end
#--------------------------------------------------------------------------
# ● 顯示飛出動畫（圖片動畫）
#--------------------------------------------------------------------------
def balloon_anime
return if self.opacity == 0
if @balloon == nil
@balloon = Sprite.new
@balloon.bitmap = Cache.system("Balloon")
@balloon.ox = @width / 16
@balloon.oy = @balloon.height / 10 + @height / 3
end
@balloon_id = @active_action[1]
@balloon_loop = @active_action[2]
@balloon_duration = 64
@balloon_back = false
update_balloon
@balloon.visible = true
end
#--------------------------------------------------------------------------
# ● BGM/BGS/SE演奏
#--------------------------------------------------------------------------
def sound
# 獲取情報
pitch = @active_action[2]
vol = @active_action[3]
name = @active_action[4]
# 實行
case @active_action[1]
when "se"
Audio.se_play("Audio/SE/" + name, vol, pitch)
when "bgm"
# 沒有指定名字時、不改變現在的BGM
if @active_action[4] == ""
now_bgm = RPG::BGM.last
name = now_bgm.name
end
Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
when "bgs"
# 沒有指定名字時、不改變現在的BGS
if @active_action[4] == ""
now_bgs = RPG::BGS.last
name = now_bgs.name
end
Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
end
end
#--------------------------------------------------------------------------
# ● 遊戲變量操作
#--------------------------------------------------------------------------
def variable
# 檢查操作
operand = @active_action[3]
# 變數操作的分歧
case @active_action[2]
when 0 # 代入
$game_variables[@active_action[1]] = operand
when 1 # 加算
$game_variables[@active_action[1]] += operand
when 2 # 減算
$game_variables[@active_action[1]] -= operand
when 3 # 乘算
$game_variables[@active_action[1]] *= operand
when 4 # 除算
$game_variables[@active_action[1]] /= operand
when 5 # 剩餘
$game_variables[@active_action[1]] %= operand
end
end
#--------------------------------------------------------------------------
# ● 二刀限定
#--------------------------------------------------------------------------
def two_swords
# 敵方不被處理
return @action.shift unless @battler.actor?
# 左手(下部顯示)沒有武器就會消除下面
return @action.shift if @battler.weapons[1] == nil
# 從行動配類的前面移動
active = @action.shift
# 確定現在的動作
@active_action = N01::ANIME[active]
# 等待設定
@wait = active.to_i if @active_action == nil
# 單獨動作開始
action
end
#--------------------------------------------------------------------------
# ● 非二刀限定
#--------------------------------------------------------------------------
def non_two_swords
# 敵方不被處理
return unless @battler.actor?
# 左手(下部顯示)沒有武器就會消除下面
return @action.shift if @battler.weapons[1] != nil
# 從行動配類的前面移動
active = @action.shift
# 確定現在的動作
@active_action = N01::ANIME[active]
# 等待設定
@wait = active.to_i if @active_action == nil
# 單獨動作開始
action
end
#--------------------------------------------------------------------------
# ● 動作條件
#--------------------------------------------------------------------------
def necessary
nece1 = @active_action[3]
nece2 = @active_action[4]
# 目標確認
case @active_action[1]
#0自身 1目標 2敵全體 3我方全體
when 0
target = [$game_party.members[@battler.index]] if @battler.is_a?(Game_Actor)
target = [$game_troop.members[@battler.index]] if @battler.is_a?(Game_Enemy)
when 1
target = @target_battler
when 2
target = $game_troop.members
when 3
target = $game_party.members
end
# 目標為空出時看作失敗
return start_action(@battler.recover_action) if target.size == 0
# 內容確認
case @active_action[2]
# 指定了狀態ID時
when 0
# 補充正號為「正在此狀態」、負號為「不在此狀態」的條件
state_on = true if nece2 > 0
# 獲取條件人數
state_member = nece2.abs
# 0從隊友數中獲取
if nece2 == 0
state_member = $game_party.members.size if @battler.is_a?(Game_Actor)
state_member = $game_troop.members.size if @battler.is_a?(Game_Enemy)
end
# 目標的狀態確認後清點人數
for member in target
state_member -= 1 if member.state?(nece1)
end
# 條件全部滿足後執行動作
if state_member == 0 && state_on
return
elsif state_member == nece2.abs
return if state_on == nil
end
# 指定了參數時
when 1
# 補充了正號為「數值以上」、負號為「數值以下」的條件
num_over = true if nece2 > 0
# 參照數值
num = 0
# 確認目標的參數
for member in target
# 參照參數來分歧
case nece1
when 0 # 現HP
num += member.hp
when 1 # 現MP
num += member.mp
when 2 # 攻擊力
num += member.atk
when 3 # 防禦力
num += member.def
when 4 # 精神力
num += member.spi
when 5 # 敏捷性
num += member.agi
end
end
# 平均
num = num / target.size
# 條件全部滿足後執行動作
if num > nece2.abs && num_over
return
elsif num < nece2.abs
return if num_over == nil
end
# 指定了開關時
when 2
# 條件全部滿足後執行動作
if $game_switches[nece1]
# 補充為true時「開關ON」、false時「開關OFF」的條件
return if nece2
# 開關為OFF時與ON時是相反的
else
return unless nece2
end
# 指定了變量時
when 3
#補充為正號時「數值以上」、負號時「數值以下」的條件
if nece2 > 0
return if $game_variables[nece1] > nece2
else
return unless $game_variables[nece1] > nece2.abs
end
# 指定了習得技能時
when 4
# 獲取技能條件人數
skill_member = nece2.abs
for member in target
skill_member -= 1 if member.skill_learn?(nece1)
# 條件確認
return if skill_member == 0
end
end
# 條件沒有被滿足時動作中斷
return @action = ["完畢"] if @non_repeat
# 不讓防禦中看起來不自然，坐標不被還原
action = @battler.recover_action
action = @battler.defence if @battler.guarding?
return start_action(action)
end
#--------------------------------------------------------------------------
# ● 技能連發
#--------------------------------------------------------------------------
def derivating
# 如果讓沒學的的技能不能連發時
return if !@active_action[2] && [email protected]_id_learn?(@active_action[3])
# 確率分岐
return if rand(100) > @active_action[1]
# 連發成功
@battler.derivation = @active_action[3]
# 之後的動作被中斷
@action = ["完畢"]
end
#--------------------------------------------------------------------------
# ● 個別處理開始
#--------------------------------------------------------------------------
def individual_action
# 反覆標誌ON
@battler.individual = true
# 保持反覆動作
@individual_act = @action.dup
# 保持目標、一個一個的發出行動目標
send_action(["個別處理"])
@individual_targets = @target_battler.dup
@target_battler = [@individual_targets.shift]
end
#--------------------------------------------------------------------------
# ● 個別處理完畢
#--------------------------------------------------------------------------
def individual_action_end
# 目標沒有殘留時行動完畢
return @battler.individual = false if @individual_targets.size == 0
@action = @individual_act.dup
@target_battler = [@individual_targets.shift]
end
#--------------------------------------------------------------------------
# ● 待機不能移動
#--------------------------------------------------------------------------
def non_repeat
@repeat_action = []
@non_repeat = true
anime_finish
end
#--------------------------------------------------------------------------
# ● 目標變更 action = [判別, 變更對像, 變更處]
#--------------------------------------------------------------------------
def change_target
# 還原自身變更了的目標
return @target_battler = @now_targets.dup if @active_action[2] == 3
# 發送目標情報
target = [@battler] if @active_action[2] == 0
target = @target_battler.dup if @active_action[2] != 0
# 自身的目標發送到對方時、記錄現在的
if @active_action[2] == 2
@now_targets = @target_battler.dup
@target_battler = []
end
# 發送目標指定目錄時
if @active_action[1] >= 1000
members = $game_party.members if @battler.actor?
members = $game_troop.members unless @battler.actor?
index = @active_action[1] - 1000
if index < members.size
if members[index].exist? && @battler.index != index
# 目標變更
members[index].force_target = ["N01target_change", target]
# 自身的目標發送到相手時
@target_battler = [members[index]] if @active_action[2] == 2
change = true
else
for member in members
next if @battler.index == member.index
next unless member.exist?
member.force_target = ["N01target_change", target]
@target_battler = [member] if @active_action[2] == 2
break change = true
end
end
end
# 指定了發送目標的狀態ID時
elsif @active_action[1] > 0
for member in $game_party.members + $game_troop.members
if member.state?(@active_action[1])
member.force_target = ["N01target_change", target]
@target_battler.push(member) if @active_action[2] == 2
change = true
end
end
# 指定了發送目標學的的技能時
elsif @active_action[1] < 0
skill_id = @active_action[1].abs
for actor in $game_party.members
if actor.skill_id_learn?(skill_id)
actor.force_target = ["N01target_change", target]
@target_battler.push(target) if @active_action[2] == 2
change = true
end
end
# 發送目標是目標時
else
for member in @target_battler
member.force_target = ["N01target_change", target]
@target_battler.push(member) if @active_action[2] == 2
change = true
end
end
# 條件沒有被滿足時動作中斷
return if change
return @action = ["完畢"] if @non_repeat
return start_action(@battler.recover_action)
end
#--------------------------------------------------------------------------
# ● 狀態付與
#--------------------------------------------------------------------------
def state_on
state_id = @active_action[2]
# 分歧對像
case @active_action[1]
when 0
@battler.add_state(state_id) if rand(100) < @battler.state_probability(state_id)
when 1
if @target_battler != nil
for target in @target_battler
target.add_state(state_id) if rand(100) < target.state_probability(state_id)
end
end
when 2
for target in $game_troop.members
target.add_state(state_id) if rand(100) < target.state_probability(state_id)
end
when 3
for target in $game_party.members
target.add_state(state_id) if rand(100) < target.state_probability(state_id)
end
when 4
for target in $game_party.members
if target.index != @battler.index
target.add_state(state_id) if rand(100) < target.state_probability(state_id)
end
end
end
end
#--------------------------------------------------------------------------
# ● 狀態解除
#--------------------------------------------------------------------------
def state_off
state_id = @active_action[2]
# 分歧對像
case @active_action[1]
when 0
@battler.remove_state(state_id)
when 1
if @target_battler != nil
for target in @target_battler
target.remove_state(state_id)
end
end
when 2
for target in $game_troop.members
target.remove_state(state_id)
end
when 3
for target in $game_party.members
target.remove_state(state_id)
end
when 4
for target in $game_party.members
if target.index != @battler.index
target.remove_state(state_id)
end
end
end
end
#--------------------------------------------------------------------------
# ● 浮遊實行
#--------------------------------------------------------------------------
def floating
# 初期化跳躍
jump_reset
# 情報確認
@jump_plus = @active_action[1]
float_end = @active_action[2]
@float_time = @active_action[3]
# 計算一格相當的移動高度
@float_up = (float_end - @jump_plus)/ @float_time
# 漂浮結束前不執行下個動作
@wait = @float_time
# 反映漂浮動畫的設定
if @anime_flug
move_anime = N01::ANIME[@active_action[4]]
# 沒有指定圖片時跳過處理
if move_anime != nil
# 寫下現在的動作
@active_action = move_anime
# 角色動畫開始
battler_anime
# 漂浮完畢時即動畫完畢
@anime_end = true
end
end
# 漂浮到初期高度
@battler.jump = @jump_plus
end
#--------------------------------------------------------------------------
# ● 強制動作
#--------------------------------------------------------------------------
def force_action
# 動作是單獨還是通用的判別
kind = @active_action[0]
# 確認有無復原
rebirth = @active_action[2]
# 獲取強制動作的內容
play = @active_action[3]
# 歸納上面3個情報
action = [kind,rebirth,play]
# 目標指定目錄時
if @active_action[1] >= 1000
members = $game_party.members if @battler.actor?
members = $game_troop.members unless @battler.actor?
index = @active_action[1] - 1000
if index < members.size
if members[index].exist? && @battler.index != index
# 交付角色情報
return members[index].force_action = action
else
for target in members
next if @battler.index == target.index
next unless target.exist?
force = true
break target.force_action = action
end
end
end
# 條件沒有被滿足時動作中斷
return if force
return @action = ["完畢"] if @non_repeat
return start_action(@battler.recover_action)
# 指定目標時
elsif @active_action[1] == 0
for target in @target_battler
target.force_action = action if target != nil
end
# 指定了狀態ID時
elsif @active_action[1] > 0
for target in $game_party.members + $game_troop.members
target.force_action = action if target.state?(@active_action[1])
end
# 指定了習得技能時
elsif @active_action[1] < 0
# 敵方不被處理
return if @battler.is_a?(Game_Enemy)
for actor in $game_party.members
# 自身除外
unless actor.id == @battler.id
# 交付角色情報
actor.force_action = action if actor.skill_id_learn?(@active_action[1].abs)
end
end
end
end
#--------------------------------------------------------------------------
# ● 實行坐標初始化
#--------------------------------------------------------------------------
def reseting
# 初期化跳躍
jump_reset
# 回轉元戾
self.angle = 0
# 情報確認
@distanse_x = @move_x * -1
@distanse_y = @move_y * -1
@move_speed_x = @active_action[1]
@move_speed_y = @move_speed_x
@move_boost_x = @active_action[2]
@move_boost_y = @move_boost_x
@jump = @active_action[3]
# 計算移動
move_distance
# 反映移動畫面的設定
if @anime_flug
move_anime = N01::ANIME[@active_action[4]]
# 沒有指定圖片時跳過處理
if move_anime != nil
# 寫下現在的動作
@active_action = move_anime
# 角色動畫開始
battler_anime
end
# 移動完畢時即動畫也完畢
@anime_end = true
end
end
#--------------------------------------------------------------------------
# ● 計算移動
#--------------------------------------------------------------------------
def moving
# 初期化跳躍
jump_reset
# 方便調出X軸的移動
xx = @active_action[1]
# 襲擊時X軸逆轉
xx *= -1 if $back_attack
# 確認移動目標的目標
case @active_action[0]
when 0 # 自身
@distanse_x = xx
@distanse_y = @active_action[2]
when 1 # 目標
# 目標沒有決定時、變換成自身
if @target_battler == nil
@distanse_x = xx
@distanse_y = @active_action[2]
else
# 一個一個的確認目標對像
target_x = 0
target_y = 0
time = 0
for i in 0...@target_battler.size
if @target_battler[i] != nil
time += 1
target_x += @target_battler[i].position_x
target_y += @target_battler[i].position_y
end
end
# 目標空出時、變換成自身
if time == 0
@distanse_x = xx
@distanse_y = @active_action[2]
else
# 計算出複數目標的中心位置
target_x = target_x / time
target_y = target_y / time
# 算出最終的移動距離
@distanse_y = target_y - self.y + @active_action[2]
# X坐標是角色和敵人的逆向計算
if @battler.is_a?(Game_Actor)
@distanse_x = target_x - self.x + xx
else
@distanse_x = self.x - target_x + xx
end
end
end
when 2 # 畫面
# X坐標是角色和敵人的逆向計算
if @battler.is_a?(Game_Actor)
@distanse_x = xx - self.x
@distanse_x = Graphics.width + xx - self.x if $back_attack
else
@distanse_x = self.x - xx
@distanse_x = self.x - (Graphics.width + xx) if $back_attack
end
@distanse_y = @active_action[2] - self.y
when 3 # 初期位置
# X坐標是角色和敵人的逆向計算
if @battler.is_a?(Game_Actor)
@distanse_x = xx + @battler.base_position_x - self.x
else
@distanse_x = xx + self.x - @battler.base_position_x
end
@distanse_y = @active_action[2] + @battler.base_position_y - @battler.position_y
end
@move_speed_x = @active_action[3]
@move_speed_y = @active_action[3]
@move_boost_x = @active_action[4]
@move_boost_y = @active_action[4]
@jump = @active_action[5]
@jump_plus = 0
# 計算移動
move_distance
# 反映移動畫面的設定
if @anime_flug
move_anime = N01::ANIME[@active_action[6]]
# 沒有指定圖片時跳過處理
if move_anime != nil
# 寫下現在的動作
@active_action = move_anime
# 角色動畫開始
battler_anime
end
# 移動完畢時即動畫也完畢
@anime_end = true
end
end
#--------------------------------------------------------------------------
# ● 計算移動
#--------------------------------------------------------------------------
def move_distance
# 速度為0時、停留在那個地方
if @move_speed_x == 0
@moving_x = 0
@moving_y = 0
else
# 計算一格相當的移動距離
@moving_x = @distanse_x / @move_speed_x
@moving_y = @distanse_y / @move_speed_y
# 剩餘的距離在這時移動消化
over_x = @distanse_x % @move_speed_x
over_y = @distanse_y % @move_speed_y
@move_x += over_x
@move_y += over_y
@battler.move_x = @move_x
@battler.move_y = @move_y
@distanse_x -= over_x
@distanse_y -= over_y
end
# 判定是否移動
if @distanse_x == 0
@move_speed_x = 0
end
if @distanse_y == 0
@move_speed_y = 0
end
# X座標計算移動
# 根據加減速修正移動格數
boost_x = @moving_x
move_x = 0
# 加速時
if @move_boost_x > 0 && @distanse_x != 0
# 加減速的正負調整成左右移動
if @distanse_x == 0
@move_boost_x = 0
elsif @distanse_x < 0
@move_boost_x *= -1
end
# 事先計算距離的變化
for i in 0...@move_speed_x
boost_x += @move_boost_x
move_x += boost_x
# 記錄超過距離
over_distance = @distanse_x - move_x
# 記錄右移動時距離超越的時第幾格
if @distanse_x > 0 && over_distance < 0
@move_speed_x = i
break
# 記錄左移動時距離超越的時第幾格
elsif @distanse_x < 0 && over_distance > 0
@move_speed_x = i
break
end
end
# 將超越距離還原到前一次
before = over_distance + boost_x
# 剩餘的距離加算到等速移動的格數中
@move_speed_plus_x = (before / @moving_x).abs
# 即使這樣剩餘的距離也在這時移動消化
@move_x += before % @moving_x
@battler.move_x = @move_x
# 減速時
elsif @move_boost_x < 0 && @distanse_x != 0
# 加減速的正負調整成左右移動
if @distanse_x == 0
@move_boost_x = 0
elsif @distanse_x < 0
@move_boost_x *= -1
end
# 事先計算距離的變化
for i in 0...@move_speed_x
boost_x += @move_boost_x
move_x += boost_x
# 記錄不足的距離
lost_distance = @distanse_x - move_x
before = lost_distance
# 記錄右移動速度到0時是第幾格
if @distanse_x > 0 && boost_x < 0
@move_speed_x = i - 1
# 不足的距離還原到前一次
before = lost_distance + boost_x
break
# 記錄左移動速度到0時是第幾格
elsif @distanse_x < 0 && boost_x > 0
@move_speed_x= i - 1
# 不足的距離還原到前一次
before = lost_distance + boost_x
break
end
end
# 不足的距離加算到等速移動的格數中
plus = before / @moving_x
@move_speed_plus_x = plus.abs
# 即使這樣剩餘的距離也在這時移動消化
@move_x += before % @moving_x
@battler.move_x = @move_x
end
# Y座標計算移動
# 根據加減速修正移動格數
boost_y = @moving_y
move_y = 0
# 加速時
if @move_boost_y > 0 && @distanse_y != 0
# 加減速的正負調整成左右移動
if @distanse_y == 0
@move_boost_y = 0
elsif @distanse_y < 0
@move_boost_y *= -1
end
# 事先計算距離的變化
for i in 0...@move_speed_y
boost_y += @move_boost_y
move_y += boost_y
# 記錄超過距離
over_distance = @distanse_y - move_y
# 記錄右移動時距離超越的時第幾格
if @distanse_y > 0 && over_distance < 0
@move_speed_y = i
break
# 記錄左移動時距離超越的時第幾格
elsif @distanse_y < 0 && over_distance > 0
@move_speed_y = i
break
end
end
# 將超越距離還原到前一次
before = over_distance + boost_y
# 剩餘的距離加算到等速移動的格數中
@move_speed_plus_y = (before / @moving_y).abs
# 即使這樣剩餘的距離也在這時移動消化
@move_y += before % @moving_y
@battler.move_y = @move_y
# 減速時
elsif @move_boost_y < 0 && @distanse_y != 0
# 加減速的正負調整成左右移動
if @distanse_y == 0
@move_boost_y = 0
elsif @distanse_y < 0
@move_boost_y *= -1
end
# 事先計算距離的變化
for i in 0...@move_speed_y
boost_y += @move_boost_y
move_y += boost_y
# 記錄不足的距離
lost_distance = @distanse_y - move_y
before = lost_distance
# 記錄右移動速度到0時是第幾格
if @distanse_y > 0 && boost_y < 0
@move_speed_y = i
# 不足的距離還原到前一次
before = lost_distance + boost_y
break
# 記錄左移動速度到0時是第幾格
elsif @distanse_y < 0 && boost_y > 0
@move_speed_y = i
# 不足的距離還原到前一次
before = lost_distance + boost_y
break
end
end
# 不足的距離加算到等速移動的格數中
plus = before / @moving_y
@move_speed_plus_y = plus.abs
# 即使這樣剩餘的距離也在這時移動消化
@move_y += before % @moving_y
@battler.move_y = @move_y
end
# 算出移動完畢的時間
x = @move_speed_plus_x + @move_speed_x
y = @move_speed_plus_y + @move_speed_y
if x > y
end_time = x
else
end_time = y
end
# 移動完畢前不進行下個動作
@wait = end_time
# 計算跳躍
if @jump != 0
# 沒有移動只跳躍時
if @wait == 0
# 時間記入
@wait = @active_action[3]
end
# 從移動完畢時間算出跳躍時間
@jump_time = @wait / 2
# 不能插入時的剩餘時間
@jump_time_plus = @wait % 2
# 判別跳躍是正還是負
@jump_sign = 0
@jump_sign2 = 0
if @jump < 0
@jump_sign = -1
@jump_sign2 = 1
@jump = @jump * -1
else
@jump_sign = 1
@jump_sign2 = -1
end
# 決定跳躍初始速度
@jump_up = 2 ** @jump * @jump_sign
# 略微調整條約時間的尾數
if @jump_time == 0
@jump_up = 0
elsif @jump_time != 1
@jump_size = @jump_up * @jump_sign * @jump_sign2
else
@jump_size = @jump_up * 2 * @jump_sign * @jump_sign2
@jump_flug = true
end
end
end
#--------------------------------------------------------------------------
# ● 角色動畫開始
#--------------------------------------------------------------------------
def battler_anime
# 反映動畫設定
@anime_kind = @active_action[1]
@anime_speed = @active_action[2]
@anime_loop = @active_action[3]
# 如果有等待時間時加算
@unloop_wait = @active_action[4]
@anime_end = true
@reverse = false
# 只有有武器動作時進行更新
if @weapon_R != nil && @active_action[8] != ""
# 確認武器的設定
weapon_kind = N01::ANIME[@active_action[8]]
# 敵方和不使用二刀角色的取消二刀標誌
two_swords_flug = weapon_kind[11]
return if two_swords_flug && [email protected]?
return if two_swords_flug && @battler.weapons[1] == nil && @battler.actor?
if @battler.actor? && @battler.weapons[0] == nil && !two_swords_flug
@weapon_R.action_reset
elsif @battler.actor? && @battler.weapons[1] == nil && two_swords_flug
@weapon_R.action_reset
elsif [email protected]? && @battler.weapon == 0
@weapon_R.action_reset
else
# 初期化
@weapon_R.action_reset
# 動畫圖像是固定時的獲取武器位置
if @active_action[5] != -1
@weapon_R.freeze(@active_action[5])
end
# 設定武器畫像
@weapon_R.weapon_graphics unless two_swords_flug
@weapon_R.weapon_graphics(true) if two_swords_flug
# 交付武器動作
@weapon_R.weapon_action(@active_action[8],@anime_loop)
@weapon_action = true
# 更新最初的武器動作
@weapon_R.action
end
elsif @weapon_R != nil
@weapon_R.action_reset
end
@anime_end = false
# 動畫圖片是固定時
if @active_action[5] != -1 && @active_action[5] != -2
# 標誌ON
@anime_freeze = true
# 看作動畫是通常的完畢了
@anime_end = true
# 單程逆轉再生時
elsif @active_action[5] == -2
@anime_freeze = false
# 標誌ON
@reverse = true
# 更新最初的動畫圖像
@pattern = @base_width - 1
# 只有在有武器動畫時更新
if @weapon_action && @weapon_R != nil
@weapon_R.action
@weapon_R.update
end
# 更新通常動畫時
else
@anime_freeze = false
# 更新最初的動畫圖像
@pattern = 0
# 只有在有武器動畫時更新
if @weapon_action && @weapon_R != nil
@weapon_R.action
@weapon_R.update
end
end
@pattern_back = false
@frame = @anime_speed
# Z座標設定
@battler.move_z = @active_action[6]
# 是否有影
if @shadow != nil
@shadow.visible = true if @active_action[7]
@shadow.visible = false unless @active_action[7]
end
# 分期從編號讀取文件名
if @active_action[0] == 0
file_name = @battler_name
else
file_name = @battler_name + "_" + @active_action[0].to_s
end
# 無動畫角色時處理完畢
return unless @anime_flug
self.bitmap = Cache.character(file_name)
# 設定轉送處的矩形
@sx = @pattern * @width
@sy = @anime_kind * @height
@sx = @active_action[5] * @width if @anime_freeze
self.src_rect.set(@sx, @sy, @width, @height)
end
#--------------------------------------------------------------------------
# ● 動畫飛出
#--------------------------------------------------------------------------
def moving_anime
# 如果前個飛出動畫還有殘留時初期化
@move_anime.action_reset if @anime_moving
@anime_moving = true
# 襲擊中動畫、武器畫像反轉
mirror = false
mirror = true if $back_attack
# 動畫ID
id = @active_action[1]
# 對像
target = @active_action[2]
x = y = mem = 0
# 對像為單體時
if target == 0
# 目標沒有決定時、變換成自身
if @target_battler == nil
x = self.x
y = self.y
else
# 沒有決定目標時、變換為自身
if @target_battler[0] == nil
x = self.x
y = self.y
else
# 目標空出時、變換為自身
x = @target_battler[0].position_x
y = @target_battler[0].position_y
end
end
# 對像在敵方中心時
elsif target == 1
# 自身是主人公時計算敵方的中心
if @battler.is_a?(Game_Actor)
for target in $game_troop.members
x += target.position_x
y += target.position_y
mem += 1
end
x = x / mem
y = y / mem
# 自身是敵方時計算主人公的中心
else
for target in $game_party.members
x += target.position_x
y += target.position_y
mem += 1
end
x = x / mem
y = y / mem
end
# 對像在我方中心時
elsif target == 2
# 自身是主人公時計算主人公的中心
if @battler.is_a?(Game_Actor)
for target in $game_party.members
x += target.position_x
y += target.position_y
mem += 1
end
x = x / mem
y = y / mem
# 自身是敵方時計算敵方的中心
else
for target in $game_troop.members
x += target.position_x
y += target.position_y
mem += 1
end
x = x / mem
y = y / mem
end
# 對象是自身時
else
x = self.x
y = self.y
end
# 開始位置的略微調整
plus_x = @active_action[6]
plus_y = @active_action[7]
# 敵方是X軸逆轉
plus_x *= -1 if @battler.is_a?(Game_Enemy)
# 算出最終的移動距離
distanse_x = x - self.x - plus_x
distanse_y = y - self.y - plus_y
# 飛出類型
type = @active_action[3]
# 速度
speed = @active_action[4]
# 軌道
orbit = @active_action[5]
# 如果自身在開始位置時
if @active_action[8] == 0
@move_anime.base_x = self.x + plus_x
@move_anime.base_y = self.y + plus_y
# 對像在開始位置時
elsif @active_action[8] == 1
@move_anime.base_x = x + plus_x
@move_anime.base_y = y + plus_y
# 把距離作為反面
distanse_y = distanse_y * -1
distanse_x = distanse_x * -1
# 如果不能動
else
@move_anime.base_x = x
@move_anime.base_y = y
distanse_x = distanse_y = 0
end
# 無武器動作時不顯示武器
if @active_action[10] == ""
weapon = ""
# 無動畫的敵方不顯示武器
elsif @anime_flug != true
weapon = ""
# 武器動作時
else
# 確認是否指定了飛出武器圖片
if @battler.is_a?(Game_Actor)
battler = $game_party.members[@battler.index]
weapon_id = battler.weapon_id
else
battler = $game_troop.members[@battler.index]
weapon_id = battler.weapon
end
# 判別是武器動作情報取得還是使用武器畫像
weapon_act = N01::ANIME[@active_action[10]].dup if @active_action[10] != ""
# 如果利用武器畫像時並不是空手
if weapon_id != 0 && weapon_act.size == 3
weapon_file = $data_weapons[weapon_id].flying_graphic
# 如果沒有指定別的畫像時獲取既存的武
if weapon_file == ""
weapon_name = $data_weapons[weapon_id].graphic
icon_weapon = false
# 然後沒有指定時使用ICON圖片
if weapon_name == ""
weapon_name = $data_weapons[weapon_id].icon_index
icon_weapon = true
end
# 指定時獲取那個圖片名
else
icon_weapon = false
weapon_name = weapon_file
end
# 武器動作情報取得
weapon = @active_action[10]
# 指定了武器畫像時不顯示空手
elsif weapon_act.size == 3
weapon = ""
# 使用技能畫像
elsif weapon_act != nil && @battler.action.skill != nil
icon_weapon = false
weapon_name = $data_skills[@battler.action.skill.id].flying_graphic
weapon = @active_action[10]
end
end
# 決定Z坐標
@move_anime.z = 1
@move_anime.z = 1000 if @active_action[9]
# 已上的全部情報都已飛出動畫送到精靈
@move_anime.anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,weapon_name,icon_weapon)
end
#--------------------------------------------------------------------------
# ● 動作完畢
#--------------------------------------------------------------------------
def anime_finish
# 單獨處理完畢省略時做反覆
return individual_action_end if @individual_targets.size != 0
# 主動向角色歸納動作情報
send_action(@active_action[0]) if @battler.active
# 如果有殘像時開放
mirage_off if @mirage_flug
# 重複待機動作
start_action(@repeat_action) unless @non_repeat
end
#--------------------------------------------------------------------------
# ● 擊倒動作
#--------------------------------------------------------------------------
def collapse_action
@non_repeat = true
@effect_type = COLLAPSE
@collapse_type = @battler.collapse_type unless @battler.actor?
@battler_visible = false unless @battler.actor?
@effect_duration = N01::COLLAPSE_WAIT + 48 if @collapse_type == 2
@effect_duration = 401 if @collapse_type == 3
end
#--------------------------------------------------------------------------
# ● 普通擊倒
#--------------------------------------------------------------------------
def normal_collapse
if @effect_duration == 47
Sound.play_enemy_collapse
self.blend_type = 1
self.color.set(255, 128, 128, 128)
end
self.opacity = 256 - (48 - @effect_duration) * 6 if @effect_duration <= 47
end
#--------------------------------------------------------------------------
# ● BOSS擊倒
#--------------------------------------------------------------------------
def boss_collapse1
if @effect_duration == 320
Audio.se_play("Audio/SE/Absorb1", 100, 80)
self.flash(Color.new(255, 255, 255), 60)
viewport.flash(Color.new(255, 255, 255), 20)
end
if @effect_duration == 280
Audio.se_play("Audio/SE/Absorb1", 100, 80)
self.flash(Color.new(255, 255, 255), 60)
viewport.flash(Color.new(255, 255, 255), 20)
end
if @effect_duration == 220
Audio.se_play("Audio/SE/Earth4", 100, 80)
reset
self.blend_type = 1
self.color.set(255, 128, 128, 128)
self.wave_amp = 6
end
if @effect_duration < 220
self.src_rect.set(0, @effect_duration / 2 - 110, @width, @height)
self.x += 8 if @effect_duration % 4 == 0
self.x -= 8 if @effect_duration % 4 == 2
self.wave_amp += 1 if @effect_duration % 10 == 0
self.opacity = @effect_duration
return if @effect_duration < 50
Audio.se_play("Audio/SE/Earth4", 100, 50) if @effect_duration % 50 == 0
end
end
end

复制代码

#==============================================================================
# ■ Scene_Battle Ver3.3
#------------------------------------------------------------------------------
# 　戰鬥畫面的處理的類。
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● 完畢處理
#--------------------------------------------------------------------------
alias terminate_n01 terminate
def terminate
terminate_n01
# 返還二刀流的替換處理
for member in $game_party.members
if member.two_swords_change
member.change_equip_by_id(1, member.weapon_id)
member.change_equip_by_id(0, 0)
member.two_swords_change = false
end
end
end
#--------------------------------------------------------------------------
# ● 戰鬥開始的處理
#--------------------------------------------------------------------------
alias process_battle_start_n01 process_battle_start
def process_battle_start
process_battle_start_n01
# 如果二刀流讓左(下部顯示)手武器像右(上部表示)手武器那樣沒有持有時
# 在這裡強制替換他
for member in $game_party.members
if member.weapons[0] == nil and member.weapons[1] != nil
member.change_equip_by_id(0, member.armor1_id)
member.change_equip_by_id(1, 0)
member.two_swords_change = true
end
end
end
#--------------------------------------------------------------------------
# ● 更新
#--------------------------------------------------------------------------
alias update_n01 update
def update
reset_stand_by_action
super
update_n01
end
#--------------------------------------------------------------------------
# ● 根據事件操作的HP變動再設置角色動畫
#--------------------------------------------------------------------------
def reset_stand_by_action
if $game_temp.status_window_refresh
$game_temp.status_window_refresh = false
for member in $game_party.members + $game_troop.members
@spriteset.set_stand_by_action(member.actor?, member.index)
# 確認自動復活
resurrection(member) if member.hp == 0
end
@status_window.refresh
end
end
#--------------------------------------------------------------------------
# ● 戰敗的處理
#--------------------------------------------------------------------------
alias process_defeat_n01 process_defeat
def process_defeat
for member in $game_party.members
@spriteset.set_stand_by_action(member.actor?, member.index)
end
process_defeat_n01
end
#--------------------------------------------------------------------------
# ● 幫助窗口的顯示
#--------------------------------------------------------------------------
def pop_help(obj)
return if obj.extension.include?("不顯示HELP")
@help_window = Window_Help.new if @help_window == nil
@help_window.set_text(obj.name, 1)
@help_window.visible = true
end
#--------------------------------------------------------------------------
# ● 顯示情報窗口的移動
#--------------------------------------------------------------------------
def move1_info_viewport
@info_viewport.ox = 128
loop do
update_basic
@info_viewport.ox -= 8
@party_command_window.x -= 8
@actor_command_window.x += 8
break if @info_viewport.ox == 64
end
end
#--------------------------------------------------------------------------
# ● 顯示情報窗口的移動
#--------------------------------------------------------------------------
def move2_info_viewport
@info_viewport.ox = 64
loop do
update_basic
@info_viewport.ox -= 8
@party_command_window.x += 8
@actor_command_window.x -= 8
break if @info_viewport.ox == 0
end
end
#--------------------------------------------------------------------------
# ● 到下個主人公的指令選擇
#--------------------------------------------------------------------------
alias next_actor_n01 next_actor
def next_actor
# 只有能動的角色顯示指令動作
if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
@spriteset.set_action(true, @actor_index,@active_battler.command_a)
end
# 最後的角色時、動作結束前等待
@wait_count = 32 if @actor_index == $game_party.members.size-1
next_actor_n01
# 只有能動的角色現實指令動作
if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
@spriteset.set_action(true, @actor_index,@active_battler.command_b)
end
end
#--------------------------------------------------------------------------
# ● 到前一個角色的指令選擇
#--------------------------------------------------------------------------
alias prior_actor_n01 prior_actor
def prior_actor
# 只有能動的角色顯示指令動作
if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
@active_battler.action.clear
@spriteset.set_action(true, @actor_index,@active_battler.command_a)
end
prior_actor_n01
# 只有能動的角色顯示指令動作
if @active_battler != nil && @active_battler.inputable? && @active_battler.actor?
@active_battler.action.clear
@spriteset.set_action(true, @actor_index,@active_battler.command_b)
end
end
#--------------------------------------------------------------------------
# ● 目標選擇的開始 ※再定義
#--------------------------------------------------------------------------
def start_target_enemy_selection
start_target_selection
end
#--------------------------------------------------------------------------
# ● 目標選擇的開始 ※再定義
#--------------------------------------------------------------------------
def start_target_actor_selection
start_target_selection(true)
end
#--------------------------------------------------------------------------
# ● 目標選擇的開始
#--------------------------------------------------------------------------
def start_target_selection(actor = false)
members = $game_party.members if actor
members = $game_troop.members unless actor
# 光標精靈的作成
@cursor = Sprite.new
@cursor.bitmap = Cache.character("cursor")
@cursor.src_rect.set(0, 0, 32, 32)
@cursor_flame = 0
@cursor.x = -200
@cursor.y = -200
@cursor.ox = @cursor.width
@cursor.oy = @cursor.height
# 作成顯示目標名的幫助窗口
@help_window.visible = false if @help_window != nil
@help_window2 = Window_Help.new if @help_window2 == nil
# 消除不要的窗口
@actor_command_window.active = false
@skill_window.visible = false if @skill_window != nil
@item_window.visible = false if @item_window != nil
# 存在的目標為最底號碼的對象也想最初那樣
@index = 0
@max_index = members.size - 1
# 主人公為站都不能者也可以作為目標來與敵方區分
unless actor
members.size.times do
break if members[@index].exist?
@index += 1
end
end
@help_window2.set_text(members[@index].name, 1)
select_member(actor)
end
#--------------------------------------------------------------------------
# ● 目標選擇
#--------------------------------------------------------------------------
def select_member(actor = false)
members = $game_party.members if actor
members = $game_troop.members unless actor
loop do
update_basic
@cursor_flame = 0 if @cursor_flame == 30
@cursor.src_rect.set(0, 0, 32, 32) if @cursor_flame == 29
@cursor.src_rect.set(0, 32, 32, 32) if @cursor_flame == 15
point = @spriteset.set_cursor(actor, @index)
@cursor.x = point[0]
@cursor.y = point[1]
@cursor_flame += 1
if Input.trigger?(Input::B)
Sound.play_cancel
end_target_selection
break
elsif Input.trigger?(Input::C)
Sound.play_decision
@active_battler.action.target_index = @index
end_target_selection
end_skill_selection
end_item_selection
next_actor
break
end
if Input.repeat?(Input::LEFT)
if actor
cursor_down(members, actor) if $back_attack
cursor_up(members, actor) unless $back_attack
else
cursor_up(members, actor) if $back_attack
cursor_down(members, actor) unless $back_attack
end
end
if Input.repeat?(Input::RIGHT)
if actor
cursor_up(members, actor) if $back_attack
cursor_down(members, actor) unless $back_attack
else
cursor_down(members, actor) if $back_attack
cursor_up(members, actor) unless $back_attack
end
end
cursor_up(members, actor) if Input.repeat?(Input::UP)
cursor_down(members, actor) if Input.repeat?(Input::DOWN)
end
end
#--------------------------------------------------------------------------
# ● 向前移動光標
#--------------------------------------------------------------------------
def cursor_up(members, actor)
Sound.play_cursor
members.size.times do
@index += members.size - 1
@index %= members.size
break if actor
break if members[@index].exist?
end
@help_window2.set_text(members[@index].name, 1)
end
#--------------------------------------------------------------------------
# ● 向後移動光標
#--------------------------------------------------------------------------
def cursor_down(members, actor)
Sound.play_cursor
members.size.times do
@index += 1
@index %= members.size
break if actor
break if members[@index].exist? && !actor
end
@help_window2.set_text(members[@index].name, 1)
end
#--------------------------------------------------------------------------
# ● 目標選擇的完畢
#--------------------------------------------------------------------------
def end_target_selection
@actor_command_window.active = true if @actor_command_window.index == 0
@skill_window.visible = true if @skill_window != nil
@item_window.visible = true if @item_window != nil
@cursor.dispose
@cursor = nil
if @help_window2 != nil
@help_window2.dispose
@help_window2 = nil
end
@help_window.visible = true if @help_window != nil
end
#--------------------------------------------------------------------------
# ● 逃走的處理 ※再定義
#--------------------------------------------------------------------------
def process_escape
@info_viewport.visible = false
@message_window.visible = true
text = sprintf(Vocab::EscapeStart, $game_party.name)
$game_message.texts.push(text)
if $game_troop.preemptive
success = true
else
success = (rand(100) < @escape_ratio)
end
Sound.play_escape
# 不能動的主人公除外逃走成功動作
if success
for actor in $game_party.members
unless actor.restriction >= 4
@spriteset.set_action(true, actor.index,actor.run_success)
end
end
wait_for_message
battle_end(1)
# 不能動主人公除外逃走失敗動作
else
for actor in $game_party.members
unless actor.restriction >= 4
@spriteset.set_action(true, actor.index,actor.run_ng)
end
end
@escape_ratio += 10
$game_message.texts.push('\.' + Vocab::EscapeFailure)
wait_for_message
$game_party.clear_actions
start_main
end
end
#--------------------------------------------------------------------------
# ● 勝利的處理
#--------------------------------------------------------------------------
alias process_victory_n01 process_victory
def process_victory
@status_window.visible = true
@message_window.visible = false
# BOSS擊倒為等待加長
for enemy in $game_troop.members
break boss_wait = true if enemy.collapse_type == 3
end
wait(440) if boss_wait
wait(N01::WIN_WAIT) unless boss_wait
# 不能動的主人公除外勝利動作
for actor in $game_party.members
unless actor.restriction >= 4
@spriteset.set_action(true, actor.index,actor.win)
end
end
process_victory_n01
end
#--------------------------------------------------------------------------
# ● 戰鬥處理的實行開始 ※再定義
#--------------------------------------------------------------------------
def start_main
$game_troop.increase_turn
@info_viewport.visible = true
@info_viewport.ox = 0
@party_command_window.active = false
@actor_command_window.active = false
@status_window.index = @actor_index = -1
@active_battler = nil
@message_window.clear
$game_troop.make_actions
make_action_orders
# 情報表示窗口的移動
move1_info_viewport
# 作成顯示技能名的幫助窗口
@help_window = Window_Help.new
@help_window.visible = false
process_battle_event
end
#--------------------------------------------------------------------------
# ● 戰鬥事件的處理 ※再定義
#--------------------------------------------------------------------------
def process_battle_event
loop do
return if judge_win_loss
return if $game_temp.next_scene != nil
$game_troop.interpreter.update
$game_troop.setup_battle_event
@message_window.update
if $game_message.visible
@message_window.visible = true
@status_window.visible = false
end
wait_for_message
@message_window.visible = false
@status_window.visible = true
if $game_troop.forcing_battler != nil
process_action
end
return unless $game_troop.interpreter.running?
update_basic
end
end
#--------------------------------------------------------------------------
# ● 作成行動順序
#--------------------------------------------------------------------------
alias make_action_orders_n01 make_action_orders
def make_action_orders
make_action_orders_n01
# 確認敵方的行動回數
for enemy in $game_troop.members
enemy.act_time = 0
if enemy.action_time[0] != 1
action_time = 0
# 獲得確認的回數
for i in 1...enemy.action_time[0]
action_time += 1 if rand(100) < enemy.action_time[1]
end
enemy.act_time = action_time
action_time.times do
enemy_order_time(enemy)
action_time -= 1
break if action_time == 0
end
enemy.adj_speed = nil
end
end
end
#--------------------------------------------------------------------------
# ● 作成敵方的行動回數
#--------------------------------------------------------------------------
def enemy_order_time(enemy)
enemy.make_action_speed2(enemy.action_time[2])
select_time = 0
for member in @action_battlers
select_time += 1
break @action_battlers.push(enemy) if member.action.speed < enemy.adj_speed
break @action_battlers.push(enemy) if select_time == @action_battlers.size
end
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行
#--------------------------------------------------------------------------
alias execute_action_n01 execute_action
def execute_action
# 技能、物品擴張時如果設定了行動前不清空
if @active_battler.action.kind != 0
obj = @active_battler.action.skill if @active_battler.action.kind == 1
obj = @active_battler.action.item if @active_battler.action.kind == 2
if obj.extension.include?("行動前")
@active_battler.white_flash = false
end
end
# 角色主動化
@active_battler.active = true
# 強制行動中派生
@active_battler.derivation = 0 if @active_battler.action.forcing
execute_action_n01
# 有技能連發時、行動繼續
if @active_battler.derivation != 0
@active_battler.action.kind = 1
@active_battler.action.skill_id = @active_battler.derivation
@action_battlers.unshift(@active_battler)
return process_action
end
# 有複數行動的敵方時、決定下個行動
if !@active_battler.actor? && @active_battler.act_time != 0
@active_battler.make_action
@active_battler.act_time -= 1
end
end
#--------------------------------------------------------------------------
# ● 回合完畢 ※再定義
#--------------------------------------------------------------------------
def turn_end
for member in $game_party.members + $game_troop.members
member.clear_action_results
next unless member.exist?
member.slip_damage = false
actor = member.actor?
damage = 0
# 確認是否有0回合解除的狀態
for state in member.states
member.remove_state(state.id) if state.extension.include?("0回合解除")
# 實行連續傷害　state = [ 對像, 定數, 比例, POP, 戰鬥不能許可]
next unless state.extension.include?("連續傷害")
for ext in state.slip_extension
if ext[0] == "hp"
base_damage = ext[1] + member.maxhp * ext[2] / 100
damage += base_damage + base_damage * (rand(5) - rand(5)) / 100
slip_pop = ext[3]
slip_dead = ext[4]
slip_damage_flug = true
member.slip_damage = true
end
end
end
# 默認的連續傷害
if member.slip_damage? && member.exist? && !slip_damage_flug
damage += member.apply_variance(member.maxhp / 10, 10)
slip_dead = false
slip_pop = true
slip_damage_flug = true
member.slip_damage = true
end
damage = member.hp - 1 if damage >= member.hp && slip_dead = false
member.hp -= damage
@spriteset.set_damage_pop(actor, member.index, damage) if slip_pop
member.perform_collapse if member.dead? && member.slip_damage
member.clear_action_results
end
@status_window.refresh
# HP和MP的定時改變
wait(55) if slip_damage_flug
slip_damage_flug = false
for member in $game_party.members + $game_troop.members
member.clear_action_results
next unless member.exist?
actor = member.actor?
mp_damage = 0
for state in member.states
next unless state.extension.include?("連續傷害")
for ext in state.slip_extension
if ext[0] == "mp"
base_damage = ext[1] + member.maxmp * ext[2] / 100
mp_damage += base_damage + base_damage * (rand(5) - rand(5)) / 100
slip_pop = ext[2]
slip_damage_flug = true
end
end
member.mp_damage = mp_damage
member.mp -= mp_damage
@spriteset.set_damage_pop(actor, member.index, mp_damage) if slip_pop
end
member.clear_action_results
end
@status_window.refresh
# 傷害和回復的定時改變
wait(55) if slip_damage_flug
# 是否有自動回復
for member in $game_party.members
if member.auto_hp_recover and member.exist?
plus_hp = member.maxhp / 20
member.hp += plus_hp
@spriteset.set_damage_pop(true, member.index, plus_hp * -1)
plus_hp_flug = true
end
member.clear_action_results
end
@status_window.refresh
wait(55) if plus_hp_flug
@help_window.dispose if @help_window != nil
@help_window = nil
move2_info_viewport
$game_troop.turn_ending = true
$game_troop.preemptive = false
$game_troop.surprise = false
process_battle_event
$game_troop.turn_ending = false
start_party_command_selection
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行 : 攻擊 ※再定義
#--------------------------------------------------------------------------
def execute_action_attack
if @active_battler.actor?
if @active_battler.weapon_id == 0
action = @active_battler.non_weapon
# 行動中不會死的隊員全員為不死身化
immortaling
else
action = $data_weapons[@active_battler.weapon_id].base_action
# 用賦予戰鬥不能的武器來分歧不死身設定
if $data_weapons[@active_battler.weapon_id].state_set.include?(1)
for member in $game_party.members + $game_troop.members
next if member.immortal
next if member.dead?
member.dying = true
end
else
immortaling
end
end
else
if @active_battler.weapon == 0
action = @active_battler.base_action
immortaling
else
action = $data_weapons[@active_battler.weapon].base_action
if $data_weapons[@active_battler.weapon].state_set.include?(1)
for member in $game_party.members + $game_troop.members
next if member.immortal
next if member.dead?
member.dying = true
end
else
immortaling
end
end
end
target_decision
@spriteset.set_action(@active_battler.actor?, @active_battler.index, action)
playing_action
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行 : 防禦 ※再定義
#--------------------------------------------------------------------------
def execute_action_guard
@help_window.set_text("防禦", 1)
@help_window.visible = true
# 解除角色的主動化
@active_battler.active = false
wait(45)
@help_window.visible = false
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行 : 逃走
#--------------------------------------------------------------------------
def execute_action_escape
@spriteset.set_action(false, @active_battler.index, @active_battler.run_success)
@help_window.set_text("逃走", 1)
@help_window.visible = true
# 解除角色的主動化
@active_battler.active = false
@active_battler.escape
Sound.play_escape
wait(45)
@help_window.visible = false
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行 : 待機 ※再定義
#--------------------------------------------------------------------------
def execute_action_wait
# 解除角色的主動化
@active_battler.active = false
wait(45)
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行 : 技能 ※再定義
#--------------------------------------------------------------------------
def execute_action_skill
skill = @active_battler.action.skill
# 用賦予戰鬥不能的技能來分歧不死身設定
if skill.plus_state_set.include?(1)
for member in $game_party.members + $game_troop.members
next if member.immortal
next if member.dead?
member.dying = true
end
else
# 行動中不會死的隊員全員為不死身化
immortaling
end
# 判別技能使用可能
return unless @active_battler.skill_can_use?(skill)
# 決定目標
target_decision(skill)
# 動作開始
@spriteset.set_action(@active_battler.actor?, @active_battler.index, skill.base_action)
# 幫助窗口中顯示技能名
pop_help(skill)
# 動作中
playing_action
# 技能成本消費
@active_battler.consum_skill_cost(skill)
# 還原狀態窗口
@status_window.refresh
# 取得公共事件
$game_temp.common_event_id = skill.common_event_id
end
#--------------------------------------------------------------------------
# ● 戰鬥行動的實行 : 物品 ※再定義
#--------------------------------------------------------------------------
def execute_action_item
item = @active_battler.action.item
# 用賦予戰鬥不能的物品來分歧不死身設定
if item.plus_state_set.include?(1)
for member in $game_party.members + $game_troop.members
next if member.immortal
next if member.dead?
member.dying = true
end
else
# 行動中不會死的隊員全員為不死身化
immortaling
end
$game_party.consume_item(item)
target_decision(item)
@spriteset.set_action(@active_battler.actor?, @active_battler.index, item.base_action)
pop_help(item)
playing_action
$game_temp.common_event_id = item.common_event_id
end
#--------------------------------------------------------------------------
# ● 決定目標
#--------------------------------------------------------------------------
def target_decision(obj = nil)
@targets = @active_battler.action.make_targets
# 目標不存在時、動作中斷
if @targets.size == 0
action = @active_battler.recover_action
@spriteset.set_action(@active_battler.actor?, @active_battler.index, action)
end
if obj != nil
# 如果默認了設定複數回合攻擊時變換成單體目標
if obj.for_two? or obj.for_three? or obj.dual?
@targets = [@targets[0]]
end
# 隨機目標時、選擇的一體保持在隨機範圍
if obj.extension.include?("隨機目標")
randum_targets = @targets.dup
@targets = [randum_targets[rand(randum_targets.size)]]
end
end
# 目標情報發送到角色精靈
@spriteset.set_target(@active_battler.actor?, @active_battler.index, @targets)
end
#--------------------------------------------------------------------------
# ● 實行動作中
#--------------------------------------------------------------------------
def playing_action
loop do
update_basic
# 查看被歸納在主動角色的動作情報
action = @active_battler.play
next if action == 0
@active_battler.play = 0
if action[0] == "個別處理"
individual
elsif action == "擊倒許可"
unimmortaling
elsif action == "解除主動"
break action_end
elsif action == "完畢"
break action_end
elsif action[0] == "對像動畫"
damage_action(action[1])
end
end
end
#--------------------------------------------------------------------------
# ● 個別處理
#--------------------------------------------------------------------------
def individual
# 保持目標情報
@individual_target = @targets
@stand_by_target = @targets.dup
end
#--------------------------------------------------------------------------
# ● 擊倒禁止
#--------------------------------------------------------------------------
def immortaling
# 賦予全員不死身
for member in $game_party.members + $game_troop.members
# 如果不能戰鬥時跳過處理
next if member.dead?
# 有事件等設定不死身創立解除無效的標誌
member.non_dead = true if member.immortal
member.immortal = true
end
end
#--------------------------------------------------------------------------
# ● 擊倒許可
#--------------------------------------------------------------------------
def unimmortaling
# 個別處理中無擊敗許可
return if @active_battler.individual
# 解除全員的不死身化(用事件設定的不死身除外)
for member in $game_party.members + $game_troop.members
if member.dying
member.dying = false
if member.dead? or member.hp == 0
member.add_state(1)
member.perform_collapse
end
end
next if member.non_dead
next if member.dead?
member.immortal = false
member.add_state(1) if member.hp == 0
member.perform_collapse
end
# 在這個時候反映待機動作
@targets = @stand_by_target if @stand_by_target != nil
return if @targets == nil or @targets.size == 0
for target in @targets
@spriteset.set_stand_by_action(target.actor?, target.index)
# 確認自動復活
next unless target.hp == 0
resurrection(target)
end
end
#--------------------------------------------------------------------------
# ● 自動復活
#--------------------------------------------------------------------------
def resurrection(target)
for state in target.states
for ext in state.extension
name = ext.split('')
next unless name[0] == "自"
wait(50)
name = name.join
name.slice!("自動復活/")
target.hp = target.maxhp * name.to_i / 100
target.remove_state(1)
target.remove_state(state.id)
target.animation_id = N01::RESURRECTION
target.animation_mirror = true if $back_attack
@status_window.refresh
wait($data_animations[N01::RESURRECTION].frame_max * 4)
end
end
end
#--------------------------------------------------------------------------
# ● 魔法反射・無效
#--------------------------------------------------------------------------
def magic_reflection(target, obj)
return if obj.physical_attack
for state in target.states
for ext in state.extension
name = ext.split('')
next unless name[0] == "魔"
if name[2] == "反"
name = name.join
name.slice!("魔法反射/")
target.animation_id = name.to_i
target.animation_mirror = true if $back_attack
@reflection = true
else
name = name.join
name.slice!("魔法無效/")
target.animation_id = name.to_i
target.animation_mirror = true if $back_attack
@invalid = true
end
end
end
end
#--------------------------------------------------------------------------
# ● 物理反射・無效
#--------------------------------------------------------------------------
def physics_reflection(target, obj)
return if obj != nil && !obj.physical_attack
for state in target.states
for ext in state.extension
name = ext.split('')
next unless name[0] == "物"
if name[2] == "反"
name = name.join
name.slice!("物理反射/")
target.animation_id = name.to_i
target.animation_mirror = true if $back_attack
@reflection = true
else
name = name.join
name.slice!("物理無效/")
target.animation_id = name.to_i
target.animation_mirror = true if $back_attack
@invalid = true
end
end
end
end
#--------------------------------------------------------------------------
# ● 技能成本吸收
#--------------------------------------------------------------------------
def absorb_cost(target, obj)
for state in target.states
if state.extension.include?("成本吸收")
cost = @active_battler.calc_mp_cost(obj)
# 區分為SP消費和HP消費
return target.hp += cost if obj.extension.include?("HP消耗")
return target.mp += cost
end
end
end
#--------------------------------------------------------------------------
# ● 吸收處理
#--------------------------------------------------------------------------
def absorb_attack(obj, target, index, actor)
absorb = target.hp_damage
absorb = target.mp_damage if target.mp_damage != 0
# 目標是複數同時吸收處理
@wide_attack = true if obj.scope == 2 or obj.scope == 4 or obj.scope == 6 or obj.extension.include?("全區域")
if @wide_attack && @absorb == nil && @targets.size != 1
# 返還吸收的部分
@active_battler.hp -= @active_battler.hp_damage
@active_battler.mp -= @active_battler.mp_damage
# 之後加算吸收返還的數值
@absorb = absorb
@absorb_target_size = @targets.size - 2
elsif @absorb != nil && @absorb_target_size > 0
@active_battler.hp -= @active_battler.hp_damage
@active_battler.mp -= @active_battler.mp_damage
@absorb += absorb
@absorb_target_size -= 1
# 處理複數目標的最重吸收
elsif @absorb != nil
# 返還吸收的部分
@active_battler.hp -= @active_battler.hp_damage
@active_battler.mp -= @active_battler.mp_damage
@absorb += absorb
# 在這裡反映全部吸收部分
@active_battler.hp_damage = -@absorb
@active_battler.mp_damage = -@absorb if target.mp_damage != 0
@active_battler.hp -= @active_battler.hp_damage
@active_battler.mp -= @active_battler.mp_damage
# 吸收量是0時吸收者方面的處理
absorb_action = ["absorb", nil, false] if @absorb == 0
absorb_action = [nil, nil, false] if @absorb != 0
@spriteset.set_damage_action(actor, index, absorb_action)
@active_battler.perform_collapse
@absorb = nil
@absorb_target_size = nil
# 單體吸收的處理
else
# 吸收量是0時吸收者方面的處理
absorb_action = ["absorb", nil, false] if absorb == 0
absorb_action = [nil, nil, false] if absorb != 0
@spriteset.set_damage_action(actor, index, absorb_action)
# 逆向吸收時HP為0時
@absorb_dead = true if @active_battler.hp == 0 && !@active_battler.non_dead
end
# 吸收量是0時對像者方面的處理
return 0 if absorb == 0
end
#--------------------------------------------------------------------------
# ● 動作完畢
#--------------------------------------------------------------------------
def action_end
# 初期化
@individual_target = nil
@help_window.visible = false if @help_window != nil && @help_window.visible
@active_battler.active = false
@active_battler.clear_action_results
# 慎重起見解除不死身化
unimmortaling
# 被反射時
if @active_battler.reflex != nil
if @active_battler.action.skill?
obj = @active_battler.action.skill
@active_battler.perfect_skill_effect(@active_battler, obj)
elsif @active_battler.action.item?
obj = @active_battler.action.item
@active_battler.item_effect(@active_battler, obj)
else
@active_battler.perfect_attack_effect(@active_battler)
end
pop_damage(@active_battler, obj, @active_battler.reflex)
@active_battler.perform_collapse
@active_battler.reflex = nil
wait(N01::COLLAPSE_WAIT)
end
#因逆向吸收戰鬥不能時
if @absorb_dead
@active_battler.perform_collapse
@absorb_dead = false
wait(N01::COLLAPSE_WAIT)
end
# 縮短到下次行動前的等待
wait(N01::ACTION_WAIT)
end
#--------------------------------------------------------------------------
# ● 傷害處理
#--------------------------------------------------------------------------
def damage_action(action)
# 單獨處理時目標一個一個發出
@targets = [@individual_target.shift] if @active_battler.individual
# 技能時
if @active_battler.action.skill?
obj = @active_battler.action.skill
for target in @targets
return if target == nil
return if target.dead? && !obj.for_dead_friend?
# HP為0時戰鬥不能復活以外不MISS
target.revival = true if obj.for_dead_friend?
if target.hp == 0 && !obj.for_dead_friend?
target.perfect_skill_effect(@active_battler, obj)
# 確認必中
elsif obj.extension.include?("必中")
target.perfect_skill_effect(@active_battler, obj)
else
# 確認反射
magic_reflection(target, obj) unless obj.extension.include?("無視反射")
physics_reflection(target, obj) unless obj.extension.include?("無視反射")
# 計算傷害
target.skill_effect(@active_battler, obj) unless @reflection or @invalid
end
pop_damage(target, obj, action) unless @reflection or @invalid
# 確認成本吸收
absorb_cost(target, obj)
# 獲取反射動作
@active_battler.reflex = action if @reflection
@reflection = false
@invalid = false
end
# 物品時
elsif @active_battler.action.item?
obj = @active_battler.action.item
for target in @targets
return if target == nil
return if target.dead? && !obj.for_dead_friend?
target.revival = true if obj.for_dead_friend?
if target.hp == 0 && !obj.for_dead_friend?
target.perfect_item_effect(@active_battler, obj)
elsif obj.extension.include?("必中")
target.perfect_item_effect(@active_battler, obj)
else
magic_reflection(target, obj) unless obj.extension.include?("無視反射")
physics_reflection(target, obj) unless obj.extension.include?("無視反射")
target.item_effect(@active_battler, obj) unless @reflection or @invalid
end
pop_damage(target, obj, action) unless @reflection or @invalid
@active_battler.reflex = action if @reflection
@reflection = false
@invalid = false
end
# 通常攻擊時
else
for target in @targets
return if target == nil or target.dead?
physics_reflection(target, nil)
target.perfect_attack_effect(@active_battler) if target.hp <= 0
target.attack_effect(@active_battler) unless target.hp <= 0 or @reflection or @invalid
pop_damage(target, nil, action) unless @reflection or @invalid
# 獲取反射動作
@active_battler.reflex = action if @reflection
@reflection = false
@invalid = false
end
end
# 還原狀態窗口
@status_window.refresh
# 考慮連續性懂得隨機目標、立刻選擇下個目標
return if obj == nil
target_decision(obj) if obj.extension.include?("隨機目標")
end
#--------------------------------------------------------------------------
# ● 傷害表示 action = [動畫ID,反轉標誌,動作許可]
#--------------------------------------------------------------------------
def pop_damage(target, obj, action)
index = @active_battler.index
actor = @active_battler.actor?
if obj != nil
# 技能或者物品是吸收屬性時
absorb = absorb_attack(obj, target, index, actor) if obj.absorb_damage
action.push(true) if absorb == 0
# 擴張設定為傷害動作禁止時
action[2] = false if obj.extension.include?("禁止傷害動作")
end
# 還原對像
@spriteset.set_damage_action(target.actor?, target.index, action)
end
end
#==============================================================================
# ■ Game_BattleAction
#------------------------------------------------------------------------------
# 　戰鬥行動處理的類。
#==============================================================================
class Game_BattleAction
#--------------------------------------------------------------------------
# ● 判定行動是否有效 ※再定義
#--------------------------------------------------------------------------
def valid?
return false if nothing? # 什麼都不作
return true if @forcing # 強制行動中
return false unless battler.movable? # 行動不能
if skill? # 技能
if battler.derivation != 0
battler.derivation = 0
return true
end
return false unless battler.skill_can_use?(skill)
elsif item? # 物品
return false unless friends_unit.item_can_use?(item)
end
return true
end
#--------------------------------------------------------------------------
# ● 作成目標的排列 ※再定義
#--------------------------------------------------------------------------
def make_targets
if attack?
return make_attack_targets
elsif skill?
targets = make_obj_targets(skill)
targets = make_obj_targets2(skill, targets) if skill.extension != [""]
return targets
elsif item?
targets = make_obj_targets(item)
targets = make_obj_targets2(item, targets) if item.extension != [""]
return targets
end
end
#--------------------------------------------------------------------------
# ● 作成技能或是物品的目標的擴張
#--------------------------------------------------------------------------
def make_obj_targets2(obj, targets)
if obj.extension.include?("全區域")
targets = []
targets += opponents_unit.existing_members
targets += friends_unit.existing_members
end
if obj.extension.include?("自分以外")
targets.delete($game_party.members[battler.index]) if battler.actor?
targets.delete($game_troop.members[battler.index]) unless battler.actor?
end
return targets.compact
end
end
#==============================================================================
# ■ Sprite_Base
#------------------------------------------------------------------------------
# 　追加了動畫的表示處理的精靈的類。
#==============================================================================
class Sprite_Base < Sprite
#--------------------------------------------------------------------------
# ● 動畫的更新動畫追隨精靈
#--------------------------------------------------------------------------
alias update_animation_n01 update_animation
def update_animation
@animation_ox = x - ox + width / 2
@animation_oy = y - oy + height / 2
update_animation_n01
end
end
#==============================================================================
# ■ Spriteset_Battle
#------------------------------------------------------------------------------
# 　整理戰鬥畫面的精靈的類。
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# ● 敵方精靈的作成
#--------------------------------------------------------------------------
def create_enemies
@enemy_sprites = []
for i in 0...$game_troop.members.size
@enemy_sprites.push(Sprite_Battler.new(@viewport1, $game_troop.members[i]))
@enemy_sprites[i].opacity = 0 if $game_troop.members[i].hidden
end
end
#--------------------------------------------------------------------------
# ● 主人公精靈的作成
#--------------------------------------------------------------------------
def create_actors
@actor_sprites = []
# 準備成員最大數精靈
for i in 0...N01::MAX_MEMBER
@actor_sprites.push(Sprite_Battler.new(@viewport1, $game_party.members[i]))
if $game_party.members[i] != nil
@actor_sprites[i].make_battler
@actor_sprites[i].first_action
end
end
end
#--------------------------------------------------------------------------
# ● 戰鬥層精靈的作成
#--------------------------------------------------------------------------
def create_battlefloor
@battlefloor_sprite = Sprite.new(@viewport1)
@battlefloor_sprite.bitmap = Cache.system("BattleFloor")
@battlefloor_sprite.x = N01::FLOOR[0]
@battlefloor_sprite.y = N01::FLOOR[1]
@battlefloor_sprite.opacity = N01::FLOOR[2]
@battlefloor_sprite.z = 1
# 偷襲時時、反轉層面和背景
back_attack
if $back_attack
@battlefloor_sprite.mirror = true
@battleback_sprite.mirror = true
$game_troop.surprise = true
else
$game_troop.surprise = false
end
end
#--------------------------------------------------------------------------
# ● 背部攻擊
#--------------------------------------------------------------------------
def back_attack
# 強制背部攻擊時標誌ON
for i in 0...N01::BACK_ATTACK_SWITCH.size
return $back_attack = true if $game_switches[N01::BACK_ATTACK_SWITCH[i]]
end
# 如果沒發生偷襲時將中斷處理
return $back_attack = false unless $game_troop.surprise && N01::BACK_ATTACK
# 確認根據裝備等背部攻擊的無效化
for actor in $game_party.members
return $back_attack = false if N01::NON_BACK_ATTACK_WEAPONS.include?(actor.weapon_id)
return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR1.include?(actor.armor1_id)
return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR2.include?(actor.armor2_id)
return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR3.include?(actor.armor3_id)
return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR4.include?(actor.armor4_id)
for i in 0...N01::NON_BACK_ATTACK_SKILLS.size
return $back_attack = false if actor.skill_id_learn?(N01::NON_BACK_ATTACK_SKILLS[i])
end
end
# 發生背部攻擊
$back_attack = true
end
#--------------------------------------------------------------------------
# ● 主人公精靈的更新 ※再定義
#--------------------------------------------------------------------------
def update_actors
for i in 0...@actor_sprites.size
if $party_change
$party_change = false
dispose_actors
return create_actors
end
if @actor_sprites[i].battler.id != $game_party.members[i].id
dispose_actors
return create_actors
end
@actor_sprites[i].update
end
end
#--------------------------------------------------------------------------
# ● 傷害動作組合　
#--------------------------------------------------------------------------
def set_damage_action(actor, index, action)
@actor_sprites[index].damage_action(action) if actor
@enemy_sprites[index].damage_action(action) unless actor
end
#--------------------------------------------------------------------------
# ● 傷害POP組合　
#--------------------------------------------------------------------------
def set_damage_pop(actor, index, damage)
@actor_sprites[index].damage_pop(damage) if actor
@enemy_sprites[index].damage_pop(damage) unless actor
end
#--------------------------------------------------------------------------
# ● 目標組合
#--------------------------------------------------------------------------
def set_target(actor, index, target)
@actor_sprites[index].get_target(target) if actor
@enemy_sprites[index].get_target(target) unless actor
end
#--------------------------------------------------------------------------
# ● 動作組合
#--------------------------------------------------------------------------
def set_action(actor, index, kind)
@actor_sprites[index].start_action(kind) if actor
@enemy_sprites[index].start_action(kind) unless actor
end
#--------------------------------------------------------------------------
# ● 待機動作組合
#--------------------------------------------------------------------------
def set_stand_by_action(actor, index)
@actor_sprites[index].push_stand_by if actor
@enemy_sprites[index].push_stand_by unless actor
end
#--------------------------------------------------------------------------
# ● 光標移動的組合
#--------------------------------------------------------------------------
def set_cursor(actor, index)
return [@actor_sprites[index].x, @actor_sprites[index].y] if actor
return [@enemy_sprites[index].x, @enemy_sprites[index].y] unless actor
end
end
#==============================================================================
# ■ Sprite_MoveAnime
#------------------------------------------------------------------------------
# 　動畫飛出用的精靈。
#==============================================================================
class Sprite_MoveAnime < Sprite_Base
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :battler
attr_accessor :base_x # 自身基本X座標
attr_accessor :base_y # 自身基本Y座標
#--------------------------------------------------------------------------
# ● 客觀初期化
#--------------------------------------------------------------------------
def initialize(viewport,battler = nil)
super(viewport)
@battler = battler
self.visible = false
@base_x = 0
@base_y = 0
@move_x = 0 # 移動後的X坐標
@move_y = 0 # 移動後Y坐標
@moving_x = 0 # 1單位相當移動的X坐標
@moving_y = 0 # 1單位相當移動的Y坐標
@orbit = 0 # 圓軌道
@orbit_plus = 0 # 加算的圓軌道
@orbit_time = 0 # 圓軌道計算時間
@through = false # 是否貫通
@finish = false # 移動完畢的標誌
@time = 0 # 移動時間
@angle = 0 # 一動時間
@angling = 0 # 1單位相當移動的武器的角度
end
#--------------------------------------------------------------------------
# ● 獲取動作
#--------------------------------------------------------------------------
def anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,icon_index,icon_weapon)
# 算出1單位相當的移動距離
@time = speed
@moving_x = distanse_x / speed
@moving_y = distanse_y / speed
# 是否貫通
@through = true if type == 1
# 獲取圓軌道
@orbit_plus = orbit
@orbit_time = @time
# 有無武器圖片
if weapon != ""
action = N01::ANIME[weapon].dup
@angle = action[0]
end_angle = action[1]
time = action[2]
# 調出1單位相當的旋轉角度
@angling = (end_angle - @angle)/ time
# 取得開始角度
self.angle = @angle
# 顯示武器圖片
self.mirror = mirror
if icon_weapon
self.bitmap = Cache.system("Iconset")
self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
self.ox = 12
self.oy = 12
else
self.bitmap = Cache.character(icon_index)
self.ox = self.bitmap.width / 2
self.oy = self.bitmap.height / 2
end
self.visible = true
# 顯示在角色面前
self.z = 1000
end
# 最初不動只顯示一次
self.x = @base_x + @move_x
self.y = @base_y + @move_y + @orbit
if id != 0
animation = $data_animations[id]
start_animation(animation, mirror)
end
end
#--------------------------------------------------------------------------
# ● 變化了的移動組合
#--------------------------------------------------------------------------
def action_reset
@moving_x = @moving_y = @move_x = @move_y = @base_x = @base_y = @orbit = 0
@orbit_time = @angling = @angle = 0
@through = self.visible = @finish = false
dispose_animation
end
#--------------------------------------------------------------------------
# ● 貫通完畢
#--------------------------------------------------------------------------
def finish?
return @finish
end
#--------------------------------------------------------------------------
# ● 單位更新
#--------------------------------------------------------------------------
def update
super
# 時間消耗
@time -= 1
# 時間內指定的移動
if @time >= 0
@move_x += @moving_x
@move_y += @moving_y
# 計算圓軌道
if @time < @orbit_time / 2
@orbit_plus = @orbit_plus * 5 / 4
elsif @time == @orbit_time / 2
@orbit_plus *= -1
else
@orbit_plus = @orbit_plus * 2 / 3
end
@orbit += @orbit_plus
end
# 就算時間完畢如果是貫穿的話也會繼續直進
@time = 100 if @time < 0 && @through
@finish = true if @time < 0 && !@through
# 更新精靈的坐標
self.x = @base_x + @move_x
self.y = @base_y + @move_y + @orbit
# 貫穿時、從畫面消失的完畢標誌ON
if self.x < -200 or self.x > 840 or self.y < -200 or self.y > 680
@finish = true
end
# 更新武器圖片
if self.visible
@angle += @angling
self.angle = @angle
end
end
end
#==============================================================================
# ■ Sprite_Weapon
#------------------------------------------------------------------------------
# 　顯示武器用的精靈。
#==============================================================================
class Sprite_Weapon < Sprite_Base
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :battler
#--------------------------------------------------------------------------
# ● 客觀初始化
#--------------------------------------------------------------------------
def initialize(viewport,battler = nil)
super(viewport)
@battler = battler
@action = [] # 武器的動作情報
@move_x = 0 # 移動後的X坐標
@move_y = 0 # 移動後的Y坐標
@move_z = 0 # 移動後的Z坐標
@plus_x = 0 # 略微調整X坐標
@plus_y = 0 # 略微調整Y坐標
@angle = 0 # 武器的旋轉角度
@zoom_x = 1 # 武器的橫向放大率
@zoom_y = 1 # 武器的縱向放大率
@moving_x = 0 # 1單位相當移動的X坐標
@moving_y = 0 # 1單位相當移動的Y坐標
@angling = 0 # 1單位相當的旋轉角度
@zooming_x = 1 # 1單位相當的橫向放大率
@zooming_y = 1 # 1單位相當的縱向放大率
@freeze = -1 # 固定動畫用的武器位置
@mirroring = false # 角色是否為反轉
@time = N01::ANIME_PATTERN + 1 # 更新回數
# 獲取武器
weapon_graphics
end
#--------------------------------------------------------------------------
# ● 解放
#--------------------------------------------------------------------------
def dispose
self.bitmap.dispose if self.bitmap != nil
super
end
#--------------------------------------------------------------------------
# ● 獲取武器
#--------------------------------------------------------------------------
def weapon_graphics(left = false)
if @battler.actor?
weapon = @battler.weapons[0] unless left
weapon = @battler.weapons[1] if left
else
weapon = $data_weapons[@battler.weapon]
end
# 確認敵方的反轉標誌
return if weapon == nil
# 如果沒有武器時處理被取消
if weapon.graphic == ""
icon_index = weapon.icon_index
self.bitmap = Cache.system("Iconset")
self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
@weapon_width = @weapon_height = 24
# 如果有指定ID時、獲取不是ICON的圖片
else
self.bitmap = Cache.character(weapon.graphic)
@weapon_width = self.bitmap.width
@weapon_height = self.bitmap.height
end
end
#--------------------------------------------------------------------------
# ● 獲取動畫固定時的武器位置
#--------------------------------------------------------------------------
def freeze(action)
@freeze = action
end
#--------------------------------------------------------------------------
# ● 獲取武器動作 freeze
#--------------------------------------------------------------------------
def weapon_action(action,loop)
# 沒有名稱時不顯示
if action == ""
self.visible = false
# 空手時不顯示
elsif @weapon_id == 0
self.visible = false
# 受取武器的動作情報
else
@action = N01::ANIME[action]
act0 = @action[0]
act1 = @action[1]
act2 = @action[2]
act3 = @action[3]
act4 = @action[4]
act5 = @action[5]
act6 = @action[6]
act7 = @action[7]
act8 = @action[8]
act9 = @action[9]
act10 = @action[10]
# 角色為反轉時、X軸的動作也逆轉
if @mirroring
act0 *= -1
act3 *= -1
act4 *= -1
act9 *= -1
end
# 背部攻擊時逆轉
time = N01::ANIME_PATTERN
# 確認Z坐標
if act2
self.z = @battler.position_z + 1
else
self.z = @battler.position_z - 1
end
# 在這裡實行反轉、如果已經反轉就還原
if act6
if self.mirror
self.mirror = false
else
self.mirror = true
end
end
# 反映角色的反轉
if @mirroring
if self.mirror
self.mirror = false
else
self.mirror = true
end
end
# 計算以動畫圖片數相除的變化
@moving_x = act0 / time
@moving_y = act1 / time
# 代入最初的角度
@angle = act3
self.angle = @angle
# 計算更新角度
@angling = (act4 - act3)/ time
# 角度沒有被插入時、在這裡加算剩餘旋轉的部分
@angle += (act4 - act3) % time
# 擴大縮小
@zooming_x = (1 - act7) / time
@zooming_y = (1 - act8) / time
# 如果是反轉時、逆轉反轉前的原點
if self.mirror
case act5
when 1 # 左上→到右上
act5 = 2
when 2 # 右上→到左上
act5 = 1
when 3 # 左下→到右下
act5 = 4
when 4 # 右下→到左下
act5 = 3
end
end
# 設定旋轉前的原點
case act5
when 0 # 中心
self.ox = @weapon_width / 2
self.oy = @weapon_height / 2
when 1 # 左上
self.ox = 0
self.oy = 0
when 2 # 右上
self.ox = @weapon_width
self.oy = 0
when 3 # 左下
self.ox = 0
self.oy = @weapon_height
when 4 # 右下
self.ox = @weapon_width
self.oy = @weapon_height
end
# 略微調整坐標
@plus_x = act9
@plus_y = act10
# 往返循環時標誌ON
@loop = true if loop == 0
# 第一次時0開始、在這時作－1回的動作
@angle -= @angling
@zoom_x -= @zooming_x
@zoom_y -= @zooming_y
# 更新精靈的坐標
@move_x -= @moving_x
@move_y -= @moving_y
@move_z = 1000 if act2
# 固定動畫時、在這時消化動作
if @freeze != -1
for i in 0..@freeze + 1
@angle += @angling
@zoom_x += @zooming_x
@zoom_y += @zooming_y
# 更新精靈的坐標
@move_x += @moving_x
@move_y += @moving_y
end
@angling = 0
@zooming_x = 0
@zooming_y = 0
@moving_x = 0
@moving_y = 0
end
# 可視
self.visible = true
end
end
#--------------------------------------------------------------------------
# ● 變化後的動作全部組合
#--------------------------------------------------------------------------
def action_reset
@moving_x = @moving_y = @move_x = @move_y = @plus_x = @plus_y = 0
@angling = @zooming_x = @zooming_y = @angle = self.angle = @move_z = 0
@zoom_x = @zoom_y = self.zoom_x = self.zoom_y = 1
self.mirror = self.visible = @loop = false
@freeze = -1
@action = []
@time = N01::ANIME_PATTERN + 1
end
#--------------------------------------------------------------------------
# ● 作出往返循環
#--------------------------------------------------------------------------
def action_loop
# 讓動作相反
@angling *= -1
@zooming_x *= -1
@zooming_y *= -1
@moving_x *= -1
@moving_y *= -1
end
#--------------------------------------------------------------------------
# ● 主人公是反轉時、自身也反轉
#--------------------------------------------------------------------------
def mirroring
return @mirroring = false if @mirroring
@mirroring = true
end
#--------------------------------------------------------------------------
# ● 只有在主人公動畫被更新時武器動作的變化也更新
#--------------------------------------------------------------------------
def action
return if @time <= 0
@time -= 1
# 旋轉、更新放大縮小
@angle += @angling
@zoom_x += @zooming_x
@zoom_y += @zooming_y
# 更新精靈的坐標
@move_x += @moving_x
@move_y += @moving_y
# 往返循環時動作反轉
if @loop && @time == 0
@time = N01::ANIME_PATTERN + 1
action_loop
end
end
#--------------------------------------------------------------------------
# ● 單位更新
#--------------------------------------------------------------------------
def update
super
# 旋轉、更新放大縮小
self.angle = @angle
self.zoom_x = @zoom_x
self.zoom_y = @zoom_y
# 更新精靈的坐標
self.x = @battler.position_x + @move_x + @plus_x
self.y = @battler.position_y + @move_y + @plus_y
self.z = @battler.position_z + @move_z - 1
end
end
#==============================================================================
# ■ Game_Battler (分割定義 1)
#------------------------------------------------------------------------------
# 　處理角色的類。
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :hp_damage # 行動結果: HP 傷害
attr_accessor :mp_damage # 行動結果: MP 傷害
attr_accessor :move_x # X方向的移動修正
attr_accessor :move_y # Y方向的移動修正
attr_accessor :move_z # Z方向的移動修正
attr_accessor :jump # 修正跳躍
attr_accessor :active # 是否主動
attr_accessor :non_dead # 不死身標誌
attr_accessor :dying # 即死標誌
attr_accessor :slip_damage # 連續傷害標誌
attr_accessor :derivation # 技能連發ID
attr_accessor :individual # 技能連發ID
attr_accessor :play # 動作情報
attr_accessor :force_action # 強制動作情報
attr_accessor :force_target # 目標變更情報
attr_accessor :revival # 復活
attr_accessor :double_damage # HPMP兩方同時傷害
attr_accessor :reflex # 技能反射情報
attr_accessor :absorb # 技能成本吸收
attr_reader :base_position_x # 初期配置X坐標
attr_reader :base_position_y # 初期配置Y座標
attr_accessor :force_damage # 事件的傷害
#--------------------------------------------------------------------------
# ● 客觀初期化
#--------------------------------------------------------------------------
alias initialize_n01 initialize
def initialize
initialize_n01
@move_x = @move_y = @move_z = @plus_y = @jump = @derivation = @play = 0
@force_action = @force_target = @base_position_x = @base_position_y = 0
@absorb = @act_time = @force_damage = 0
@active = @non_dead = @individual = @slip_damage = @revival = false
@double_damage = @dying = false
end
#--------------------------------------------------------------------------
# ● 返還最新的狀態ID
#--------------------------------------------------------------------------
def state_id
return @states[@states.size - 1]
end
#--------------------------------------------------------------------------
# ● 判定技能的使用可能 ※再定義
#--------------------------------------------------------------------------
def skill_can_use?(skill)
return false unless skill.is_a?(RPG::Skill)
return false unless movable?
return false if silent? and skill.spi_f > 0
if skill.extension.include?("HP消耗")
return false if calc_mp_cost(skill) > hp
else
return false if calc_mp_cost(skill) > mp
end
if $game_temp.in_battle
return skill.battle_ok?
else
return skill.menu_ok?
end
end
#--------------------------------------------------------------------------
# ● 技能的消費 MP 計算 ※再定義
#--------------------------------------------------------------------------
def calc_mp_cost(skill)
if half_mp_cost && !skill.extension.include?("MP消耗減半無效")
cost = skill.mp_cost / 2
else
cost = skill.mp_cost
end
if skill.extension.include?("%成本MAX")
return self.maxhp * cost / 100 if skill.extension.include?("HP消耗")
return self.maxmp * cost / 100
elsif skill.extension.include?("%成本NOW")
return self.hp * cost / 100 if skill.extension.include?("HP消耗")
return self.mp * cost / 100
end
return cost
end
#--------------------------------------------------------------------------
# ● 技能成本消費
#--------------------------------------------------------------------------
def consum_skill_cost(skill)
return false unless skill_can_use?(skill)
cost = calc_mp_cost(skill)
return self.hp -= cost if skill.extension.include?("HP消耗")
return self.mp -= cost
end
#--------------------------------------------------------------------------
# ● 根據通常攻擊計算傷害修正二刀流
#--------------------------------------------------------------------------
alias make_attack_damage_value_n01 make_attack_damage_value
def make_attack_damage_value(attacker)
make_attack_damage_value_n01(attacker)
# 只有在裝備了兩把武器時修正有效
return unless attacker.actor?
return if attacker.weapons[0] == nil
return if attacker.weapons[1] == nil
@hp_damage = @hp_damage * N01::TWO_SWORDS_STYLE[0] / 100
end
#--------------------------------------------------------------------------
# ● 根據技能或者物品來計算傷害　修正二刀流
#--------------------------------------------------------------------------
alias make_obj_damage_value_n01 make_obj_damage_value
def make_obj_damage_value(user, obj)
make_obj_damage_value_n01(user, obj)
# 只有在裝備了兩把武器時修正有效
return unless user.actor?
return if user.weapons[0] == nil
return if user.weapons[1] == nil
if obj.damage_to_mp
@mp_damage = @mp_damage * N01::TWO_SWORDS_STYLE[1] / 100 # 傷害MP
else
@hp_damage = @hp_damage * N01::TWO_SWORDS_STYLE[1] / 100 # 傷害HP
end
end
#--------------------------------------------------------------------------
# ● 使用通常攻擊的效果全部戰鬥不能，不能絕對迴避的處理
#--------------------------------------------------------------------------
def perfect_attack_effect(attacker)
clear_action_results
make_attack_damage_value(attacker) # 計算傷害
execute_damage(attacker) # 反映傷害
apply_state_changes(attacker) # 狀態變化
end
#--------------------------------------------------------------------------
# ● 使用技能的效果全部戰鬥不能，不能絕對迴避的處理
#--------------------------------------------------------------------------
def perfect_skill_effect(user, skill)
clear_action_results
make_obj_damage_value(user, skill) # 傷害計算
make_obj_absorb_effect(user, skill) # 吸收效果計算
execute_damage(user) # 傷害反映
apply_state_changes(skill) # 狀態變化
end
#--------------------------------------------------------------------------
# ● 使用物品的效果全部戰鬥不能，不能絕對迴避的處理
#--------------------------------------------------------------------------
def perfect_item_effect(user, item)
clear_action_results
hp_recovery = calc_hp_recovery(user, item) # 計算HP的回復量
mp_recovery = calc_mp_recovery(user, item) # 計算MP的回復量
make_obj_damage_value(user, item) # 計算傷害
@hp_damage -= hp_recovery # 扣除HP的回復量
@mp_damage -= mp_recovery # 扣除MP的回復量
make_obj_absorb_effect(user, item) # 計算吸收效果
execute_damage(user) # 反映傷害
item_growth_effect(user, item) # 使用成長效果
if item.physical_attack and @hp_damage == 0 # 物理判定
return
end
apply_state_changes(item) # 狀態變化
end
#--------------------------------------------------------------------------
# ● 傷害的反映
#--------------------------------------------------------------------------
alias execute_damage_n01 execute_damage
def execute_damage(user)
execute_damage_n01(user)
# 吸收時這裡的處理相沖
if @absorbed
user.hp_damage = -@hp_damage
user.mp_damage = -@mp_damage
end
end
#--------------------------------------------------------------------------
# ● 使用技能的效果
#--------------------------------------------------------------------------
alias skill_effect_n01 skill_effect
def skill_effect(user, obj)
# 保持變化前的HPMP
nowhp = self.hp
nowmp = self.mp
# 為了計算現在HPMP的威力獲取變化前的使用者的HPMP
if obj.extension.include?("HP消耗")
user_hp = user.hp + user.calc_mp_cost(obj)
user_mp = user.mp
else
user_hp = user.hp
user_mp = user.mp + user.calc_mp_cost(obj)
end
# 確認擴張設定
check_extension(obj)
# 計算傷害
skill_effect_n01(user, obj)
# 有傷害系的擴張時這裡的處理會相沖
if @extension
self.hp = nowhp
self.mp = nowmp
end
# 攻擊未名中時中斷處理
return if self.evaded or self.missed
# 變換傷害屬性
damage = @hp_damage unless obj.damage_to_mp
damage = @mp_damage if obj.damage_to_mp
# 比例傷害
if @ratio_maxdamage != nil
damage = self.maxhp * @ratio_maxdamage / 100 unless obj.damage_to_mp
damage = self.maxmp * @ratio_maxdamage / 100 if obj.damage_to_mp
end
if @ratio_nowdamage != nil
damage = self.hp * @ratio_nowdamage / 100 unless obj.damage_to_mp
damage = self.mp * @ratio_nowdamage / 100 if obj.damage_to_mp
end
# 成本威力
if @cost_damage
cost = user.calc_mp_cost(obj)
if obj.extension.include?("HP消耗")
damage = damage * cost / user.maxhp
else
damage = damage * cost / user.maxmp
end
end
# 現在HP威力
damage = damage * user_hp / user.maxhp if @nowhp_damage
# 現在MP威力
damage = damage * user_mp / user.maxmp if @nowmp_damage
# 放棄傷害屬性的變換
@hp_damage = damage unless obj.damage_to_mp
@mp_damage = damage if obj.damage_to_mp
# 反應擴張
if @extension
self.hp -= @hp_damage
self.mp -= @mp_damage
end
# 初期化
@extension = false
@cost_damage = false
@nowhp_damage = false
@nowmp_damage = false
@ratio_maxdamage = nil
@ratio_nowdamage = nil
end
#--------------------------------------------------------------------------
# ● 確認擴張設定
#--------------------------------------------------------------------------
def check_extension(skill)
for ext in skill.extension
# 成本威力
if ext == "成本威力"
@extension = true
next @cost_damage = true
# 現在HP威力
elsif ext == "現HP威力"
@extension = true
next @nowhp_damage = true
# 現在MP威力
elsif ext == "現MP威力"
@extension = true
next @nowmp_damage = true
else
# 比例傷害
name = ext.split('')
if name[5] == "M"
name = name.join
name.slice!("%傷害MAX/")
@extension = true
next @ratio_maxdamage = name.to_i
elsif name[5] == "N"
name = name.join
name.slice!("%傷害NOW/")
@extension = true
next @ratio_nowdamage = name.to_i
end
end
end
end
#--------------------------------------------------------------------------
# ● 初期配置的變更
#--------------------------------------------------------------------------
def change_base_position(x, y)
@base_position_x = x
@base_position_y = y
end
#--------------------------------------------------------------------------
# ● 初期化
#--------------------------------------------------------------------------
def reset_coordinate
@move_x = @move_y = @move_z = @jump = @derivation = 0
@active = @non_dead = @individual = false
end
#--------------------------------------------------------------------------
# ● 使用連續傷害的效果
#--------------------------------------------------------------------------
def slip_damage_effect
if slip_damage? and @hp > 0
@hp_damage = apply_variance(maxhp / 10, 10)
@hp_damage = @hp - 1 if @hp_damage >= @hp
self.hp -= @hp_damage
end
end
#--------------------------------------------------------------------------
# ● 事件的傷害POP
#--------------------------------------------------------------------------
def damage_num(num = nil)
return if dead? or !$game_temp.in_battle or num == 0
@force_damage = num
end
end
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　處理主人公的類。
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :two_swords_change # 強制替換二刀流的標誌
#--------------------------------------------------------------------------
# ● 根據ID判定技能是否習得
#--------------------------------------------------------------------------
def skill_id_learn?(skill_id)
return @skills.include?(skill_id)
end
#--------------------------------------------------------------------------
# ● 判定技能的使用可能 ※再定義
#--------------------------------------------------------------------------
def skill_can_use?(skill)
return super
end
#--------------------------------------------------------------------------
# ● 圖片的變更
#--------------------------------------------------------------------------
def graphic_change(character_name)
@character_name = character_name
end
#--------------------------------------------------------------------------
# ● 擊倒的實行 ※再定義
#--------------------------------------------------------------------------
def perform_collapse
Sound.play_actor_collapse if $game_temp.in_battle and dead?
end
#--------------------------------------------------------------------------
# ● 初期配置的取得
#--------------------------------------------------------------------------
def base_position
base = N01::ACTOR_POSITION[self.index]
@base_position_x = base[0]
@base_position_y = base[1]
# 時X軸逆
@base_position_x = Graphics.width - base[0] if $back_attack && N01::BACK_ATTACK
end
#--------------------------------------------------------------------------
# ● 戰鬥畫面 X 坐標的取得
#--------------------------------------------------------------------------
def position_x
return 0 if self.index == nil
return @base_position_x + @move_x
end
#--------------------------------------------------------------------------
# ● 戰鬥畫面 Y 坐標的取得
#--------------------------------------------------------------------------
def position_y
return 0 if self.index == nil
return @base_position_y + @move_y + @jump
end
#--------------------------------------------------------------------------
# ● 戰鬥畫面 Z 坐標的取得
#--------------------------------------------------------------------------
def position_z
return 0 if self.index == nil
return self.index + @base_position_y + @move_y + @move_z - @jump + 200
end
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　處理敵方的類。
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :adj_speed # 複數會合行動的速度修正
attr_accessor :act_time # 行動數回
#--------------------------------------------------------------------------
# ● 動作速度的決定複數回合行動用
#--------------------------------------------------------------------------
def make_action_speed2(adj)
@adj_speed = self.action.speed if @adj_speed == nil
@adj_speed = @adj_speed * adj / 100
end
#--------------------------------------------------------------------------
# ● 擊倒的實行 ※再定義
#--------------------------------------------------------------------------
def perform_collapse
@force_action = ["N01collapse"] if $game_temp.in_battle and dead?
end
#--------------------------------------------------------------------------
# ● 獲取初期配置
#--------------------------------------------------------------------------
def base_position
return if self.index == nil
# 確認角色畫像的大小修正Y坐標
bitmap = Bitmap.new("Graphics/Battlers/" + @battler_name) if !self.anime_on
bitmap = Bitmap.new("Graphics/Characters/" + @battler_name) if self.anime_on && N01::WALK_ANIME
bitmap = Bitmap.new("Graphics/Characters/" + @battler_name + "_1") if self.anime_on && !N01::WALK_ANIME
height = bitmap.height
@base_position_x = self.screen_x + self.position_plus[0]
@base_position_y = self.screen_y + self.position_plus[1] - height / 3
bitmap.dispose
# 背後攻擊時X軸逆轉
if $back_attack && N01::BACK_ATTACK
@base_position_x = Graphics.width - self.screen_x - self.position_plus[0]
end
end
#--------------------------------------------------------------------------
# ● 戰鬥畫面 X 坐標的取得
#--------------------------------------------------------------------------
def position_x
return @base_position_x - @move_x
end
#--------------------------------------------------------------------------
# ● 戰鬥畫面 Y 坐標的取得
#--------------------------------------------------------------------------
def position_y
return @base_position_y + @move_y + @jump
end
#--------------------------------------------------------------------------
# ● 戰鬥畫面 Z 坐標的取得
#--------------------------------------------------------------------------
def position_z
return position_y + @move_z - @jump + 200
end
end
#==============================================================================
# ■ Sprite_Damage
#------------------------------------------------------------------------------
# 　傷害表示的精靈。
#==============================================================================
class Sprite_Damage < Sprite_Base
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :battler
#--------------------------------------------------------------------------
# ● 客觀初期化
#--------------------------------------------------------------------------
def initialize(viewport,battler = nil)
super(viewport)
@battler = battler
@damage = 0
@duration = 0
@x = 0
@y = 0
@z_plus = 0
@minus = false
@num1 = Sprite.new(viewport)
@num2 = Sprite.new(viewport)
@num3 = Sprite.new(viewport)
@num4 = Sprite.new(viewport)
@num5 = Sprite.new(viewport)
@num1.visible = false
@num2.visible = false
@num3.visible = false
@num4.visible = false
@num5.visible = false
end
#--------------------------------------------------------------------------
# ● 更新
#--------------------------------------------------------------------------
def update
force_damage
move_damage(@num5, @pop_time) if @num5.visible
move_damage(@num4, @pop_time - 2) if @num4.visible
move_damage(@num3, @pop_time - 4) if @num3.visible
move_damage(@num2, @pop_time - 6) if @num2.visible
move_damage(@num1, @pop_time - 8) if @num1.visible
move_window if @window != nil
@duration -= 1 if @duration > 0
end
#--------------------------------------------------------------------------
# ● 事件的傷害POP
#--------------------------------------------------------------------------
def force_damage
if @battler.force_damage != 0
damage_pop(@battler.force_damage)
@battler.hp -= @battler.force_damage
@force_damage = true
@battler.force_damage = 0
$game_temp.status_window_refresh = true
end
end
#--------------------------------------------------------------------------
# ● 數值的移動
#--------------------------------------------------------------------------
def move_damage(num, min)
case @duration
when min-1..min
num.x -= 1
num.y -= 4
when min-3..min-2
num.x -= 1
num.y -= 3
when min-6..min-4
num.y -= 2
when min-14..min-7
num.y += 2
when min-17..min-15
num.y -= 2
when min-23..min-18
num.y += 1
when min-27..min-24
num.y -= 1
when min-30..min-28
num.y += 1
when min-33..min-31
num.y -= 1
when min-36..min-34
num.y += 1
end
next_damage if @battler.double_damage && @duration == min-34
num.opacity = 256 - (12 - @duration) * 32
num.visible = false if @duration == 0
if @force_damage && @duration == 0
@force_damage = false
@battler.perform_collapse
end
end
#--------------------------------------------------------------------------
# ● 文字窗口的移動
#--------------------------------------------------------------------------
def move_window
@window.x -= 6 if @window_time > 0 && @window.x > 0
@window_time -= 1
if @duration == 0
@window.dispose
@window = nil
end
end
#--------------------------------------------------------------------------
# ● HPMP兩方同時傷害
#--------------------------------------------------------------------------
def next_damage
@battler.hp_damage = 0
@battler.double_damage = false
damage_pop
end
#--------------------------------------------------------------------------
# ● 準備傷害POP
#--------------------------------------------------------------------------
def damage_pop(num = nil)
reset
damage = battler.hp_damage
# 抽出狀態的變化
states = battler.added_states
text = ""
# MP傷害用文本(HPMP兩方同時傷害除外)
if [email protected]_damage && @battler.mp_damage != 0
text = N01::POP_MP_DAM if battler.mp_damage > 0
text = N01::POP_MP_REC if battler.mp_damage < 0
damage = battler.mp_damage
end
# 連續傷害不顯示MP傷害以外的文字
if num == nil
text = N01::POP_DAMAGE0 if damage == 0 && states == [] && !battler.revival
text = N01::POP_MISS if battler.missed && states == []
text = N01::POP_EVA if battler.evaded
text = N01::POP_CRI if battler.critical
for state in states
# 無POP設定的狀態不顯示
unless state.extension.include?("無POP")
text += " " if text != ""
text += state.name
end
end
else
damage = num
end
# 區分傷害和回復
@minus = false
@minus = true if damage < 0
damage = damage.abs
# 略微調整POP位置
adjust = -16
adjust = 16 if $back_attack
adjust = 0 if damage == 0
@x = battler.position_x + adjust
@y = battler.position_y
window(text) if text != ""
@pop_time = N01::NUM_DURATION
# 沒有傷害時沒有數字的POP
return @duration = @pop_time if damage == 0
@num_time = -1
damage_file(@num1, damage % 10, @pop_time - 7) if damage >= 0
damage_file(@num2, (damage % 100)/10, @pop_time - 5) if damage >= 10
damage_file(@num3, (damage % 1000)/100, @pop_time - 3) if damage >= 100
damage_file(@num4, (damage % 10000)/1000, @pop_time - 1) if damage >= 1000
damage_file(@num5, (damage % 100000)/10000, @pop_time + 1) if damage >= 10000
end
#--------------------------------------------------------------------------
# ● 準備情報窗口
#--------------------------------------------------------------------------
def window(text)
@window = Window_Damage.new(@x - 64, @y - 22)
@window.pop_text(text)
@window_time = 5
end
#--------------------------------------------------------------------------
# ● 準備數字畫像
#--------------------------------------------------------------------------
def damage_file(num, cw, dur)
num.visible = true
# 判別文件
file = N01::DAMAGE_GRAPHICS
file = N01::RECOVER_GRAPHICS if @minus
# 數字
num.bitmap = Cache.system(file)
@num_time += 1
sx = num.bitmap.width / 10
num.src_rect.set(cw * sx, 0, sx, num.height)
num.x = @x - (num.width + N01::NUM_INTERBAL) * @num_time
num.y = @y
num.z = 2000 - @num_time
@duration = dur
@window.x = num.x - @window.width + 64 if @window != nil && N01::NON_DAMAGE_WINDOW
@window.x = num.x - @window.width + 26 if @window != nil && !N01::NON_DAMAGE_WINDOW
@window.x = 0 if @window != nil && @window.x < 0
end
#--------------------------------------------------------------------------
# ● 傷害組合
#--------------------------------------------------------------------------
def reset
@num5.visible = @num4.visible = @num3.visible = @num2.visible = @num1.visible = false
@window.dispose if @window != nil
@window = nil
end
#--------------------------------------------------------------------------
# ● 開放
#--------------------------------------------------------------------------
def dispose
super
@num1.dispose
@num2.dispose
@num3.dispose
@num4.dispose
@num5.dispose
@window.dispose if @window != nil
end
end
#==============================================================================
# ■ Window_Damage
#------------------------------------------------------------------------------
# 　危機等表示的窗口。
#==============================================================================
class Window_Damage < Window_Base
#--------------------------------------------------------------------------
# ● 客觀初期化
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 160, 46)
self.opacity = 0 if N01::NON_DAMAGE_WINDOW
end
#--------------------------------------------------------------------------
# ● 窗口內容的作成
#--------------------------------------------------------------------------
def create_contents
self.contents.dispose
self.contents = Bitmap.new(width - 32, height - 32)
end
#--------------------------------------------------------------------------
# ● 狀態設定
#--------------------------------------------------------------------------
def pop_text(text, align = 1)
self.contents.clear
self.width = self.contents.text_size(text).width + 36
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.color = normal_color
self.contents.font.size = 16
self.contents.draw_text(0,-8, width - 32, 32, text, align)
end
end
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　遊戲中處理所有窗口的超級類。
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# ● 狀態的描畫 ※再定義(反映設定不顯示狀態ICON)
#--------------------------------------------------------------------------
def draw_actor_state(actor, x, y, width = 96)
count = 0
for state in actor.states
break if state.extension.include?("不顯示ICON")
draw_icon(state.icon_index, x + 24 * count, y)
count += 1
break if (24 * count > width - 24)
end
end
end
#==============================================================================
# ■ Game_Temp
#------------------------------------------------------------------------------
# 　不包含存儲數據、處理一時數據的類。
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# ● 公開變數
#--------------------------------------------------------------------------
attr_accessor :status_window_refresh # 狀態窗口的還原標誌
#--------------------------------------------------------------------------
# ● 客觀初期化
#--------------------------------------------------------------------------
alias initialize_n01 initialize
def initialize
initialize_n01
@status_window_refresh = false
end
end
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　實行時間指令的解釋。
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# ● HP 的增減
#--------------------------------------------------------------------------
def command_311
if $game_temp.in_battle
value = operate_value(@params[1], @params[2], @params[3])
iterate_actor_id(@params[0]) do |actor|
next if actor.dead?
if @params[4] == false and actor.hp + value <= 0
actor.damage_num(actor.hp - 1) # 如果不允許戰鬥不能時變為1
else
actor.damage_num(-value)
end
end
return true
else
value = operate_value(@params[1], @params[2], @params[3])
iterate_actor_id(@params[0]) do |actor|
next if actor.dead?
if @params[4] == false and actor.hp + value <= 0
actor.hp = 1 # 如果不允許戰鬥不能時變為1
else
actor.hp += value
end
actor.perform_collapse
end
if $game_party.all_dead?
$game_temp.next_scene = "gameover"
end
return true
end
end
#--------------------------------------------------------------------------
# ● 敵角色的 HP 增減
#--------------------------------------------------------------------------
def command_331
value = operate_value(@params[1], @params[2], @params[3])
iterate_enemy_index(@params[0]) do |enemy|
if enemy.hp > 0
if @params[4] == false and enemy.hp + value <= 0
enemy.damage_num(enemy.hp - 1) # 如果不允許戰鬥不能時變為1
else
enemy.damage_num(-value)
end
end
end
return true
end
end
#==============================================================================
# ■ Game_Party
#------------------------------------------------------------------------------
# 　扱。
#==============================================================================
class Game_Party < Game_Unit
#--------------------------------------------------------------------------
# ● 加
# actor_id :  ID
#--------------------------------------------------------------------------
alias add_actor_n01 add_actor
def add_actor(actor_id)
add_actor_n01(actor_id)
$party_change = true if actor_id == 4
end
#--------------------------------------------------------------------------
# ● 外
# actor_id :  ID
#--------------------------------------------------------------------------
alias remove_actor_n01 remove_actor
def remove_actor(actor_id)
remove_actor_n01(actor_id)
$party_change = true if actor_id == 4
end
end

复制代码

evermilk · 发表于 2011-6-27 20:20:53

搜索def collapse_type
地下return 1的都是有残像的敌人2为普通3为boss
如果你想大家都一样普通的话就把when 后面的数字改成0或者直接删掉条件

lsu666666 · 发表于 2011-6-27 21:49:40

应该说我运气好昨天套用了一个范例的横版战斗系统..竟然就不会有此问题
好神奇...问题就这样很自然的解决了
刚好省去我很多麻烦..qq...谢谢你的回覆

帐号		自动登录	找回密码
密码			注册会员

[已经解决] VX-横版-敌人死亡..还会出现残影.如何克服?谢谢

点评