Project1
标题:
《综合战斗处理第二代》
[打印本页]
作者:
dengwei
时间:
2012-7-13 10:50
标题:
《综合战斗处理第二代》
#==============================================================================
# 《综合战斗处理第二代》
#介绍；这款脚本加了以下内容；
# 1.空手攻击的动画ID是第一个，被攻动画ID是第二个
# 2.空手时攻防能力，修改防御力在 1252行，攻击力在 1246行
# 3.增加了入场的动画，入场动画为3
# 4.增加了 当物理攻击时，被攻方SP 与 HP 一起减少
# 5.增加了 当物理攻击时，被攻方SP增加，HP 减少 (恢血的sp会减少的奥~~这是个缺陷，呵呵~~)
# 6.增加了 连续伤害时，被攻方SP增加，HP 减少HP的5%
# 7.增加了 战斗人物的上下摇动，如果不想要，就把1560行的 return 480 - rand(5)改为return 480
# 8.把“MISS”更改成了“打空”
# 9.增加了 战斗敌人人物的左右摇动，如果不想要，就把1793行的 return $data_troops[@troop_id].members[@member_index].y + rand(5)改为return $data_troops[@troop_id].members[@member_index].y
# 10.更新了新的战斗计算方式，增加了幸运的随机伤害100
# 11.随机获取经验，获取范围为你输入的 打死后获得经验 的值
# 13.随机获取金钱，获取范围为你输入的 打死后获得金钱 的值
# 14.增加了游戏一开始你的金钱，（随机获得），更改在1914，如果不要，就改为0.
# 15.增加了显血设置(其中有2个显血设置来自66RPG)
#
#
# *！！一定要在Main脚本前面，所有脚本的后面插入，不然就会发生错误！~~~~~
# *！！注意，空手时攻击力的值是随机值，每换一次装备，空手时的攻击力就会改变！~
# #！！此脚步可能会与某些脚本发生冲突！~~
#制作人；STUPID ANT 制作组；STUPID PIG工作室
##########################《使用声明》#########################################
#本脚本由STUPID PIG工作室自行研制，其制作权归本工作室所有，当然大家可以尽情的
#使用，但是所有的备注都不能删除，呵呵~~就算你加密，我们也不怕，很轻松就能看到！
#在使用过程中如果有什么漏洞或新的想法，可以联系我们，QQ;1660618519
#当然，我不经常在线，所以你们还可以打我手机；13977375101
#祝你们做游戏愉快!~
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 定义实例变量
#--------------------------------------------------------------------------
attr_reader :battler_name # 战斗者 文件名
attr_reader :battler_hue # 战斗者 色相
attr_reader :hp # HP
attr_reader :sp # SP
attr_reader :states # 状态
attr_accessor :hidden # 隐藏标志
attr_accessor :immortal # 不死身标志
attr_accessor :damage_pop # 显示伤害标志
attr_accessor :damage # 伤害值
attr_accessor :critical # 会心一击标志
attr_accessor :animation_id # 动画 ID
attr_accessor :animation_hit # 动画 击中标志
attr_accessor :white_flash # 白色屏幕闪烁标志
attr_accessor :blink # 闪烁标志
#--------------------------------------------------------------------------
# ● 初始化对像
#--------------------------------------------------------------------------
def initialize
@battler_name = ""
@battler_hue = 0
@hp = 0
@sp = 0
@states = []
@states_turn = {}
@maxhp_plus = 0
@maxsp_plus = 0
@str_plus = 0
@dex_plus = 0
@agi_plus = 0
@int_plus = 0
@hidden = false
@immortal = false
@damage_pop = false
@damage = nil
@critical = false
@animation_id = 03
@animation_hit = false
@white_flash = false
@blink = false
@current_action = Game_BattleAction.new
end
#--------------------------------------------------------------------------
# ● 获取 MaxHP
#--------------------------------------------------------------------------
def maxhp
n = [[base_maxhp + @maxhp_plus, 1].max, 999999].min
for i in @states
n *= $data_states.maxhp_rate / 100.0
end
n = [[Integer(n), 1].max, 999999].min
return n
end
#--------------------------------------------------------------------------
# ● 获取 MaxSP
#--------------------------------------------------------------------------
def maxsp
n = [[base_maxsp + @maxsp_plus, 0].max, 9999].min
for i in @states
n *= $data_states.maxsp_rate / 100.0
end
n = [[Integer(n), 0].max, 9999].min
return n
end
#--------------------------------------------------------------------------
# ● 获取力量
#--------------------------------------------------------------------------
def str
n = [[base_str + @str_plus, 1].max, 999].min
for i in @states
n *= $data_states.str_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# ● 获取灵巧
#--------------------------------------------------------------------------
def dex
n = [[base_dex + @dex_plus, 1].max, 999].min
for i in @states
n *= $data_states.dex_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# ● 获取速度
#--------------------------------------------------------------------------
def agi
n = [[base_agi + @agi_plus, 1].max, 999].min
for i in @states
n *= $data_states.agi_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# ● 获取魔力
#--------------------------------------------------------------------------
def int
n = [[base_int + @int_plus, 1].max, 999].min
for i in @states
n *= $data_states.int_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# ● 设置 MaxHP
# maxhp : 新的 MaxHP
#--------------------------------------------------------------------------
def maxhp=(maxhp)
@maxhp_plus += maxhp - self.maxhp
@maxhp_plus = [[@maxhp_plus, -9999].max, 9999].min
@hp = [@hp, self.maxhp].min
end
#--------------------------------------------------------------------------
# ● 设置 MaxSP
# maxsp : 新的 MaxSP
#--------------------------------------------------------------------------
def maxsp=(maxsp)
@maxsp_plus += maxsp - self.maxsp
@maxsp_plus = [[@maxsp_plus, -9999].max, 9999].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# ● 设置力量
# str : 新的力量
#--------------------------------------------------------------------------
def str=(str)
@str_plus += str - self.str
@str_plus = [[@str_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# ● 设置灵巧
# dex : 新的灵巧
#--------------------------------------------------------------------------
def dex=(dex)
@dex_plus += dex - self.dex
@dex_plus = [[@dex_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# ● 设置速度
# agi : 新的速度
#--------------------------------------------------------------------------
def agi=(agi)
@agi_plus += agi - self.agi
@agi_plus = [[@agi_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# ● 设置魔力
# int : 新的魔力
#--------------------------------------------------------------------------
def int=(int)
@int_plus += int - self.int
@int_plus = [[@int_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# ● 获取命中率
#--------------------------------------------------------------------------
def hit
n = 100
for i in @states
n *= $data_states.hit_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# ● 获取攻击力
#--------------------------------------------------------------------------
def atk
n = base_atk
for i in @states
n *= $data_states.atk_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# ● 获取物理防御
#--------------------------------------------------------------------------
def pdef
n = base_pdef
for i in @states
n *= $data_states.pdef_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# ● 获取魔法防御
#--------------------------------------------------------------------------
def mdef
n = base_mdef
for i in @states
n *= $data_states.mdef_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# ● 获取回避修正
#--------------------------------------------------------------------------
def eva
n = base_eva
for i in @states
n += $data_states.eva
end
return n
end
#--------------------------------------------------------------------------
# ● 更改 HP
# hp : 新的 HP
#--------------------------------------------------------------------------
def hp=(hp)
@hp = [[hp, maxhp].min, 0].max
# 解除附加的战斗不能状态
for i in 1...$data_states.size
if $data_states.zero_hp
if self.dead?
add_state(i)
else
remove_state(i)
end
end
end
end
#--------------------------------------------------------------------------
# ● 更改 SP
# sp : 新的 SP
#--------------------------------------------------------------------------
def sp=(sp)
@sp = [[sp, maxsp].min, 0].max
end
#--------------------------------------------------------------------------
# ● 全回复
#--------------------------------------------------------------------------
def recover_all
@hp = maxhp
@sp = maxsp
for i in @states.clone
remove_state(i)
end
end
#--------------------------------------------------------------------------
# ● 获取当前的动作
#--------------------------------------------------------------------------
def current_action
return @current_action
end
#--------------------------------------------------------------------------
# ● 确定动作速度
#--------------------------------------------------------------------------
def make_action_speed
@current_action.speed = agi + rand(10 + agi / 4)
end
#--------------------------------------------------------------------------
# ● 战斗不能判定
#--------------------------------------------------------------------------
def dead?
return (@hp == 0 and not @immortal)
end
#--------------------------------------------------------------------------
# ● 存在判定
#--------------------------------------------------------------------------
def exist?
return (not @hidden and (@hp > 0 or @immortal))
end
#--------------------------------------------------------------------------
# ● HP 0 判定
#--------------------------------------------------------------------------
def hp0?
return (not @hidden and @hp == 0)
end
#--------------------------------------------------------------------------
# ● 可以输入命令判定
#--------------------------------------------------------------------------
def inputable?
return (not @hidden and restriction <= 1)
end
#--------------------------------------------------------------------------
# ● 可以行动判定
#--------------------------------------------------------------------------
def movable?
return (not @hidden and restriction < 4)
end
#--------------------------------------------------------------------------
# ● 防御中判定
#--------------------------------------------------------------------------
def guarding?
return (@current_action.kind == 0 and @current_action.basic == 1)
end
#--------------------------------------------------------------------------
# ● 休止中判定
#--------------------------------------------------------------------------
def resting?
return (@current_action.kind == 0 and @current_action.basic == 3)
end
end
#==============================================================================
# ■ Game_Battler (分割定义 2)
#------------------------------------------------------------------------------
# 处理战斗者的类。这个类作为 Game_Actor 类与 Game_Enemy 类的
# 超级类来使用。
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 检查状态
# state_id : 状态 ID
#--------------------------------------------------------------------------
def state?(state_id)
# 如果符合被附加的状态的条件就返回 ture
return @states.include?(state_id)
end
#--------------------------------------------------------------------------
# ● 判断状态是否为 full
# state_id : 状态 ID
#--------------------------------------------------------------------------
def state_full?(state_id)
# 如果符合被附加的状态的条件就返回 false
unless self.state?(state_id)
return false
end
# 秩序回合数 -1 (自动状态) 然后返回 true
if @states_turn[state_id] == -1
return true
end
# 当持续回合数等于自然解除的最低回合数时返回 ture
return @states_turn[state_id] == $data_states[state_id].hold_turn
end
#--------------------------------------------------------------------------
# ● 附加状态
# state_id : 状态 ID
# force : 强制附加标志 (处理自动状态时使用)
#--------------------------------------------------------------------------
def add_state(state_id, force = false)
# 无效状态的情况下
if $data_states[state_id] == nil
# 过程结束
return
end
# 无法强制附加的情况下
unless force
# 已存在的状态循环
for i in @states
# 新的状态和已经存在的状态 (-) 同时包含的情况下、
# 本状态不包含变化为新状态的状态变化 (-)
# (ex : 战斗不能与附加中毒同时存在的场合)
if $data_states.minus_state_set.include?(state_id) and
not $data_states[state_id].minus_state_set.include?(i)
# 过程结束
return
end
end
end
# 无法附加本状态的情况下
unless state?(state_id)
# 状态 ID 追加到 @states 序列中
@states.push(state_id)
# 选项 [当作 HP 0 的状态] 有效的情况下
if $data_states[state_id].zero_hp
# HP 更改为 0
@hp = 0
end
# 所有状态的循环
for i in 1...$data_states.size
# 状态变化 (+) 处理
if $data_states[state_id].plus_state_set.include?(i)
add_state(i)
end
# 状态变化 (-) 处理
if $data_states[state_id].minus_state_set.include?(i)
remove_state(i)
end
end
# 按比例大的排序 (值相等的情况下按照强度排序)
@states.sort! do |a, b|
state_a = $data_states[a]
state_b = $data_states
if state_a.rating > state_b.rating
-1
elsif state_a.rating < state_b.rating
+1
elsif state_a.restriction > state_b.restriction
-1
elsif state_a.restriction < state_b.restriction
+1
else
a <=> b
end
end
end
# 强制附加的场合
if force
# 设置为自然解除的最低回数 -1 (无效)
@states_turn[state_id] = -1
end
# 不能强制附加的场合
unless @states_turn[state_id] == -1
# 设置为自然解除的最低回数
@states_turn[state_id] = $data_states[state_id].hold_turn
end
# 无法行动的场合
unless movable?
# 清除行动
@current_action.clear
end
# 检查 HP 及 SP 的最大值
@hp = [@hp, self.maxhp].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# ● 解除状态
# state_id : 状态 ID
# force : 强制解除标志 (处理自动状态时使用)
#--------------------------------------------------------------------------
def remove_state(state_id, force = false)
# 无法附加本状态的情况下
if state?(state_id)
# 被强制附加的状态、并不是强制解除的情况下
if @states_turn[state_id] == -1 and not force
# 过程结束
return
end
# 现在的 HP 为 0 当作选项 [当作 HP 0 的状态]有效的场合
if @hp == 0 and $data_states[state_id].zero_hp
# 判断是否有另外的 [当作 HP 0 的状态]状态
zero_hp = false
for i in @states
if i != state_id and $data_states.zero_hp
zero_hp = true
end
end
# 如果可以解除战斗不能、将 HP 更改为 1
if zero_hp == false
@hp = 1
end
end
# 将状态 ID 从 @states 队列和 @states_turn hash 中删除
@states.delete(state_id)
@states_turn.delete(state_id)
end
# 检查 HP 及 SP 的最大值
@hp = [@hp, self.maxhp].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# ● 获取状态的动画 ID
#--------------------------------------------------------------------------
def state_animation_id
# 一个状态也没被附加的情况下
if @states.size == 0
return 0
end
# 返回概率最大的状态动画 ID
return $data_states[@states[0]].animation_id
end
#--------------------------------------------------------------------------
# ● 获取限制
#--------------------------------------------------------------------------
def restriction
restriction_max = 0
# 从当前附加的状态中获取最大的 restriction
for i in @states
if $data_states.restriction >= restriction_max
restriction_max = $data_states.restriction
end
end
return restriction_max
end
#--------------------------------------------------------------------------
# ● 判断状态 [无法获得 EXP]
#--------------------------------------------------------------------------
def cant_get_exp?
for i in @states
if $data_states.cant_get_exp
return true
end
end
return false
end
#--------------------------------------------------------------------------
# ● 判断状态 [无法回避攻击]
#--------------------------------------------------------------------------
def cant_evade?
for i in @states
if $data_states.cant_evade
return true
end
end
return false
end
#--------------------------------------------------------------------------
# ● 判断状态 [连续伤害]
#--------------------------------------------------------------------------
def slip_damage?
for i in @states
if $data_states.slip_damage
return true
end
end
return false
end
#--------------------------------------------------------------------------
# ● 解除战斗用状态 (战斗结束时调用)
#--------------------------------------------------------------------------
def remove_states_battle
for i in @states.clone
if $data_states.battle_only
remove_state(i)
end
end
end
#--------------------------------------------------------------------------
# ● 状态自然解除 (回合改变时调用)
#--------------------------------------------------------------------------
def remove_states_auto
for i in @states_turn.keys.clone
if @states_turn > 0
@states_turn -= 1
elsif rand(100) < $data_states.auto_release_prob
remove_state(i)
end
end
end
#--------------------------------------------------------------------------
# ● 状态攻击解除 (受到物理伤害时调用)
#--------------------------------------------------------------------------
def remove_states_shock
for i in @states.clone
if rand(100) < $data_states.shock_release_prob
remove_state(i)
end
end
end
#--------------------------------------------------------------------------
# ● 状态变化 (+) 的适用
# plus_state_set : 状态变化 (+)
#--------------------------------------------------------------------------
def states_plus(plus_state_set)
# 清除有效标志
effective = false
# 循环 (附加状态)
for i in plus_state_set
# 无法防御本状态的情况下
unless self.state_guard?(i)
# 这个状态如果不是 full 的话就设置有效标志
effective |= self.state_full?(i) == false
# 状态为 [不能抵抗] 的情况下
if $data_states.nonresistance
# 设置状态变化标志
@state_changed = true
# 附加状态
add_state(i)
# 这个状态不是 full 的情况下
elsif self.state_full?(i) == false
# 将状态的有效度变换为概率、与随机数比较
if rand(100) < [0,100,80,60,40,20,0][self.state_ranks]
# 设置状态变化标志
@state_changed = true
# 附加状态
add_state(i)
end
end
end
end
# 过程结束
return effective
end
#--------------------------------------------------------------------------
# ● 状态变化 (-) 的使用
# minus_state_set : 状态变化 (-)
#--------------------------------------------------------------------------
def states_minus(minus_state_set)
# 清除有效标志
effective = false
# 循环 (解除状态)
for i in minus_state_set
# 如果这个状态被附加则设置有效标志
effective |= self.state?(i)
# 设置状态变化标志
@state_changed = true
# 解除状态
remove_state(i)
end
# 过程结束
return effective
end
end
#==============================================================================
# ■ Game_Battler (分割定义 3)
#------------------------------------------------------------------------------
# 处理战斗者的类。这个类作为 Game_Actor 类与 Game_Enemy 类的
# 超级类来使用。
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 可以使用特技的判定
# skill_id : 特技 ID
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
# SP 不足的情况下不能使用
if $data_skills[skill_id].sp_cost > self.sp
return false
end
# 战斗不能的情况下不能使用
if dead?
return false
end
# 沉默状态的情况下、物理特技以外的特技不能使用
if $data_skills[skill_id].atk_f == 0 and self.restriction == 1
return false
end
# 获取可以使用的时机
occasion = $data_skills[skill_id].occasion
# 战斗中的情况下
if $game_temp.in_battle
# [平时] 或者是 [战斗中] 可以使用
return (occasion == 0 or occasion == 1)
# 不是战斗中的情况下
else
# [平时] 或者是 [菜单中] 可以使用
return (occasion == 0 or occasion == 2)
end
end
#--------------------------------------------------------------------------
# ● 应用通常攻击效果
# attacker : 攻击者 (battler)
#--------------------------------------------------------------------------
def attack_effect(attacker)
# 清除会心一击标志
self.critical = false
# 第一命中判定
hit_result = (rand(100) < attacker.hit)
# 命中的情况下
if hit_result == true
# 计算基本伤害
atk = [attacker.atk - self.pdef / 2, 0].max
self.damage = atk * (20 + attacker.str) / 20 + rand(100)
# 属性修正
self.damage *= elements_correct(attacker.element_set)
self.damage /= 100
# 伤害符号正确的情况下
if self.damage > 0
# 会心一击修正
if rand(100) < 4 * attacker.dex / self.agi
self.damage *= 2
self.critical = true
end
# 防御修正
if self.guarding?
self.damage /= 2
end
end
# 分散
if self.damage.abs > 0
amp = [self.damage.abs * 15 / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# 第二命中判定
eva = 8 * self.agi / attacker.dex + self.eva
hit = self.damage < 0 ? 100 : 100 - eva
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
end
# 命中的情况下
if hit_result == true
# 状态冲击解除
remove_states_shock
# HP 的伤害计算
self.hp -= self.damage
self.sp -= self.damage
# 状态变化
@state_changed = false
states_plus(attacker.plus_state_set)
states_minus(attacker.minus_state_set)
# Miss 的情况下
else
# 伤害设置为 "Miss"
self.damage = "打空"
# 清除会心一击标志
self.critical = false
end
# 过程结束
return true
end
#--------------------------------------------------------------------------
# ● 应用特技效果
# user : 特技的使用者 (battler)
# skill : 特技
#--------------------------------------------------------------------------
def skill_effect(user, skill)
# 清除会心一击标志
self.critical = false
# 特技的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
# 或者特技的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
# 过程结束
return false
end
# 清除有效标志
effective = false
# 公共事件 ID 是有效的情况下,设置为有效标志
effective |= skill.common_event_id > 0
# 第一命中判定
hit = skill.hit
if skill.atk_f > 0
hit *= user.hit / 100
end
hit_result = (rand(100) < hit)
# 不确定的特技的情况下设置为有效标志
effective |= hit < 100
# 命中的情况下
if hit_result == true
# 计算威力
power = skill.power + user.atk * skill.atk_f / 100
if power > 0
power -= self.pdef * skill.pdef_f / 200
power -= self.mdef * skill.mdef_f / 200
power = [power, 0].max
end
# 计算倍率
rate = 20
rate += (user.str * skill.str_f / 100)
rate += (user.dex * skill.dex_f / 100)
rate += (user.agi * skill.agi_f / 100)
rate += (user.int * skill.int_f / 100)
# 计算基本伤害
self.damage = power * rate / 20 + rand(100)
# 属性修正
self.damage *= elements_correct(skill.element_set)
self.damage /= 100
# 伤害符号正确的情况下
if self.damage > 0
# 防御修正
if self.guarding?
self.damage /= 2
end
end
# 分散
if skill.variance > 0 and self.damage.abs > 0
amp = [self.damage.abs * skill.variance / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# 第二命中判定
eva = 8 * self.agi / user.dex + self.eva
hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
# 不确定的特技的情况下设置为有效标志
effective |= hit < 100
end
# 命中的情况下
if hit_result == true
# 威力 0 以外的物理攻击的情况下
if skill.power != 0 and skill.atk_f > 0
# 状态冲击解除
remove_states_shock
# 设置有效标志
effective = true
end
# HP 的伤害减法运算
last_hp = self.hp
self.hp -= self.damage
self.sp += self.damage
effective |= self.hp != last_hp
# 状态变化
@state_changed = false
effective |= states_plus(skill.plus_state_set)
effective |= states_minus(skill.minus_state_set)
# 威力为 0 的场合
if skill.power == 0
# 伤害设置为空的字串
self.damage = ""
# 状态没有变化的情况下
unless @state_changed
# 伤害设置为 "Miss"
self.damage = "打空"
end
end
# Miss 的情况下
else
# 伤害设置为 "Miss"
self.damage = "打空"
end
# 不在战斗中的情况下
unless $game_temp.in_battle
# 伤害设置为 nil
self.damage = nil
end
# 过程结束
return effective
end
#--------------------------------------------------------------------------
# ● 应用物品效果
# item : 物品
#--------------------------------------------------------------------------
def item_effect(item)
# 清除会心一击标志
self.critical = false
# 物品的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
# 或者物品的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
((item.scope == 5 or item.scope == 6) and self.hp >= 1)
# 过程结束
return false
end
# 清除有效标志
effective = false
# 公共事件 ID 是有效的情况下,设置为有效标志
effective |= item.common_event_id > 0
# 命中判定
hit_result = (rand(100) < item.hit)
# 不确定的特技的情况下设置为有效标志
effective |= item.hit < 100
# 命中的情况
if hit_result == true
# 计算回复量
recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
if recover_hp < 0
recover_hp += self.pdef * item.pdef_f / 20
recover_hp += self.mdef * item.mdef_f / 20
recover_hp = [recover_hp, 0].min
end
# 属性修正
recover_hp *= elements_correct(item.element_set)
recover_hp /= 100
recover_sp *= elements_correct(item.element_set)
recover_sp /= 100
# 分散
if item.variance > 0 and recover_hp.abs > 0
amp = [recover_hp.abs * item.variance / 100, 1].max
recover_hp += rand(amp+1) + rand(amp+1) - amp
end
if item.variance > 0 and recover_sp.abs > 0
amp = [recover_sp.abs * item.variance / 100, 1].max
recover_sp += rand(amp+1) + rand(amp+1) - amp
end
# 回复量符号为负的情况下
if recover_hp < 0
# 防御修正
if self.guarding?
recover_hp /= 2
end
end
# HP 回复量符号的反转、设置伤害值
self.damage = -recover_hp
# HP 以及 SP 的回复
last_hp = self.hp
last_sp = self.sp
self.hp += recover_hp
self.sp += recover_sp
effective |= self.hp != last_hp
effective |= self.sp != last_sp
# 状态变化
@state_changed = false
effective |= states_plus(item.plus_state_set)
effective |= states_minus(item.minus_state_set)
# 能力上升值有效的情况下
if item.parameter_type > 0 and item.parameter_points != 0
# 能力值的分支
case item.parameter_type
when 1 # MaxHP
@maxhp_plus += item.parameter_points
when 2 # MaxSP
@maxsp_plus += item.parameter_points
when 3 # 力量
@str_plus += item.parameter_points
when 4 # 灵巧
@dex_plus += item.parameter_points
when 5 # 速度
@agi_plus += item.parameter_points
when 6 # 魔力
@int_plus += item.parameter_points
end
# 设置有效标志
effective = true
end
# HP 回复率与回复量为 0 的情况下
if item.recover_hp_rate == 0 and item.recover_hp == 0
# 设置伤害为空的字符串
self.damage = ""
# SP 回复率与回复量为 0、能力上升值无效的情况下
if item.recover_sp_rate == 0 and item.recover_sp == 0 and
(item.parameter_type == 0 or item.parameter_points == 0)
# 状态没有变化的情况下
unless @state_changed
# 伤害设置为 "Miss"
self.damage = "打空"
end
end
end
# Miss 的情况下
else
# 伤害设置为 "Miss"
self.damage = "打空"
end
# 不在战斗中的情况下
unless $game_temp.in_battle
# 伤害设置为 nil
self.damage = nil
end
# 过程结束
return effective
end
#--------------------------------------------------------------------------
# ● 应用连续伤害效果
#--------------------------------------------------------------------------
def slip_damage_effect
# 设置伤害
self.damage = self.maxhp / 5
# 分散
if self.damage.abs > 0
amp = [self.damage.abs * 15 / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# HP 的伤害减法运算
self.hp -= self.damage
# 过程结束
return true
end
#--------------------------------------------------------------------------
# ● 属性修正计算
# element_set : 属性
#--------------------------------------------------------------------------
def elements_correct(element_set)
# 无属性的情况
if element_set == []
# 返回 100
return 100
end
# 在被赋予的属性中返回最弱的
# ※过程 element_rate 是、本类以及继承的 Game_Actor
# 和 Game_Enemy 类的定义
weakest = -100
for i in element_set
weakest = [weakest, self.element_rate(i)].max
end
return weakest
end
end
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 处理角色的类。本类在 Game_Actors 类 ($game_actors)
# 的内部使用、Game_Party 类请参考 ($game_party) 。
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● 定义实例变量
#--------------------------------------------------------------------------
attr_reader :name # 名称
attr_reader :character_name # 角色 文件名
attr_reader :character_hue # 角色 色相
attr_reader :class_id # 职业 ID
attr_reader :weapon_id # 武器 ID
attr_reader :armor1_id # 盾 ID
attr_reader :armor2_id # 头防具 ID
attr_reader :armor3_id # 身体体防具 ID
attr_reader :armor4_id # 装饰品 ID
attr_reader :level # 等级
attr_reader :exp # EXP
attr_reader :skills # 特技
#--------------------------------------------------------------------------
# ● 初始化对像
# actor_id : 角色 ID
#--------------------------------------------------------------------------
def initialize(actor_id)
super()
setup(actor_id)
end
#--------------------------------------------------------------------------
# ● 设置
# actor_id : 角色 ID
#--------------------------------------------------------------------------
def setup(actor_id)
actor = $data_actors[actor_id]
@actor_id = actor_id
@name = actor.name
@character_name = actor.character_name
@character_hue = actor.character_hue
@battler_name = actor.battler_name
@battler_hue = actor.battler_hue
@class_id = actor.class_id
@weapon_id = actor.weapon_id
@armor1_id = actor.armor1_id
@armor2_id = actor.armor2_id
@armor3_id = actor.armor3_id
@armor4_id = actor.armor4_id
@level = actor.initial_level
@exp_list = Array.new(101)
make_exp_list
@exp = @exp_list[@level]
@skills = []
@hp = maxhp
@sp = maxsp
@states = []
@states_turn = {}
@maxhp_plus = 0
@maxsp_plus = 0
@str_plus = 0
@dex_plus = 0
@agi_plus = 0
@int_plus = 0
# 学会特技
for i in 1..@level
for j in $data_classes[@class_id].learnings
if j.level == i
learn_skill(j.skill_id)
end
end
end
# 刷新自动状态
update_auto_state(nil, $data_armors[@armor1_id])
update_auto_state(nil, $data_armors[@armor2_id])
update_auto_state(nil, $data_armors[@armor3_id])
update_auto_state(nil, $data_armors[@armor4_id])
end
#--------------------------------------------------------------------------
# ● 获取角色 ID
#--------------------------------------------------------------------------
def id
return @actor_id
end
#--------------------------------------------------------------------------
# ● 获取索引
#--------------------------------------------------------------------------
def index
return $game_party.actors.index(self)
end
#--------------------------------------------------------------------------
# ● 计算 EXP
#--------------------------------------------------------------------------
def make_exp_list
actor = $data_actors[@actor_id]
@exp_list[1] = 0
pow_i = 2.4 + actor.exp_inflation / 100.0
for i in 2..100
if i > actor.final_level
@exp_list = 0
else
n = actor.exp_basis * ((i + 3) ** pow_i) / (5 ** pow_i)
@exp_list = @exp_list[i-1] + Integer(n)
end
end
end
#--------------------------------------------------------------------------
# ● 取得属性修正值
# element_id : 属性 ID
#--------------------------------------------------------------------------
def element_rate(element_id)
# 获取对应属性有效度的数值
table = [0,200,150,100,50,0,-100]
result = table[$data_classes[@class_id].element_ranks[element_id]]
# 防具能防御本属性的情况下效果减半
for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
armor = $data_armors
if armor != nil and armor.guard_element_set.include?(element_id)
result /= 2
end
end
# 状态能防御本属性的情况下效果减半
for i in @states
if $data_states.guard_element_set.include?(element_id)
result /= 2
end
end
# 过程结束
return result
end
#--------------------------------------------------------------------------
# ● 获取属性有效度
#--------------------------------------------------------------------------
def state_ranks
return $data_classes[@class_id].state_ranks
end
#--------------------------------------------------------------------------
# ● 判定防御属性
# state_id : 属性 ID
#--------------------------------------------------------------------------
def state_guard?(state_id)
for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
armor = $data_armors
if armor != nil
if armor.guard_state_set.include?(state_id)
return true
end
end
end
return false
end
#--------------------------------------------------------------------------
# ● 获取普通攻击属性
#--------------------------------------------------------------------------
def element_set
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.element_set : []
end
#--------------------------------------------------------------------------
# ● 获取普通攻击状态变化 (+)
#--------------------------------------------------------------------------
def plus_state_set
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.plus_state_set : []
end
#--------------------------------------------------------------------------
# ● 获取普通攻击状态变化 (-)
#--------------------------------------------------------------------------
def minus_state_set
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.minus_state_set : []
end
#--------------------------------------------------------------------------
# ● 获取 MaxHP
#--------------------------------------------------------------------------
def maxhp
n = [[base_maxhp + @maxhp_plus, 1].max, 9999].min
for i in @states
n *= $data_states.maxhp_rate / 100.0
end
n = [[Integer(n), 1].max, 9999].min
return n
end
#--------------------------------------------------------------------------
# ● 获取基本 MaxHP
#--------------------------------------------------------------------------
def base_maxhp
return $data_actors[@actor_id].parameters[0, @level]
end
#--------------------------------------------------------------------------
# ● 获取基本 MaxSP
#--------------------------------------------------------------------------
def base_maxsp
return $data_actors[@actor_id].parameters[1, @level]
end
#--------------------------------------------------------------------------
# ● 获取基本力量
#--------------------------------------------------------------------------
def base_str
n = $data_actors[@actor_id].parameters[2, @level]
weapon = $data_weapons[@weapon_id]
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
n += weapon != nil ? weapon.str_plus : 0
n += armor1 != nil ? armor1.str_plus : 0
n += armor2 != nil ? armor2.str_plus : 0
n += armor3 != nil ? armor3.str_plus : 0
n += armor4 != nil ? armor4.str_plus : 0
return [[n, 1].max, 999].min
end
#--------------------------------------------------------------------------
# ● 获取基本灵巧
#--------------------------------------------------------------------------
def base_dex
n = $data_actors[@actor_id].parameters[3, @level]
weapon = $data_weapons[@weapon_id]
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
n += weapon != nil ? weapon.dex_plus : 0
n += armor1 != nil ? armor1.dex_plus : 0
n += armor2 != nil ? armor2.dex_plus : 0
n += armor3 != nil ? armor3.dex_plus : 0
n += armor4 != nil ? armor4.dex_plus : 0
return [[n, 1].max, 999].min
end
#--------------------------------------------------------------------------
# ● 获取基本速度
#--------------------------------------------------------------------------
def base_agi
n = $data_actors[@actor_id].parameters[4, @level]
weapon = $data_weapons[@weapon_id]
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
n += weapon != nil ? weapon.agi_plus : 0
n += armor1 != nil ? armor1.agi_plus : 0
n += armor2 != nil ? armor2.agi_plus : 0
n += armor3 != nil ? armor3.agi_plus : 0
n += armor4 != nil ? armor4.agi_plus : 0
return [[n, 1].max, 999].min
end
#--------------------------------------------------------------------------
# ● 获取基本魔力
#--------------------------------------------------------------------------
def base_int
n = $data_actors[@actor_id].parameters[5, @level]
weapon = $data_weapons[@weapon_id]
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
n += weapon != nil ? weapon.int_plus : 0
n += armor1 != nil ? armor1.int_plus : 0
n += armor2 != nil ? armor2.int_plus : 0
n += armor3 != nil ? armor3.int_plus : 0
n += armor4 != nil ? armor4.int_plus : 0
return [[n, 1].max, 999].min
end
#--------------------------------------------------------------------------
# ● 获取基本攻击力
#--------------------------------------------------------------------------
def base_atk
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.atk : rand(60)
end
#--------------------------------------------------------------------------
# ● 获取基本物理防御
#--------------------------------------------------------------------------
def base_pdef
weapon = $data_weapons[@weapon_id]
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
pdef1 = weapon != nil ? weapon.pdef : 0
pdef2 = armor1 != nil ? armor1.pdef : 0
pdef3 = armor2 != nil ? armor2.pdef : 0
pdef4 = armor3 != nil ? armor3.pdef : 0
pdef5 = armor4 != nil ? armor4.pdef : 0
return pdef1 + pdef2 + pdef3 + pdef4 + pdef5 + 5
end
#--------------------------------------------------------------------------
# ● 获取基本魔法防御
#--------------------------------------------------------------------------
def base_mdef
weapon = $data_weapons[@weapon_id]
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
mdef1 = weapon != nil ? weapon.mdef : 0
mdef2 = armor1 != nil ? armor1.mdef : 0
mdef3 = armor2 != nil ? armor2.mdef : 0
mdef4 = armor3 != nil ? armor3.mdef : 0
mdef5 = armor4 != nil ? armor4.mdef : 0
return mdef1 + mdef2 + mdef3 + mdef4 + mdef5
end
#--------------------------------------------------------------------------
# ● 获取基本回避修正
#--------------------------------------------------------------------------
def base_eva
armor1 = $data_armors[@armor1_id]
armor2 = $data_armors[@armor2_id]
armor3 = $data_armors[@armor3_id]
armor4 = $data_armors[@armor4_id]
eva1 = armor1 != nil ? armor1.eva : 0
eva2 = armor2 != nil ? armor2.eva : 0
eva3 = armor3 != nil ? armor3.eva : 0
eva4 = armor4 != nil ? armor4.eva : 0
return eva1 + eva2 + eva3 + eva4
end
#--------------------------------------------------------------------------
# ● 普通攻击 获取攻击方动画 ID
#--------------------------------------------------------------------------
def animation1_id
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.animation1_id : 1
end
#--------------------------------------------------------------------------
# ● 普通攻击 获取对像方动画 ID
#--------------------------------------------------------------------------
def animation2_id
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.animation2_id : 2
end
#--------------------------------------------------------------------------
# ● 获取类名
#--------------------------------------------------------------------------
def class_name
return $data_classes[@class_id].name
end
#--------------------------------------------------------------------------
# ● 获取 EXP 字符串
#--------------------------------------------------------------------------
def exp_s
return @exp_list[@level+1] > 0 ? @exp.to_s : "-------"
end
#--------------------------------------------------------------------------
# ● 获取下一等级的 EXP 字符串
#--------------------------------------------------------------------------
def next_exp_s
return @exp_list[@level+1] > 0 ? @exp_list[@level+1].to_s : "-------"
end
#--------------------------------------------------------------------------
# ● 获取离下一等级还需的 EXP 字符串
#--------------------------------------------------------------------------
def next_rest_exp_s
return @exp_list[@level+1] > 0 ?
(@exp_list[@level+1] - @exp).to_s : "-------"
end
#--------------------------------------------------------------------------
# ● 更新自动状态
# old_armor : 卸下防具
# new_armor : 装备防具
#--------------------------------------------------------------------------
def update_auto_state(old_armor, new_armor)
# 强制解除卸下防具的自动状态
if old_armor != nil and old_armor.auto_state_id != 0
remove_state(old_armor.auto_state_id, true)
end
# 强制附加装备防具的自动状态
if new_armor != nil and new_armor.auto_state_id != 0
add_state(new_armor.auto_state_id, true)
end
end
#--------------------------------------------------------------------------
# ● 装备固定判定
# equip_type : 装备类型
#--------------------------------------------------------------------------
def equip_fix?(equip_type)
case equip_type
when 0 # 武器
return $data_actors[@actor_id].weapon_fix
when 1 # 盾
return $data_actors[@actor_id].armor1_fix
when 2 # 头
return $data_actors[@actor_id].armor2_fix
when 3 # 身体
return $data_actors[@actor_id].armor3_fix
when 4 # 装饰品
return $data_actors[@actor_id].armor4_fix
end
return false
end
#--------------------------------------------------------------------------
# ● 变更装备
# equip_type : 装备类型
# id : 武器 or 防具 ID (0 为解除装备)
#--------------------------------------------------------------------------
def equip(equip_type, id)
case equip_type
when 0 # 武器
if id == 0 or $game_party.weapon_number(id) > 0
$game_party.gain_weapon(@weapon_id, 1)
@weapon_id = id
$game_party.lose_weapon(id, 1)
end
when 1 # 盾
if id == 0 or $game_party.armor_number(id) > 0
update_auto_state($data_armors[@armor1_id], $data_armors[id])
$game_party.gain_armor(@armor1_id, 1)
@armor1_id = id
$game_party.lose_armor(id, 1)
end
when 2 # 头
if id == 0 or $game_party.armor_number(id) > 0
update_auto_state($data_armors[@armor2_id], $data_armors[id])
$game_party.gain_armor(@armor2_id, 1)
@armor2_id = id
$game_party.lose_armor(id, 1)
end
when 3 # 身体
if id == 0 or $game_party.armor_number(id) > 0
update_auto_state($data_armors[@armor3_id], $data_armors[id])
$game_party.gain_armor(@armor3_id, 1)
@armor3_id = id
$game_party.lose_armor(id, 1)
end
when 4 # 装饰品
if id == 0 or $game_party.armor_number(id) > 0
update_auto_state($data_armors[@armor4_id], $data_armors[id])
$game_party.gain_armor(@armor4_id, 1)
@armor4_id = id
$game_party.lose_armor(id, 1)
end
end
end
#--------------------------------------------------------------------------
# ● 可以装备判定
# item : 物品
#--------------------------------------------------------------------------
def equippable?(item)
# 武器的情况
if item.is_a?(RPG::Weapon)
# 包含当前的职业可以装备武器的场合
if $data_classes[@class_id].weapon_set.include?(item.id)
return true
end
end
# 防具的情况
if item.is_a?(RPG::Armor)
# 不包含当前的职业可以装备武器的场合
if $data_classes[@class_id].armor_set.include?(item.id)
return true
end
end
return false
end
#--------------------------------------------------------------------------
# ● 更改 EXP
# exp : 新的 EXP
#--------------------------------------------------------------------------
def exp=(exp)
@exp = [[exp, 9999999].min, 0].max
# 升级
while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0
@level += 1
# 学会特技
for j in $data_classes[@class_id].learnings
if j.level == @level
learn_skill(j.skill_id)
end
end
end
# 降级
while @exp < @exp_list[@level]
@level -= 1
end
# 修正当前的 HP 与 SP 超过最大值
@hp = [@hp, self.maxhp].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# ● 更改等级
# level : 新的等级
#--------------------------------------------------------------------------
def level=(level)
# 检查上下限
level = [[level, $data_actors[@actor_id].final_level].min, 1].max
# 更改 EXP
self.exp = @exp_list[level]
end
#--------------------------------------------------------------------------
# ● 觉悟特技
# skill_id : 特技 ID
#--------------------------------------------------------------------------
def learn_skill(skill_id)
if skill_id > 0 and not skill_learn?(skill_id)
@skills.push(skill_id)
@skills.sort!
end
end
#--------------------------------------------------------------------------
# ● 遗忘特技
# skill_id : 特技 ID
#--------------------------------------------------------------------------
def forget_skill(skill_id)
@skills.delete(skill_id)
end
#--------------------------------------------------------------------------
# ● 已经学会的特技判定
# skill_id : 特技 ID
#--------------------------------------------------------------------------
def skill_learn?(skill_id)
return @skills.include?(skill_id)
end
#--------------------------------------------------------------------------
# ● 可以使用特技判定
# skill_id : 特技 ID
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
if not skill_learn?(skill_id)
return false
end
return super
end
#--------------------------------------------------------------------------
# ● 更改名称
# name : 新的名称
#--------------------------------------------------------------------------
def name=(name)
@name = name
end
#--------------------------------------------------------------------------
# ● 更改职业 ID
# class_id : 新的职业 ID
#--------------------------------------------------------------------------
def class_id=(class_id)
if $data_classes[class_id] != nil
@class_id = class_id
# 避开无法装备的物品
unless equippable?($data_weapons[@weapon_id])
equip(0, 0)
end
unless equippable?($data_armors[@armor1_id])
equip(1, 0)
end
unless equippable?($data_armors[@armor2_id])
equip(2, 0)
end
unless equippable?($data_armors[@armor3_id])
equip(3, 0)
end
unless equippable?($data_armors[@armor4_id])
equip(4, 0)
end
end
end
#--------------------------------------------------------------------------
# ● 更改图形
# character_name : 新的角色 文件名
# character_hue : 新的角色 色相
# battler_name : 新的战斗者 文件名
# battler_hue : 新的战斗者 色相
#--------------------------------------------------------------------------
def set_graphic(character_name, character_hue, battler_name, battler_hue)
@character_name = character_name
@character_hue = character_hue
@battler_name = battler_name
@battler_hue = battler_hue
end
#--------------------------------------------------------------------------
# ● 取得战斗画面的 X 坐标
#--------------------------------------------------------------------------
def screen_x
# 返回计算后的队伍 X 坐标的排列顺序
if self.index != nil
return self.index * 160 + 80
else
return 0
end
end
#--------------------------------------------------------------------------
# ● 取得战斗画面的 Y 坐标
#--------------------------------------------------------------------------
def screen_y
return 480 - rand(5)
end
#--------------------------------------------------------------------------
# ● 取得战斗画面的 Z 坐标
#--------------------------------------------------------------------------
def screen_z
# 返回计算后的队伍 Z 坐标的排列顺序
if self.index != nil
return 8 - self.index
else
return 0
end
end
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 处理敌人的类。本类在 Game_Troop 类 ($game_troop) 的
# 内部使用。
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# ● 初始化对像
# troop_id : 循环 ID
# member_index : 循环成员的索引
#--------------------------------------------------------------------------
def initialize(troop_id, member_index)
super()
@troop_id = troop_id
@member_index = member_index
troop = $data_troops[@troop_id]
@enemy_id = troop.members[@member_index].enemy_id
enemy = $data_enemies[@enemy_id]
@battler_name = enemy.battler_name
@battler_hue = enemy.battler_hue
@hp = maxhp
@sp = maxsp
@hidden = troop.members[@member_index].hidden
@immortal = troop.members[@member_index].immortal
end
#--------------------------------------------------------------------------
# ● 获取敌人 ID
#--------------------------------------------------------------------------
def id
return @enemy_id
end
#--------------------------------------------------------------------------
# ● 获取索引
#--------------------------------------------------------------------------
def index
return @member_index
end
#--------------------------------------------------------------------------
# ● 获取名称
#--------------------------------------------------------------------------
def name
return $data_enemies[@enemy_id].name
end
#--------------------------------------------------------------------------
# ● 获取基本 MaxHP
#--------------------------------------------------------------------------
def base_maxhp
return $data_enemies[@enemy_id].maxhp
end
#--------------------------------------------------------------------------
# ● 获取基本 MaxSP
#--------------------------------------------------------------------------
def base_maxsp
return $data_enemies[@enemy_id].maxsp
end
#--------------------------------------------------------------------------
# ● 获取基本力量
#--------------------------------------------------------------------------
def base_str
return $data_enemies[@enemy_id].str
end
#--------------------------------------------------------------------------
# ● 获取基本灵巧
#--------------------------------------------------------------------------
def base_dex
return $data_enemies[@enemy_id].dex
end
#--------------------------------------------------------------------------
# ● 获取基本速度
#--------------------------------------------------------------------------
def base_agi
return $data_enemies[@enemy_id].agi
end
#--------------------------------------------------------------------------
# ● 获取基本魔力
#--------------------------------------------------------------------------
def base_int
return $data_enemies[@enemy_id].int
end
#--------------------------------------------------------------------------
# ● 获取基本攻击力
#--------------------------------------------------------------------------
def base_atk
return $data_enemies[@enemy_id].atk
end
#--------------------------------------------------------------------------
# ● 获取基本物理防御
#--------------------------------------------------------------------------
def base_pdef
return $data_enemies[@enemy_id].pdef
end
#--------------------------------------------------------------------------
# ● 获取基本魔法防御
#--------------------------------------------------------------------------
def base_mdef
return $data_enemies[@enemy_id].mdef
end
#--------------------------------------------------------------------------
# ● 获取基本回避修正
#--------------------------------------------------------------------------
def base_eva
return $data_enemies[@enemy_id].eva
end
#--------------------------------------------------------------------------
# ● 普通攻击 获取攻击方动画 ID
#--------------------------------------------------------------------------
def animation1_id
return $data_enemies[@enemy_id].animation1_id
end
#--------------------------------------------------------------------------
# ● 普通攻击 获取对像方动画 ID
#--------------------------------------------------------------------------
def animation2_id
return $data_enemies[@enemy_id].animation2_id
end
#--------------------------------------------------------------------------
# ● 获取属性修正值
# element_id : 属性 ID
#--------------------------------------------------------------------------
def element_rate(element_id)
# 获取对应属性有效度的数值
table = [0,200,150,100,50,0,-100]
result = table[$data_enemies[@enemy_id].element_ranks[element_id]]
# 状态能防御本属性的情况下效果减半
for i in @states
if $data_states.guard_element_set.include?(element_id)
result /= 2
end
end
# 过程结束
return result
end
#--------------------------------------------------------------------------
# ● 获取属性有效度
#--------------------------------------------------------------------------
def state_ranks
return $data_enemies[@enemy_id].state_ranks
end
#--------------------------------------------------------------------------
# ● 属性防御判定
# state_id : 状态 ID
#--------------------------------------------------------------------------
def state_guard?(state_id)
return false
end
#--------------------------------------------------------------------------
# ● 获取普通攻击属性
#--------------------------------------------------------------------------
def element_set
return []
end
#--------------------------------------------------------------------------
# ● 获取普通攻击的状态变化 (+)
#--------------------------------------------------------------------------
def plus_state_set
return []
end
#--------------------------------------------------------------------------
# ● 获取普通攻击的状态变化 (-)
#--------------------------------------------------------------------------
def minus_state_set
return []
end
#--------------------------------------------------------------------------
# ● 获取行动
#--------------------------------------------------------------------------
def actions
return $data_enemies[@enemy_id].actions
end
#--------------------------------------------------------------------------
# ● 获取 EXP
#--------------------------------------------------------------------------
def exp
return rand($data_enemies[@enemy_id].exp) + 1
end
#--------------------------------------------------------------------------
# ● 获取金钱
#--------------------------------------------------------------------------
def gold
return rand($data_enemies[@enemy_id].gold) + 1
end
#--------------------------------------------------------------------------
# ● 获取物品 ID
#--------------------------------------------------------------------------
def item_id
return $data_enemies[@enemy_id].item_id
end
#--------------------------------------------------------------------------
# ● 获取武器 ID
#--------------------------------------------------------------------------
def weapon_id
return $data_enemies[@enemy_id].weapon_id
end
#--------------------------------------------------------------------------
# ● 获取防具 ID
#--------------------------------------------------------------------------
def armor_id
return $data_enemies[@enemy_id].armor_id
end
#--------------------------------------------------------------------------
# ● 获取宝物出现率
#--------------------------------------------------------------------------
def treasure_prob
return $data_enemies[@enemy_id].treasure_prob
end
#--------------------------------------------------------------------------
# ● 取得战斗画面 X 坐标
#--------------------------------------------------------------------------
def screen_x
return $data_troops[@troop_id].members[@member_index].x
end
#--------------------------------------------------------------------------
# ● 取得战斗画面 Y 坐标
#--------------------------------------------------------------------------
def screen_y
return $data_troops[@troop_id].members[@member_index].y + rand(5)
end
#--------------------------------------------------------------------------
# ● 取得战斗画面 Z 坐标
#--------------------------------------------------------------------------
def screen_z
return screen_y
end
#--------------------------------------------------------------------------
# ● 逃跑
#--------------------------------------------------------------------------
def escape
# 设置隐藏标志
@hidden = true
# 清除当前行动
self.current_action.clear
end
#--------------------------------------------------------------------------
# ● 变身
# enemy_id : 变身为的敌人 ID
#--------------------------------------------------------------------------
def transform(enemy_id)
# 更改敌人 ID
@enemy_id = enemy_id
# 更改战斗图形
@battler_name = $data_enemies[@enemy_id].battler_name
@battler_hue = $data_enemies[@enemy_id].battler_hue
# 再生成行动
make_action
end
#--------------------------------------------------------------------------
# ● 生成行动
#--------------------------------------------------------------------------
def make_action
# 清除当前行动
self.current_action.clear
# 无法行动的情况
unless self.movable?
# 过程结束
return
end
# 抽取现在有效的行动
available_actions = []
rating_max = 0
for action in self.actions
# 确认回合条件
n = $game_temp.battle_turn
a = action.condition_turn_a
b = action.condition_turn_b
if (b == 0 and n != a) or
(b > 0 and (n < 1 or n < a or n % b != a % b))
next
end
# 确认 HP 条件
if self.hp * 100.0 / self.maxhp > action.condition_hp
next
end
# 确认等级条件
if $game_party.max_level < action.condition_level
next
end
# 确认开关条件
switch_id = action.condition_switch_id
if switch_id > 0 and $game_switches[switch_id] == false
next
end
# 符合条件 : 添加本行动
available_actions.push(action)
if action.rating > rating_max
rating_max = action.rating
end
end
# 最大概率值作为 3 合计计算(0 除外)
ratings_total = 0
for action in available_actions
if action.rating > rating_max - 3
ratings_total += action.rating - (rating_max - 3)
end
end
# 概率合计不为 0 的情况下
if ratings_total > 0
# 生成随机数
value = rand(ratings_total)
# 设置对应生成随机数的当前行动
for action in available_actions
if action.rating > rating_max - 3
if value < action.rating - (rating_max - 3)
self.current_action.kind = action.kind
self.current_action.basic = action.basic
self.current_action.skill_id = action.skill_id
self.current_action.decide_random_target_for_enemy
return
else
value -= action.rating - (rating_max - 3)
end
end
end
end
end
end
#==============================================================================
# ■ Game_Party
#------------------------------------------------------------------------------
# 处理同伴的类。包含金钱以及物品的信息。本类的实例
# 请参考 $game_party。
#==============================================================================
class Game_Party
#--------------------------------------------------------------------------
# ● 定义实例变量
#--------------------------------------------------------------------------
attr_reader :actors # 角色
attr_reader :gold # 金钱
attr_reader :steps # 步数
#--------------------------------------------------------------------------
# ● 初始化对像
#--------------------------------------------------------------------------
def initialize
# 建立角色序列
@actors = []
# 初始化金钱与步数
@gold = rand(2000) + 1
@steps = 0
# 生成物品、武器、防具的所持数 hash
@items = {}
@weapons = {}
@armors = {}
end
#--------------------------------------------------------------------------
# ● 设置初期同伴
#--------------------------------------------------------------------------
def setup_starting_members
@actors = []
for i in $data_system.party_members
@actors.push($game_actors)
end
end
#--------------------------------------------------------------------------
# ● 设置战斗测试用同伴
#--------------------------------------------------------------------------
def setup_battle_test_members
@actors = []
for battler in $data_system.test_battlers
actor = $game_actors[battler.actor_id]
actor.level = battler.level
gain_weapon(battler.weapon_id, 1)
gain_armor(battler.armor1_id, 1)
gain_armor(battler.armor2_id, 1)
gain_armor(battler.armor3_id, 1)
gain_armor(battler.armor4_id, 1)
actor.equip(0, battler.weapon_id)
actor.equip(1, battler.armor1_id)
actor.equip(2, battler.armor2_id)
actor.equip(3, battler.armor3_id)
actor.equip(4, battler.armor4_id)
actor.recover_all
@actors.push(actor)
end
@items = {}
for i in 1...$data_items.size
if $data_items.name != ""
occasion = $data_items.occasion
if occasion == 0 or occasion == 1
@items = 99
end
end
end
end
#--------------------------------------------------------------------------
# ● 同伴成员的还原
#--------------------------------------------------------------------------
def refresh
# 游戏数据载入后角色对像直接从 $game_actors
# 分离。
# 回避由于载入造成的角色再设置的问题。
new_actors = []
for i in
[email protected]
if $data_actors[@actors.id] != nil
new_actors.push($game_actors[@actors.id])
end
end
@actors = new_actors
end
#--------------------------------------------------------------------------
# ● 获取最大等级
#--------------------------------------------------------------------------
def max_level
# 同伴人数为 0 的情况下
if @actors.size == 0
return 0
end
# 初始化本地变量 level
level = 0
# 求得同伴的最大等级
for actor in @actors
if level < actor.level
level = actor.level
end
end
return level
end
#--------------------------------------------------------------------------
# ● 加入同伴
# actor_id : 角色 ID
#--------------------------------------------------------------------------
def add_actor(actor_id)
# 获取角色
actor = $game_actors[actor_id]
# 同伴人数未满 4 人、本角色不在队伍中的情况下
if @actors.size < 4 and not @actors.include?(actor)
# 添加角色
@actors.push(actor)
# 还原主角
$game_player.refresh
end
end
#--------------------------------------------------------------------------
# ● 角色离开
# actor_id : 角色 ID
#--------------------------------------------------------------------------
def remove_actor(actor_id)
# 删除角色
@actors.delete($game_actors[actor_id])
# 还原主角
$game_player.refresh
end
#--------------------------------------------------------------------------
# ● 增加金钱 (减少)
# n : 金额
#--------------------------------------------------------------------------
def gain_gold(n)
@gold = [[@gold + n, 0].max, 9999999].min
end
#--------------------------------------------------------------------------
# ● 减少金钱
# n : 金额
#--------------------------------------------------------------------------
def lose_gold(n)
# 调用数值逆转 gain_gold
gain_gold(-n)
end
#--------------------------------------------------------------------------
# ● 增加步数
#--------------------------------------------------------------------------
def increase_steps
@steps = [@steps + 1, 9999999].min
end
#--------------------------------------------------------------------------
# ● 获取物品的所持数
# item_id : 物品 ID
#--------------------------------------------------------------------------
def item_number(item_id)
# 如果 hash 个数数值不存在就返回 0
return @items.include?(item_id) ? @items[item_id] : 0
end
#--------------------------------------------------------------------------
# ● 获取武器所持数
# weapon_id : 武器 ID
#--------------------------------------------------------------------------
def weapon_number(weapon_id)
# 如果 hash 个数数值不存在就返回 0
return @weapons.include?(weapon_id) ? @weapons[weapon_id] : 0
end
#--------------------------------------------------------------------------
# ● 获取防具所持数
# armor_id : 防具 ID
#--------------------------------------------------------------------------
def armor_number(armor_id)
# 如果 hash 个数数值不存在就返回 0
return @armors.include?(armor_id) ? @armors[armor_id] : 0
end
#--------------------------------------------------------------------------
# ● 增加物品 (减少)
# item_id : 物品 ID
# n : 个数
#--------------------------------------------------------------------------
def gain_item(item_id, n)
# 更新 hash 的个数数据
if item_id > 0
@items[item_id] = [[item_number(item_id) + n, 0].max, 99].min
end
end
#--------------------------------------------------------------------------
# ● 增加武器 (减少)
# weapon_id : 武器 ID
# n : 个数
#--------------------------------------------------------------------------
def gain_weapon(weapon_id, n)
# 更新 hash 的个数数据
if weapon_id > 0
@weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, 99].min
end
end
#--------------------------------------------------------------------------
# ● 增加防具 (减少)
# armor_id : 防具 ID
# n : 个数
#--------------------------------------------------------------------------
def gain_armor(armor_id, n)
# 更新 hash 的个数数据
if armor_id > 0
@armors[armor_id] = [[armor_number(armor_id) + n, 0].max, 99].min
end
end
#--------------------------------------------------------------------------
# ● 减少物品
# item_id : 物品 ID
# n : 个数
#--------------------------------------------------------------------------
def lose_item(item_id, n)
# 调用 gain_item 的数值逆转
gain_item(item_id, -n)
end
#--------------------------------------------------------------------------
# ● 减少武器
# weapon_id : 武器 ID
# n : 个数
#--------------------------------------------------------------------------
def lose_weapon(weapon_id, n)
# 调用 gain_weapon 的数值逆转
gain_weapon(weapon_id, -n)
end
#--------------------------------------------------------------------------
# ● 减少防具
# armor_id : 防具 ID
# n : 个数
#--------------------------------------------------------------------------
def lose_armor(armor_id, n)
# 调用 gain_armor 的数值逆转
gain_armor(armor_id, -n)
end
#--------------------------------------------------------------------------
# ● 判断物品可以使用
# item_id : 物品 ID
#--------------------------------------------------------------------------
def item_can_use?(item_id)
# 物品个数为 0 的情况
if item_number(item_id) == 0
# 不能使用
return false
end
# 获取可以使用的时候
occasion = $data_items[item_id].occasion
# 战斗的情况
if $game_temp.in_battle
# 可以使用时为 0 (平时) 或者是 1 (战斗时) 可以使用
return (occasion == 0 or occasion == 1)
end
# 可以使用时为 0 (平时) 或者是 2 (菜单时) 可以使用
return (occasion == 0 or occasion == 2)
end
#--------------------------------------------------------------------------
# ● 清除全体的行动
#--------------------------------------------------------------------------
def clear_actions
# 清除全体同伴的行为
for actor in @actors
actor.current_action.clear
end
end
#--------------------------------------------------------------------------
# ● 可以输入命令的判定
#--------------------------------------------------------------------------
def inputable?
# 如果一可以输入命令就返回 true
for actor in @actors
if actor.inputable?
return true
end
end
return false
end
#--------------------------------------------------------------------------
# ● 全灭判定
#--------------------------------------------------------------------------
def all_dead?
# 同伴人数为 0 的情况下
if $game_party.actors.size == 0
return false
end
# 同伴中无人 HP 在 0 以上
for actor in @actors
if actor.hp > 0
return false
end
end
# 全灭
return true
end
#--------------------------------------------------------------------------
# ● 检查连续伤害 (地图用)
#--------------------------------------------------------------------------
def check_map_slip_damage
for actor in @actors
if actor.hp > 0 and actor.slip_damage?
actor.hp -= [actor.maxhp / 100, 1].max
if actor.hp == 0
$game_system.se_play($data_system.actor_collapse_se)
end
$game_screen.start_flash(Color.new(255,0,0,128), 4)
$game_temp.gameover = $game_party.all_dead?
end
end
end
#--------------------------------------------------------------------------
# ● 对像角色的随机确定
# hp0 : 限制为 HP 0 的角色
#--------------------------------------------------------------------------
def random_target_actor(hp0 = false)
# 初始化轮流
roulette = []
# 循环
for actor in @actors
# 符合条件的场合
if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)
# 获取角色职业的位置 [位置]
position = $data_classes[actor.class_id].position
# 前卫的话 n = 4、中卫的话 n = 3、后卫的话 n = 2
n = 4 - position
# 添加角色的轮流 n 回
n.times do
roulette.push(actor)
end
end
end
# 轮流大小为 0 的情况
if roulette.size == 0
return nil
end
# 转轮盘赌，决定角色
return roulette[rand(roulette.size)]
end
#--------------------------------------------------------------------------
# ● 对像角色的随机确定 (HP 0)
#--------------------------------------------------------------------------
def random_target_actor_hp0
return random_target_actor(true)
end
#--------------------------------------------------------------------------
# ● 对像角色的顺序确定
# actor_index : 角色索引
#--------------------------------------------------------------------------
def smooth_target_actor(actor_index)
# 取得对像
actor = @actors[actor_index]
# 对像存在的情况下
if actor != nil and actor.exist?
return actor
end
# 循环
for actor in @actors
# 对像存在的情况下
if actor.exist?
return actor
end
end
end
end
module PLAN_HPSP_DRAW
FONT_NAME = ["黑体", "楷体", "宋体"] # フォント
FONT_SIZE = 14 # フォントサイズ
FONT_BOLD = true # 太字
FONT_ITALIC = true # 斜体
DRAW_NAME = false # 名前の描画
DRAW_HP = true # HP の描画
DRAW_SP = true # SP の描画
DRAW_WIDTH = 80 # 描画幅
DRAW_HEIGHT = 3 * 32 # 描画高さ
DRAW_SPACE = 0 # 行間
DRAW_Y = 36 # Y 座標修正値
end
#==============================================================================
# ■ Sprite_Battler
#==============================================================================
class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_initialize initialize
def initialize(viewport, battler = nil)
# 元のメソッドに戻す
plan_enemy_hpsp_draw_initialize(viewport, battler)
# エネミーの場合
if @battler.is_a?(Game_Enemy)
width = PLAN_HPSP_DRAW::DRAW_WIDTH + 32
height = PLAN_HPSP_DRAW::DRAW_HEIGHT + 32
x = @battler.screen_x - width / 2
y = @battler.screen_y - height + 32 + PLAN_HPSP_DRAW::DRAW_Y
@enemy_hpsp_window = Window_Base.new(x, y, width, height)
@enemy_hpsp_window.contents = Bitmap.new(width - 32, height - 32)
@enemy_hpsp_window.contents.font.name = PLAN_HPSP_DRAW::FONT_NAME
@enemy_hpsp_window.contents.font.size = PLAN_HPSP_DRAW::FONT_SIZE
@enemy_hpsp_window.contents.font.bold = PLAN_HPSP_DRAW::FONT_BOLD
@enemy_hpsp_window.contents.font.italic = PLAN_HPSP_DRAW::FONT_ITALIC
y = 0
@old_enemy_hpsp = []
one_line = ((PLAN_HPSP_DRAW::FONT_SIZE * 100 / 28) * 32) / 100
if PLAN_HPSP_DRAW::DRAW_NAME
@enemy_hpsp_window.draw_actor_name(@battler, 0, y, width - 32)
y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
@old_enemy_hpsp.push(@battler.name)
end
if PLAN_HPSP_DRAW::DRAW_HP
@enemy_hpsp_window.draw_actor_hp2222(@battler, 0, y, width - 32)
y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
@old_enemy_hpsp.push(@battler.hp)
end
if PLAN_HPSP_DRAW::DRAW_SP
@enemy_hpsp_window.draw_actor_sp2222(@battler, 0, y, width - 32)
@old_enemy_hpsp.push(@battler.sp)
end
@enemy_hpsp_window.opacity = 0
@enemy_hpsp_window.contents_opacity = 0
@enemy_hpsp_window.z = -2
end
end
#--------------------------------------------------------------------------
# ● 解放
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_dispose dispose
def dispose
# エネミーの場合
if @battler.is_a?(Game_Enemy)
@enemy_hpsp_window.dispose
end
# 元のメソッドに戻す
plan_enemy_hpsp_draw_dispose
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_update update
def update
# 元のメソッドに戻す
plan_enemy_hpsp_draw_update
# エネミーの場合
if @battler.is_a?(Game_Enemy)
@enemy_hpsp_window.visible = @battler_visible
# スプライトの座標を設定
width = PLAN_HPSP_DRAW::DRAW_WIDTH + 32
@enemy_hpsp_window.x = self.x - width / 2
@now_enemy_hpsp = []
if PLAN_HPSP_DRAW::DRAW_NAME
@now_enemy_hpsp.push(@battler.name)
end
if PLAN_HPSP_DRAW::DRAW_HP
@now_enemy_hpsp.push(@battler.hp)
end
if PLAN_HPSP_DRAW::DRAW_SP
@now_enemy_hpsp.push(@battler.sp)
end
if @old_enemy_hpsp != @now_enemy_hpsp and $game_temp.enemy_hpsp_refresh
@old_enemy_hpsp = @now_enemy_hpsp
@enemy_hpsp_window.contents.clear
y = 0
width = PLAN_HPSP_DRAW::DRAW_WIDTH + 32
one_line = ((PLAN_HPSP_DRAW::FONT_SIZE * 100 / 28) * 32) / 100
if PLAN_HPSP_DRAW::DRAW_NAME
@enemy_hpsp_window.draw_actor_name(@battler, 0, y, width - 32)
y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
end
if PLAN_HPSP_DRAW::DRAW_HP
@enemy_hpsp_window.draw_actor_hp2222(@battler, 0, y, width - 32)
y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
end
if PLAN_HPSP_DRAW::DRAW_SP
@enemy_hpsp_window.draw_actor_sp2222(@battler, 0, y, width - 32)
end
Graphics.frame_reset
end
end
end
#--------------------------------------------------------------------------
# ● visible の設定
#--------------------------------------------------------------------------
if !method_defined?("plan_enemy_hpsp_draw_visible=")
alias plan_enemy_hpsp_draw_visible= visible=
end
def visible=(bool)
# エネミーの場合
if @battler.is_a?(Game_Enemy)
@enemy_hpsp_window.visible = bool
end
# 元のメソッドに戻す
self.plan_enemy_hpsp_draw_visible=(bool)
end
#--------------------------------------------------------------------------
# ● 不透明度の設定
#--------------------------------------------------------------------------
if !method_defined?("plan_enemy_hpsp_draw_opacity=")
alias plan_enemy_hpsp_draw_opacity= opacity=
end
def opacity=(n)
# 元のメソッドに戻す
self.plan_enemy_hpsp_draw_opacity=(n)
# エネミーの場合
if @battler.is_a?(Game_Enemy)
@enemy_hpsp_window.contents_opacity = n
end
end
end
#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :enemy_hpsp_refresh
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_initialize initialize
def initialize
# 元のメソッドに戻す
plan_enemy_hpsp_draw_initialize
@enemy_hpsp_refresh = false
end
end
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
# ● プレバトルフェーズ開始 (エネミー名＋アルファベット用)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_start_phase1 start_phase1
def start_phase1
$game_temp.enemy_hpsp_refresh = true
# 元のメソッドに戻す
plan_enemy_hpsp_draw_start_phase1
end
#--------------------------------------------------------------------------
# ● パーティコマンドフェーズ開始 (エネミー名＋アルファベット用)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_start_phase2 start_phase2
def start_phase2
$game_temp.enemy_hpsp_refresh = false
# 元のメソッドに戻す
plan_enemy_hpsp_draw_start_phase2
end
#--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズ ステップ 5 : ダメージ表示)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_update_phase4_step5 update_phase4_step5
def update_phase4_step5
# 元のメソッドに戻す
plan_enemy_hpsp_draw_update_phase4_step5
$game_temp.enemy_hpsp_refresh = true
end
#--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_update_phase4_step6 update_phase4_step6
def update_phase4_step6
# 元のメソッドに戻す
plan_enemy_hpsp_draw_update_phase4_step6
$game_temp.enemy_hpsp_refresh = false
end
end
#==============================================================================
# ■ Window_Base
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# ● 名前の描画
#--------------------------------------------------------------------------
def draw_actor_name(actor, x, y, width = 120, align = 0)
self.contents.font.color = normal_color
align = 1 if $scene.is_a?(Scene_Battle)
self.contents.draw_text(x, y, width, 32, actor.name, align)
end
#--------------------------------------------------------------------------
# ● ステートの描画
#--------------------------------------------------------------------------
def draw_actor_state(actor, x, y, width = 120)
# 元のメソッドに戻す
text = make_battler_state_text(actor, width, true)
self.contents.draw_text(x, y, width, 32, text, 1)
end
end
class Window_Base < Window
def draw_actor_hp2222(actor, x, y, width = 100, height=8)
y+=3
olx = x
oly = y
w = width * actor.hp / [actor.maxhp,1].max
hp_color_1 = Color.new(255, 0, 0, 192)
hp_color_2 = Color.new(255, 255, 0, 192)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x = olx
y = oly-14
# 描绘字符串 "HP"
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 32, $data_system.words.hp)
# 计算描绘 MaxHP 所需的空间
if width - 32 >= 108
hp_x = x + width - 108
flag = true
elsif width - 32 >= 48
hp_x = x + width - 48
flag = false
end
# 描绘 HP
self.contents.font.color = actor.hp == 0 ? knockout_color :
actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
self.contents.draw_text(hp_x, y, 48, 32, actor.hp.to_s, 2)
# 描绘 MaxHP
if flag
self.contents.font.color = normal_color
self.contents.draw_text(hp_x + 48, y, 12, 32, "/", 1)
self.contents.draw_text(hp_x + 60, y, 48, 32, actor.maxhp.to_s)
end
end
def draw_actor_sp2222(actor, x, y, width = 100, height = 8)
y+=3
olx = x
oly = y
w = width * actor.sp / [actor.maxsp,1].max
hp_color_1 = Color.new( 0, 0, 255, 192)
hp_color_2 = Color.new( 0, 255, 255, 192)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x = olx
y = oly-14
# 描绘字符串 "SP"
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 32, $data_system.words.sp)
# 计算描绘 MaxSP 所需的空间
if width - 32 >= 108
sp_x = x + width - 108
flag = true
elsif width - 32 >= 48
sp_x = x + width - 48
flag = false
end
# 描绘 SP
self.contents.font.color = actor.sp == 0 ? knockout_color :
actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
self.contents.draw_text(sp_x, y, 48, 32, actor.sp.to_s, 2)
# 描绘 MaxSP
if flag
self.contents.font.color = normal_color
self.contents.draw_text(sp_x + 48, y, 12, 32, "/", 1)
self.contents.draw_text(sp_x + 60, y, 48, 32, actor.maxsp.to_s)
end
end
#--------------------------------------------------------------------------
# ● ライン描画 by 桜雅 在土
#--------------------------------------------------------------------------
def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)
# 描写距離の計算。大きめに直角時の長さ。
distance = (start_x - end_x).abs + (start_y - end_y).abs
# 描写開始
if end_color == start_color
for i in 1..distance
x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
if width == 1
self.contents.set_pixel(x, y, start_color)
else
self.contents.fill_rect(x, y, width, width, start_color)
end
end
else
for i in 1..distance
x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
r = start_color.red * (distance-i)/distance + end_color.red * i/distance
g = start_color.green * (distance-i)/distance + end_color.green * i/distance
b = start_color.blue * (distance-i)/distance + end_color.blue * i/distance
a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance
if width == 1
self.contents.set_pixel(x, y, Color.new(r, g, b, a))
else
self.contents.fill_rect(x, y, width, width, Color.new(r, g, b, a))
end
end
end
end
end
class Window_Help < Window_Base
def set_enemy(actor)
self.contents.clear
draw_actor_name(actor, 4, 0)
draw_actor_state(actor, 140, 0)
carol3_draw_hp_bar(actor, 284, 0)
carol3_draw_sp_bar(actor, 460, 0)
@text = nil
self.visible = true
end
def carol3_draw_hp_bar(actor, x, y, width = 128) #宽度可调，建议不要改。
self.contents.font.color = system_color
w = width * actor.hp / [actor.maxhp,1].max
if actor.maxhp != 0
rate = actor.hp.to_f / actor.maxhp
else
rate = 0
end
color1 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 150)
self.contents.fill_rect(x+1, y+15, width+2,1, Color.new(0, 0, 0, 255))
self.contents.fill_rect(x+1, y+16, width+2,1, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x+1, y+17, w,6,color1)
self.contents.fill_rect(x+1, y+23, width+2,1, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x+1, y+24, width+2,1, Color.new(0, 0, 0, 255))
self.contents.fill_rect(x, y+16, 1,8, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x-1, y+15, 1,10, Color.new(0, 0, 0, 255))
self.contents.fill_rect(x+129, y+16, 1,8, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x+130, y+15, 1,10, Color.new(0, 0, 0, 255))
self.contents.draw_text(x-53,y,128,32,$data_system.words.hp,1)
if actor.hp>actor.maxhp/3
self.contents.font.color = Color.new(255, 255, 255, 250)
end
if actor.hp>=actor.maxhp/6 and actor.maxhp/3>actor.hp
self.contents.font.color = Color.new(200, 200, 0, 255)
end
if actor.maxhp/6>actor.hp
self.contents.font.color = Color.new(200, 0, 0, 255)
end
self.contents.draw_text(x+47,y,128,32,actor.hp.to_s,1)
end
def carol3_draw_sp_bar(actor, x, y, width = 128)
self.contents.font.color = system_color
if actor.maxsp != 0
rate = actor.sp.to_f / actor.maxsp
else
rate = 0
end
color2 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
w = width * actor.sp / [actor.maxsp,1].max
self.contents.fill_rect(x+1, y+15, width+2,1, Color.new(0, 0, 0, 255))
self.contents.fill_rect(x+1, y+16, width+2,1, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x+1, y+17, w,6,color2)
self.contents.fill_rect(x+1, y+23, width+2,1, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x+1, y+24, width+2,1, Color.new(0, 0, 0, 255))
self.contents.fill_rect(x, y+16, 1,8, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x-1, y+15, 1,10, Color.new(0, 0, 0, 255))
self.contents.fill_rect(x+129, y+16, 1,8, Color.new(255, 255, 192, 192))
self.contents.fill_rect(x+130, y+15, 1,10, Color.new(0, 0, 0, 255))
self.contents.draw_text(x-53,y,128,32,$data_system.words.sp,1)
if actor.hp>actor.maxsp/3
self.contents.font.color = Color.new(255, 255, 255, 250)
end
if actor.hp>=actor.maxsp/6 and actor.maxsp/3>actor.sp
self.contents.font.color = Color.new(200, 200, 0, 255)
end
if actor.maxsp/6>actor.sp
self.contents.font.color = Color.new(200, 0, 0, 255)
end
self.contents.draw_text(x+47,y,128,32,actor.sp.to_s,1)
end
end
#==============================================================================
# ■ Window_Item
#------------------------------------------------------------------------------
# 物品画面、战斗画面、显示浏览物品的窗口。
#==============================================================================
class Window_Item < Window_Selectable
#--------------------------------------------------------------------------
# ● 刷新
#--------------------------------------------------------------------------
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
@data = []
# 在战斗中以外添加武器、防具
unless $game_temp.in_battle
# 添加报务
for i in 1...$data_items.size
if $game_party.item_number(i) > 0
@data.push($data_items)
end
end
for i in 1...$data_weapons.size
if $game_party.weapon_number(i) > 0
@data.push($data_weapons)
end
end
for i in 1...$data_armors.size
if $game_party.armor_number(i) > 0
@data.push($data_armors)
end
end
else
for i in 1...$data_items.size
if $game_party.item_number(i) > 0
occasion = $data_items.occasion
if occasion == 0 or occasion == 1
@data.push($data_items)
end
end
end
end
# 如果项目数不是 0 就生成位图、重新描绘全部项目
@item_max = @data.size
if @item_max > 0
self.contents = Bitmap.new(width - 32, row_max * 32)
for i in 0...@item_max
draw_item(i)
end
end
end
end
#===============================================================
# 本脚本来自www.66RPG.com，使用和转载请保留此信息
#===============================================================
# ——————————————————————————————
# HP/SP/EXPゲージ表示スクリプト Ver 1.00
# 配布元?サポートURL
# http://members.jcom.home.ne.jp/cogwheel/
#===============================================================
# ■ Game_Actor
#--------------------------------------------------------
# アクターを扱うクラスです。このクラスは Game_Actors クラス ($game_actors)
# の内部で使用され、Game_Party クラス ($game_party) からも参照されます。
#==============================================================
class Game_Actor < Game_Battler
def now_exp
return @exp - @exp_list[@level]
end
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end
#==========================================================
# ■ Window_Base
#------------------------------------------------------------
# ゲーム中のすべてのウィンドウのスーパークラスです。
#============================================================
class Window_Base < Window
#--------------------------------------------------------
# ● HP ゲージの描画
#--------------------------------------------------
# オリジナルのHP描画を draw_actor_hp_original と名前変更
alias :draw_actor_hp_original :draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
# 変数rateに 現在のHP/MHPを代入
if actor.maxhp != 0
rate = actor.hp.to_f / actor.maxhp
else
rate = 0
end
# plus_x:X座標の位置補正 rate_x:X座標の位置補正(%) plus_y:Y座標の位置補正
# plus_width:幅の補正 rate_width:幅の補正(%) height:縦幅
# align1:描画タイプ1 0:左詰め 1:中央揃え 2:右詰め
# align2:描画タイプ2 0:上詰め 1:中央揃え 2:下詰め
# align3:ゲージタイプ 0:左詰め 1:右詰め
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# グラデーション設定 grade1:空ゲージ grade2:実ゲージ
# (0:横にグラデーション 1:縦にグラデーション 2:斜めにグラデーション(激重)）
grade1 = 1
grade2 = 0
# 色設定。color1:外枠，color2:中枠
# color3:空ゲージダークカラー，color4:空ゲージライトカラー
# color5:実ゲージダークカラー，color6:実ゲージライトカラー
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
# 変数spに描画するゲージの幅を代入
if actor.maxhp != 0
hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
else
hp = 0
end
# ゲージの描画
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, hp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# オリジナルのHP描画処理を呼び出し
draw_actor_hp_original(actor, x, y, width)
end
#--------------------------------------------------------------
# ● SP ゲージの描画
#------------------------------------------------------------
# オリジナルのSP描画を draw_actor_sp_original と名前変更
alias :draw_actor_sp_original :draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
# 変数rateに 現在のSP/MSPを代入
if actor.maxsp != 0
rate = actor.sp.to_f / actor.maxsp
else
rate = 1
end
# plus_x:X座標の位置補正 rate_x:X座標の位置補正(%) plus_y:Y座標の位置補正
# plus_width:幅の補正 rate_width:幅の補正(%) height:縦幅
# align1:描画タイプ1 0:左詰め 1:中央揃え 2:右詰め
# align2:描画タイプ2 0:上詰め 1:中央揃え 2:下詰め
# align3:ゲージタイプ 0:左詰め 1:右詰め
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# グラデーション設定 grade1:空ゲージ grade2:実ゲージ
# (0:横にグラデーション 1:縦にグラデーション 2:斜めにグラデーション(激重)）
grade1 = 1
grade2 = 0
# 色設定。color1:外枠，color2:中枠
# color3:空ゲージダークカラー，color4:空ゲージライトカラー
# color5:実ゲージダークカラー，color6:実ゲージライトカラー
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 0, 192)
color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
# 変数spに描画するゲージの幅を代入
if actor.maxsp != 0
sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
else
sp = (width + plus_width) * rate_width / 100
end
# ゲージの描画
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, sp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# オリジナルのSP描画処理を呼び出し
draw_actor_sp_original(actor, x, y, width)
end
#--------------------------------------------------------
# ● EXP ゲージの描画
#----------------------------------------------------------
# オリジナルのEXP描画を draw_actor_sp_original と名前変更
alias :draw_actor_exp_original :draw_actor_exp
def draw_actor_exp(actor, x, y, width = 204)
# 変数rateに 現在のexp/nextexpを代入
if actor.next_exp != 0
rate = actor.now_exp.to_f / actor.next_exp
else
rate = 1
end
# plus_x:X座標の位置補正 rate_x:X座標の位置補正(%) plus_y:Y座標の位置補正
# plus_width:幅の補正 rate_width:幅の補正(%) height:縦幅
# align1:描画タイプ1 0:左詰め 1:中央揃え 2:右詰め
# align2:描画タイプ2 0:上詰め 1:中央揃え 2:下詰め
# align3:ゲージタイプ 0:左詰め 1:右詰め
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# グラデーション設定 grade1:空ゲージ grade2:実ゲージ
# (0:横にグラデーション 1:縦にグラデーション 2:斜めにグラデーション(激重)）
grade1 = 1
grade2 = 0
# 色設定。color1:外枠，color2:中枠
# color3:空ゲージダークカラー，color4:空ゲージライトカラー
# color5:実ゲージダークカラー，color6:実ゲージライトカラー
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
# 変数expに描画するゲージの幅を代入
if actor.next_exp != 0
exp = (width + plus_width) * actor.now_exp * rate_width /
100 / actor.next_exp
else
exp = (width + plus_width) * rate_width / 100
end
# ゲージの描画
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, exp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# オリジナルのEXP描画処理を呼び出し
draw_actor_exp_original(actor, x, y)
end
#---------------------------------------------------------
# ● ゲージの描画
#-----------------------------------------------------
def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
case align1
when 1
x += (rect_width - width) / 2
when 2
x += rect_width - width
end
case align2
when 1
y -= height / 2
when 2
y -= height
end
# 枠描画
self.contents.fill_rect(x, y, width, height, color1)
self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
if align3 == 0
if grade1 == 2
grade1 = 3
end
if grade2 == 2
grade2 = 3
end
end
if (align3 == 1 and grade1 == 0) or grade1 > 0
color = color3
color3 = color4
color4 = color
end
if (align3 == 1 and grade2 == 0) or grade2 > 0
color = color5
color5 = color6
color6 = color
end
# 空ゲージの描画
self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
color3, color4, grade1)
if align3 == 1
x += width - gauge
end
# 実ゲージの描画
self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
color5, color6, grade2)
end
end
#--------------------------------------------------------------
# Bitmapクラスに新たな機能を追加します。
#===================================================================
class Bitmap
#------------------------------------------------------------
# ● 矩形をグラデーション表示
# color1 : スタートカラー
# color2 : エンドカラー
# align : 0:横にグラデーション
# 1:縦にグラデーション
# 2:斜めにグラデーション（激重につき注意）
#--------------------------------------------------------
def gradation_rect(x, y, width, height, color1, color2, align = 0)
if align == 0
for i in x...x + width
red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
green = color1.green +
(color2.green - color1.green) * (i - x) / (width - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - x) / (width - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - x) / (width - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(i, y, 1, height, color)
end
elsif align == 1
for i in y...y + height
red = color1.red +
(color2.red - color1.red) * (i - y) / (height - 1)
green = color1.green +
(color2.green - color1.green) * (i - y) / (height - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - y) / (height - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - y) / (height - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(x, i, width, 1, color)
end
elsif align == 2
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
elsif align == 3
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
end
end
end
################################################################################
#STUPID PIG工作室里面的人不是笨猪，而是一群追逐梦想的年轻人！~~
################################################################################
复制代码
作者:
杀人神经婆
时间:
2012-7-20 14:22
综合站都处理是什么意思？
作者:
忧雪の伤
时间:
2012-7-20 17:49
本帖最后由 忧雪の伤 于 2012-7-20 17:52 编辑
本脚本由STUPID PIG工作室自行研制，其制作权归本工作室所有，当然大家可以尽情的
#使用，但是所有的备注都不能删除
UI> 先不说你把默认的脚本全部复制了一遍（包括没有进行改动的），冲突率大，长度大，然后后面一大段还是其他人写的……还自行研制……别笑死我了……
作者:
不如归去
时间:
2012-7-20 17:54
既然是自行研制，麻烦解释一下后面的日文注释是怎么回事可以么？还是说写日文出来装逼？
2586
#--------------------------------------------------------------------------
# ● ライン描画 by 桜雅 在土
#--------------------------------------------------------------------------
复制代码
此外，也太看不起自加密了吧？
作者:
serena718
时间:
2012-7-20 18:22
能否用別名之類的方法整合下？
不然這樣衝突率很高，而且似乎只支援默認系統，
這樣弄不如你把算法的部分獨立出來，讓大家自行整合算了……
作者:
stevenrock
时间:
2012-7-21 13:20
整合系统是个相当枯燥的工作，虽然鄙人表示估计不会用，我还是理解LZ你，再接再厉吧。
作者:
f26401004
时间:
2012-7-21 17:32
不過貌似還有日站的腳本，這樣真的可以算是自行研製的嗎？
作者:
我本将心向明月
时间:
2012-7-31 22:13
枯燥乏味。。。我晕了
‘‘──我本将心向明月于2012-7-31 22:13补充以下内容：
枯燥。。。。乏味。。晕了。。
’’
作者:
958801
时间:
2016-7-12 14:22
用不起啊！！！！！！
欢迎光临 Project1 (https://rpg.blue/)
Powered by Discuz! X3.1
