同一角色不同种类的SP分开使用(13楼做出第二次改进版)

雪流星 · 发表于 2008-5-31 12:39:34

如果能的话
请楼主顺便制作一个VX版的吧

越前リョーマ · 发表于 2008-5-31 16:52:36

这个就是传说种的属性能量吧……

slick · 发表于 2009-6-12 08:00:00

这个系统已经作了第二次改进，使用方法如下：

武器类型定义方法：
　　譬如“钢之剑,600,0”意思是：名称为“钢之剑”的武器，决定了角色SP最大值为600，属性值为0（在本范例中该属性的意义为“格斗”），使用格斗系SP。
　　譬如“水之杖,1000,2”意思是：名称为“水之杖”的武器，决定了角色SP最大值为1000，属性值为2（在本范例中该属性的意义为“水”），使用水系SP。
　　其中第一个附带参数不能缺省。
　　第二个附带参数可以缺省，缺省设置为1，在本范例中是使用默认的格斗技SP。　
　　其他使用方法同“武器决定技能”。

改进版对物品的使用也做了调整：
　　譬如“火之滋补剂,0”意思是：名称为“火之滋补剂”的物品，附带参数设为0，对应第一种SP，本范例设定为使用后回复角色的炎属性SP。
　　譬如“普通滋补剂”意思是：名称为“普通滋补剂”的物品，因为一个附带参数缺省，故使用后回复角色当前正在使用的SP。
　　譬如“万能滋补剂,255”意思是：名称为“万能滋补剂”的物品，附带参数设为255，故使用后回复角色所有属性的SP。
万能SP回复物品的参数一定要设为255。

特别注意：
　　该脚本有一定冲突性，主要是SP使用、武器装备变更、以及血条描画方面等。

如果想要投宿住店时回复SP，请在事件调用中加上这个脚本：
for i in 0...$game_party.actors.size
  m=$game_party.actors.cta.size
  for j in 0...m
if j==$game_party.actors.akind
   k=$game_party.actors.cta[j]
   $game_party.actors.ammo[j]=k
else
   $game_party.actors.ammo[j]=9999
end
  end
end

呃。。。至于VX版的嘛。。。Ojz还请期待==|||

# 不同种类的SP分开用　改进版 V1.01 BY SLICK

module RPG

  class Weapon  # 武器名称所能决定SP种类及属性的定义方法(格式像这样：钢匕首,2000,0)

attr_accessor :w_maxsp

attr_accessor :w_akind

def name

   name = @name.split(/,/)[0]

   return name != nil ? name : ''

end

def w_maxsp

   w_maxsp = @name.split(/,/)[1]

   return w_maxsp != nil ? w_maxsp.to_i : 0

end

def w_akind

   w_akind = @name.split(/,/)[2]

   return w_akind != nil ? w_akind.to_i : 1

end

  end

  class Item  # 定义某种物品能回复哪种SP(格式像这样：普通滋补剂,0)

attr_accessor :i_rkind

def name

   name = @name.split(/,/)[0]

   return name != nil ? name : ''

end

def i_rkind

   i_rkind = @name.split(/,/)[1]

   return i_rkind != nil ? i_rkind.to_i : nil

end

  end

end

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                # スキル





#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

  attr_accessor :ammo                   # SP残留量

  attr_accessor :akind                   # 使用何种SP

  attr_accessor :cta                   # SP最大容量

#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝





  #--------------------------------------------------------------------------

  # ● セットアップ

  #    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

#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

@ammo = [0,0,0,0,0,0,0,0,0]#　目前只使用九种能量

@akind = 1 #　缺省情况下使用格斗技能量

@cta = [0,0,0,0,0,0,0,0,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

end

class Scene_Equip

  #--------------------------------------------------------------------------

  # ● 刷新画面 (右侧窗口被激活的情况下)

  #--------------------------------------------------------------------------

  def update_right

# 按下 B 键的情况下

if Input.trigger?(Input::B)

   # 演奏取消 SE

   $game_system.se_play($data_system.cancel_se)





#装备结束时再次判断一下属性SP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

   neomaxsp=0

   if @actor.weapon_id !=0

      @actor.akind=$data_weapons[@actor.weapon_id].w_akind

   end

   if @actor.weapon_id !=0

      neomaxsp+=$data_weapons[@actor.weapon_id].w_maxsp

   end

   @actor.cta[@actor.akind]=neomaxsp

   @actor.ammo[@actor.akind] = [$lammo[@actor.akind],@actor.cta[@actor.akind]].min#弹药种类相同取弹匣小值

#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝



   # 切换到菜单画面

   $scene = Scene_Menu.new(2)

   return

end

# 按下 C 键的情况下

if Input.trigger?(Input::C)

   # 固定装备的情况下

   if @actor.equip_fix?(@right_window.index)

      # 演奏冻结 SE

      $game_system.se_play($data_system.buzzer_se)

      return

   end

   # 演奏确定 SE

   $game_system.se_play($data_system.decision_se)

   # 激活物品窗口

   @right_window.active = false

   @item_window.active = true

   @item_window.index = 0





#开始装备武器时判断一下属性SP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

   $lkind = @actor.akind #弹药种类是否与以前相同？

   $lammo = []

   for ii in [email protected]

      $lammo[ii][email protected][ii]

   end

#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝





   return

end

# 按下 R 键的情况下

if Input.trigger?(Input::R)

   # 演奏光标 SE

   $game_system.se_play($data_system.cursor_se)

   # 移至下一位角色

   @actor_index += 1

   @actor_index %= $game_party.actors.size

   # 切换到别的装备画面

   $scene = Scene_Equip.new(@actor_index, @right_window.index)

   return

end

# 按下 L 键的情况下

if Input.trigger?(Input::L)

   # 演奏光标 SE

   $game_system.se_play($data_system.cursor_se)

   # 移至上一位角色

   @actor_index += $game_party.actors.size - 1

   @actor_index %= $game_party.actors.size

   # 切换到别的装备画面

   $scene = Scene_Equip.new(@actor_index, @right_window.index)

   return

end

  end

end

class Game_Battler

#--------------------------------------------------------------------------

SW_SET = [1,2,3,4,5,6,7,8,9] # 此处设定武器和技能关联的属性id

#--------------------------------------------------------------------------

def skill_can_use?(skill_id)

if self.is_a?(Game_Actor) and self.weapon_id > 0

   sw_boolean = false # 判断武器和技能关联

   s = SW_SET & $data_skills[skill_id].element_set

   if s.empty?

   sw_boolean = true

   else

   for i in s

      if  $data_weapons[self.weapon_id].element_set .include?(i)

         sw_boolean = true

         break

      end

   end

   end

   if sw_boolean == false

   return false

   end





#这里修改为对各种SP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

   current_sp=self.ammo[self.akind]

   current_maxsp=self.cta[self.akind]

#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝





   if $data_skills[skill_id].sp_cost > current_sp

   return false

   end

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

end

class Scene_Battle

  def make_skill_action_result

# 获取特技

@skill = $data_skills[@active_battler.current_action.skill_id]

# 如果不是强制行动

unless @active_battler.current_action.forcing

   # 因为 SP 耗尽而无法使用的情况下

   unless @active_battler.skill_can_use?(@skill.id)

      # 清除强制行动对像的战斗者

      $game_temp.forcing_battler = nil

      # 移至步骤 1

      @phase4_step = 1

      return

   end

end

# 消耗 SP（区分不同种类）＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

if @active_battler.is_a?(Game_Actor)

   @active_battler.ammo[@active_battler.akind] -= @skill.sp_cost

else

   @active_battler.sp -= @skill.sp_cost

end if

#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

# 刷新状态窗口

@status_window.refresh

# 在帮助窗口显示特技名

@help_window.set_text(@skill.name, 1)

# 设置动画 ID

@animation1_id = @skill.animation1_id

@animation2_id = @skill.animation2_id

# 设置公共事件 ID

@common_event_id = @skill.common_event_id

# 设置对像侧战斗者

set_target_battlers(@skill.scope)

# 应用特技效果

for target in @target_battlers

   target.skill_effect(@active_battler, @skill)

end

  end

end

#==============================================================================

# 物品对不同SP分别起作用

#==============================================================================

class Game_Battler

  #--------------------------------------------------------------------------

  # ● 应用物品效果

  #    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



#这里修改了对SP回复率的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

   recover_sp = self.cta[self.akind] * 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

   self.hp += recover_hp





#这里修改为对各种属性SP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

   if self.is_a?(Game_Actor)

      case item.i_rkind

      when 255 #对自己所有的SP都起作用

         for ii in 0...self.cta.size

            current_sp = self.ammo[ii]

            if ii==self.akind  #最大SP值的限制只对当前SP起作用

            current_maxsp=self.cta[ii]

            current_sp += recover_sp

            if current_sp > current_maxsp

               current_sp = current_maxsp

            end

            else

            current_sp += recover_sp

            end

            self.ammo[ii] = current_sp

         end

      when nil #对自己当前正在使用的SP起作用

         current_sp=self.ammo[self.akind]

         current_maxsp=self.cta[self.akind]  #最大SP值的限制只对当前SP起作用

         current_sp += recover_sp

         if current_sp > current_maxsp

            current_sp = current_maxsp

         end

         self.ammo[self.akind] = current_sp

      else    #对自己某种特定属性的SP起作用

         current_sp=self.ammo[item.i_rkind]

         current_sp += recover_sp

         self.ammo[item.i_rkind] = current_sp

      end

      last_sp = current_sp

      effective =true

   else

      last_sp = self.sp

      self.sp += recover_sp

      effective |= self.sp != last_sp

   end

# ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

   effective |= self.hp != last_hp

   # 状态变化

   @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 = "Miss"

      end

      end

   end

# Miss 的情况下

else

   # 伤害设置为 "Miss"

   self.damage = "Miss"

end

# 不在战斗中的情况下

unless $game_temp.in_battle

   # 伤害设置为 nil

   self.damage = nil

end

# 过程结束

return effective

  end

end

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

  #--------------------------------------------------------------------------

  # ● 描绘 SP

  #    actor : 角色

  #    x    : 描画目标 X 坐标

  #    y    : 描画目标 Y 坐标

  #    width : 描画目标的宽

  #--------------------------------------------------------------------------

  def draw_actor_sp(actor, x, y, width = 144)

# 描绘字符串 "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

current_sp=actor.ammo[actor.akind]

current_maxsp=actor.cta[actor.akind]

self.contents.font.color = current_sp == 0 ? knockout_color :

   current_sp <= current_maxsp / 4 ? crisis_color : normal_color

self.contents.draw_text(sp_x, y, 48, 32, current_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, current_maxsp.to_s)

end

  end

  #--------------------------------------------------------------------------

  # ● 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.cta[actor.akind]

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:実ゲージライトカラー

#区分SP属性的颜色＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

case actor.akind

   when 0 #　火

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(255, 192, 192, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(0, 64, 64, 192)

      color5 = Color.new(128 * rate, 0, 0, 192)

      color6 = Color.new(255 * rate, 0, 0, 192)

   when 3 #　水

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(192, 192, 255, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(64, 64, 0, 192)

      color5 = Color.new(0, 0, 128 * rate, 192)

      color6 = Color.new(0, 0, 255 * rate, 192)

   when 5 #　风

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(192, 255, 224, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(64, 0, 0, 192)

      color5 = Color.new(0, 128 * rate, 96 * rate, 192)

      color6 = Color.new(0, 255 * rate, 192 * rate, 192)

   when 4 #　地

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(255, 224, 192, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(0, 0, 0, 192)

      color5 = Color.new(128 * rate, 64 * rate, 0, 192)

      color6 = Color.new(255 * rate, 128 * rate, 0, 192)

   when 2 #　雷

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(192, 224, 255, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(64, 0, 0, 192)

      color5 = Color.new(0, 96 * rate, 128 * rate, 192)

      color6 = Color.new(0, 192 * rate, 255 * rate, 192)

   when 6 #　光

      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, 0, 64, 192)

      color5 = Color.new(128 * rate, 128 * rate, 64 * rate, 192)

      color6 = Color.new(255 * rate, 255 * rate, 96 * rate, 192)

   when 7 #　暗

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(160, 0, 224, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(0, 0, 0, 192)

      color5 = Color.new(32 * rate, 0, 64 * rate, 192)

      color6 = Color.new(128 * rate, 0 * rate, 192 * rate, 192)

   when 8 #　毒

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(128, 224, 128, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(0, 0, 0, 192)

      color5 = Color.new(0, 96 * rate, 0, 192)

      color6 = Color.new(0, 192 * rate, 0, 192)

   else

      color1 = Color.new(0, 0, 0, 192)

      color2 = Color.new(255, 255, 255, 192)

      color3 = Color.new(0, 0, 0, 192)

      color4 = Color.new(0, 0, 0, 192)

      color5 = Color.new(64 * rate, 64 * rate, 64 * rate, 192)

      color6 = Color.new(192 * rate, 192 * rate, 192 * rate, 192)

end

#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝





# 変数spに描画するゲージの幅を代入

current_sp=actor.ammo[actor.akind]

current_maxsp=actor.cta[actor.akind]

if current_maxsp != 0

   sp = (width + plus_width) * current_sp * rate_width / 100 / current_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

  #--------------------------------------------------------------------------

  # ● ゲージの描画

  #--------------------------------------------------------------------------

  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

复制代码

改进版的范例下载：

http://rpg.blue/upload_program/f ... CKV101_92751188.rar

slick · 发表于 2008-6-1 20:17:04

以下引用越前リョーマ于2008-5-31 8:52:36的发言：

这个就是传说种的属性能量吧……

这个系统我个人认为，如果制作RM版的CS、洛克人或是POKEMON应该都有用处。

禾西 · 发表于 2008-6-1 20:43:20

比上一版好好多。唔唔。明天測試一下 XD

禾西 · 发表于 2008-6-2 11:14:11

使用藥物可以超出SP上限

另外這裏我幫你减少了一些重複定義：

# 不同种类的SP分开用　改进版 V1.01 BY SLICK
module RPG
class Weapon # 武器名称所能决定SP种类及属性的定义方法(格式像这样：钢匕首,2000,0)
attr_writer :w_maxsp
attr_writer :w_akind
def name
name = @name.split(/,/)[0]
return name != nil ? name : ''
end
def w_maxsp
w_maxsp = @name.split(/,/)[1]
return w_maxsp != nil ? w_maxsp.to_i : 0
end
def w_akind
w_akind = @name.split(/,/)[2]
return w_akind != nil ? w_akind.to_i : 1
end
end
class Item # 定义某种物品能回复哪种SP(格式像这样：普通滋补剂,0)
attr_writer :i_rkind
def name
name = @name.split(/,/)[0]
return name != nil ? name : ''
end
def i_rkind
i_rkind = @name.split(/,/)[1]
return i_rkind != nil ? i_rkind.to_i : nil
end
end
end
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
attr_accessor :ammo # SP残留量
attr_accessor :akind # 使用何种SP
attr_accessor :cta # SP最大容量
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#--------------------------------------------------------------------------
# ● セットアップ
# actor_id : アクター ID
#--------------------------------------------------------------------------
alias ooo_setup setup
def setup(actor_id)
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
@ammo = [0,0,0,0,0,0,0,0,0]#　目前只使用九种能量
@akind = 1 #　缺省情况下使用格斗技能量
@cta = [0,0,0,0,0,0,0,0,0]# 这个新版本中每一种能量的最大值都要设定
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
ooo_setup(actor_id)
end
end
class Scene_Equip
#--------------------------------------------------------------------------
# ● 刷新画面 (右侧窗口被激活的情况下)
#--------------------------------------------------------------------------
def update_right
# 按下 B 键的情况下
if Input.trigger?(Input::B)
# 演奏取消 SE
$game_system.se_play($data_system.cancel_se)
#装备结束时再次判断一下属性SP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
neomaxsp=0
if @actor.weapon_id !=0
@actor.akind=$data_weapons[@actor.weapon_id].w_akind
end
if @actor.weapon_id !=0
neomaxsp+=$data_weapons[@actor.weapon_id].w_maxsp
end
@actor.cta[@actor.akind]=neomaxsp
@actor.ammo[@actor.akind] = [$lammo[@actor.akind],@actor.cta[@actor.akind]].min#弹药种类相同取弹匣小值
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 切换到菜单画面
$scene = Scene_Menu.new(2)
return
end
# 按下 C 键的情况下
if Input.trigger?(Input::C)
# 固定装备的情况下
if @actor.equip_fix?(@right_window.index)
# 演奏冻结 SE
$game_system.se_play($data_system.buzzer_se)
return
end
# 演奏确定 SE
$game_system.se_play($data_system.decision_se)
# 激活物品窗口
@right_window.active = false
@item_window.active = true
@item_window.index = 0
#开始装备武器时判断一下属性SP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
$lkind = @actor.akind #弹药种类是否与以前相同？
$lammo = []
for ii in [email protected]
$lammo[ii][email protected][ii]
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
return
end
# 按下 R 键的情况下
if Input.trigger?(Input::R)
# 演奏光标 SE
$game_system.se_play($data_system.cursor_se)
# 移至下一位角色
@actor_index += 1
@actor_index %= $game_party.actors.size
# 切换到别的装备画面
$scene = Scene_Equip.new(@actor_index, @right_window.index)
return
end
# 按下 L 键的情况下
if Input.trigger?(Input::L)
# 演奏光标 SE
$game_system.se_play($data_system.cursor_se)
# 移至上一位角色
@actor_index += $game_party.actors.size - 1
@actor_index %= $game_party.actors.size
# 切换到别的装备画面
$scene = Scene_Equip.new(@actor_index, @right_window.index)
return
end
end
end
class Game_Battler
#--------------------------------------------------------------------------
SW_SET = [1,2,3,4,5,6,7,8,9] # 此处设定武器和技能关联的属性id
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
if self.is_a?(Game_Actor) and self.weapon_id > 0
sw_boolean = false # 判断武器和技能关联
s = SW_SET & $data_skills[skill_id].element_set
if s.empty?
sw_boolean = true
else
for i in s
if $data_weapons[self.weapon_id].element_set .include?(i)
sw_boolean = true
break
end
end
end
if sw_boolean == false
return false
end
#这里修改为对各种SP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
current_sp=self.ammo[self.akind]
current_maxsp=self.cta[self.akind]
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if $data_skills[skill_id].sp_cost > current_sp
return false
end
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
end
class Scene_Battle
def make_skill_action_result
# 获取特技
@skill = $data_skills[@active_battler.current_action.skill_id]
# 如果不是强制行动
unless @active_battler.current_action.forcing
# 因为 SP 耗尽而无法使用的情况下
unless @active_battler.skill_can_use?(@skill.id)
# 清除强制行动对像的战斗者
$game_temp.forcing_battler = nil
# 移至步骤 1
@phase4_step = 1
return
end
end
# 消耗 SP（区分不同种类）＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if @active_battler.is_a?(Game_Actor)
@active_battler.ammo[@active_battler.akind] -= @skill.sp_cost
else
@active_battler.sp -= @skill.sp_cost
end if
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 刷新状态窗口
@status_window.refresh
# 在帮助窗口显示特技名
@help_window.set_text(@skill.name, 1)
# 设置动画 ID
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
# 设置公共事件 ID
@common_event_id = @skill.common_event_id
# 设置对像侧战斗者
set_target_battlers(@skill.scope)
# 应用特技效果
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
end
end
#==============================================================================
# 物品对不同SP分别起作用
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 应用物品效果
# 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
#这里修改了对SP回复率的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
recover_sp = self.cta[self.akind] * 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
self.hp += recover_hp
#这里修改为对各种属性SP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if self.is_a?(Game_Actor)
case item.i_rkind
when 255 #对自己所有的SP都起作用
for ii in 0...self.cta.size
current_sp = self.ammo[ii]
if ii==self.akind #最大SP值的限制只对当前SP起作用
current_maxsp=self.cta[ii]
current_sp += recover_sp
if current_sp > current_maxsp
current_sp = current_maxsp
end
else
current_sp += recover_sp
end
self.ammo[ii] = current_sp
end
when nil #对自己当前正在使用的SP起作用
current_sp=self.ammo[self.akind]
current_maxsp=self.cta[self.akind] #最大SP值的限制只对当前SP起作用
current_sp += recover_sp
if current_sp > current_maxsp
current_sp = current_maxsp
end
self.ammo[self.akind] = current_sp
else #对自己某种特定属性的SP起作用
current_sp=self.ammo[item.i_rkind]
current_sp += recover_sp
self.ammo[item.i_rkind] = current_sp
end
last_sp = current_sp
effective =true
else
last_sp = self.sp
self.sp += recover_sp
effective |= self.sp != last_sp
end
# ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
effective |= self.hp != last_hp
# 状态变化
@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 = "Miss"
end
end
end
# Miss 的情况下
else
# 伤害设置为 "Miss"
self.damage = "Miss"
end
# 不在战斗中的情况下
unless $game_temp.in_battle
# 伤害设置为 nil
self.damage = nil
end
# 过程结束
return effective
end
end
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
#--------------------------------------------------------------------------
# ● 描绘 SP
# actor : 角色
# x : 描画目标 X 坐标
# y : 描画目标 Y 坐标
# width : 描画目标的宽
#--------------------------------------------------------------------------
def draw_actor_sp(actor, x, y, width = 144)
# 描绘字符串 "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
current_sp=actor.ammo[actor.akind]
current_maxsp=actor.cta[actor.akind]
self.contents.font.color = current_sp == 0 ? knockout_color :
current_sp <= current_maxsp / 4 ? crisis_color : normal_color
self.contents.draw_text(sp_x, y, 48, 32, current_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, current_maxsp.to_s)
end
end
#--------------------------------------------------------------------------
# ● 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.cta[actor.akind]
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:実ゲージライトカラー
#区分SP属性的颜色＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
case actor.akind
when 0 #　火
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 192, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 64, 192)
color5 = Color.new(128 * rate, 0, 0, 192)
color6 = Color.new(255 * rate, 0, 0, 192)
when 3 #　水
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 192, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 64, 0, 192)
color5 = Color.new(0, 0, 128 * rate, 192)
color6 = Color.new(0, 0, 255 * rate, 192)
when 5 #　风
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 255, 224, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(0, 128 * rate, 96 * rate, 192)
color6 = Color.new(0, 255 * rate, 192 * rate, 192)
when 4 #　地
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 224, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(128 * rate, 64 * rate, 0, 192)
color6 = Color.new(255 * rate, 128 * rate, 0, 192)
when 2 #　雷
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 224, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(0, 96 * rate, 128 * rate, 192)
color6 = Color.new(0, 192 * rate, 255 * rate, 192)
when 6 #　光
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, 0, 64, 192)
color5 = Color.new(128 * rate, 128 * rate, 64 * rate, 192)
color6 = Color.new(255 * rate, 255 * rate, 96 * rate, 192)
when 7 #　暗
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(160, 0, 224, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(32 * rate, 0, 64 * rate, 192)
color6 = Color.new(128 * rate, 0 * rate, 192 * rate, 192)
when 8 #　毒
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(128, 224, 128, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(0, 96 * rate, 0, 192)
color6 = Color.new(0, 192 * rate, 0, 192)
else
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(64 * rate, 64 * rate, 64 * rate, 192)
color6 = Color.new(192 * rate, 192 * rate, 192 * rate, 192)
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 変数spに描画するゲージの幅を代入
current_sp=actor.ammo[actor.akind]
current_maxsp=actor.cta[actor.akind]
if current_maxsp != 0
sp = (width + plus_width) * current_sp * rate_width / 100 / current_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
#--------------------------------------------------------------------------
# ● ゲージの描画
#--------------------------------------------------------------------------
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

复制代码

還有一個就是
沒有附帶武器就退出裝備界面後會發生 No Method Error
錯誤指向不同SP分开用（改进） 136行以下句子

@actor.ammo[@actor.akind] = [$lammo[@actor.akind],@actor.cta[@actor.akind]].min#弹药种类相同取弹匣小值

$lammo 此時爲nil

slick · 发表于 2008-6-2 19:17:15

这回应该不会了吧，这个是改进版V1.02

http://rpg.blue/upload_program/f ... ��V102_92834207.rar

# 不同种类的SP分开用　改进版 V1.02
# 制作　SLICK
# 技术指导/测试　禾西
# 修正了几个BUG
# 修正了V1.01版中卸掉武器就会出脚本错
# 修正了V1.01版中特定药物使用后SP超上限的BUG
module RPG
class Weapon # 武器名称所能决定SP种类及属性的定义方法(格式像这样：钢匕首,2000,0)
attr_writer :w_maxsp
attr_writer :w_akind
def name
name = @name.split(/,/)[0]
return name != nil ? name : ''
end
def w_maxsp
w_maxsp = @name.split(/,/)[1]
return w_maxsp != nil ? w_maxsp.to_i : 0
end
def w_akind
w_akind = @name.split(/,/)[2]
return w_akind != nil ? w_akind.to_i : 1
end
end
class Item # 定义某种物品能回复哪种SP(格式像这样：普通滋补剂,0)
attr_writer :i_rkind
def name
name = @name.split(/,/)[0]
return name != nil ? name : ''
end
def i_rkind
i_rkind = @name.split(/,/)[1]
return i_rkind != nil ? i_rkind.to_i : nil
end
end
end
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
attr_accessor :ammo # SP残留量
attr_accessor :akind # 使用何种SP
attr_accessor :cta # SP最大容量
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#感谢禾大人帮助精简＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#--------------------------------------------------------------------------
# ● セットアップ
# actor_id : アクター ID
#--------------------------------------------------------------------------
alias ooo_setup setup
def setup(actor_id)
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
@ammo = [0,0,0,0,0,0,0,0,0]#　目前只使用九种能量
@akind = 1 #　缺省情况下使用格斗技能量
@cta = [0,0,0,0,0,0,0,0,0]# 这个新版本中每一种能量的最大值都要设定
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
ooo_setup(actor_id)
end
end
class Scene_Equip
#--------------------------------------------------------------------------
# ● 刷新画面 (右侧窗口被激活的情况下)
#--------------------------------------------------------------------------
def update_right
# 按下 B 键的情况下
if Input.trigger?(Input::B)
# 演奏取消 SE
$game_system.se_play($data_system.cancel_se)
#装备结束时再次判断一下属性SP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
neomaxsp=0
if @actor.weapon_id !=0
@actor.akind=$data_weapons[@actor.weapon_id].w_akind
neomaxsp+=$data_weapons[@actor.weapon_id].w_maxsp
@actor.cta[@actor.akind]=neomaxsp
@actor.ammo[@actor.akind] = [$lammo[@actor.akind],@actor.cta[@actor.akind]].min#弹药种类相同取弹匣小值
else #如果扔掉武器，SP就是0
@actor.akind=1
@actor.cta[@actor.akind]=0
@actor.ammo[@actor.akind]=0
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 切换到菜单画面
$scene = Scene_Menu.new(2)
return
end
# 按下 C 键的情况下
if Input.trigger?(Input::C)
# 固定装备的情况下
if @actor.equip_fix?(@right_window.index)
# 演奏冻结 SE
$game_system.se_play($data_system.buzzer_se)
return
end
# 演奏确定 SE
$game_system.se_play($data_system.decision_se)
# 激活物品窗口
@right_window.active = false
@item_window.active = true
@item_window.index = 0
#开始装备武器时判断一下属性SP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
$lkind = @actor.akind #弹药种类是否与以前相同？
$lammo = []
for ii in [email protected]
$lammo[ii][email protected][ii]
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
return
end
# 按下 R 键的情况下
if Input.trigger?(Input::R)
# 演奏光标 SE
$game_system.se_play($data_system.cursor_se)
# 移至下一位角色
@actor_index += 1
@actor_index %= $game_party.actors.size
# 切换到别的装备画面
$scene = Scene_Equip.new(@actor_index, @right_window.index)
return
end
# 按下 L 键的情况下
if Input.trigger?(Input::L)
# 演奏光标 SE
$game_system.se_play($data_system.cursor_se)
# 移至上一位角色
@actor_index += $game_party.actors.size - 1
@actor_index %= $game_party.actors.size
# 切换到别的装备画面
$scene = Scene_Equip.new(@actor_index, @right_window.index)
return
end
end
end
class Game_Battler
#--------------------------------------------------------------------------
SW_SET = [1,2,3,4,5,6,7,8,9] # 此处设定武器和技能关联的属性id
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
if self.is_a?(Game_Actor) and self.weapon_id > 0
sw_boolean = false # 判断武器和技能关联
s = SW_SET & $data_skills[skill_id].element_set
if s.empty?
sw_boolean = true
else
for i in s
if $data_weapons[self.weapon_id].element_set .include?(i)
sw_boolean = true
break
end
end
end
if sw_boolean == false
return false
end
#这里修改为对各种SP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
current_sp=self.ammo[self.akind]
current_maxsp=self.cta[self.akind]
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if $data_skills[skill_id].sp_cost > current_sp
return false
end
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
end
class Scene_Battle
def make_skill_action_result
# 获取特技
@skill = $data_skills[@active_battler.current_action.skill_id]
# 如果不是强制行动
unless @active_battler.current_action.forcing
# 因为 SP 耗尽而无法使用的情况下
unless @active_battler.skill_can_use?(@skill.id)
# 清除强制行动对像的战斗者
$game_temp.forcing_battler = nil
# 移至步骤 1
@phase4_step = 1
return
end
end
# 消耗 SP（区分不同种类）＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if @active_battler.is_a?(Game_Actor)
@active_battler.ammo[@active_battler.akind] -= @skill.sp_cost
else
@active_battler.sp -= @skill.sp_cost
end if
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 刷新状态窗口
@status_window.refresh
# 在帮助窗口显示特技名
@help_window.set_text(@skill.name, 1)
# 设置动画 ID
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
# 设置公共事件 ID
@common_event_id = @skill.common_event_id
# 设置对像侧战斗者
set_target_battlers(@skill.scope)
# 应用特技效果
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
end
end
#==============================================================================
# 物品对不同SP分别起作用
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 应用物品效果
# 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
#这里修改了对SP回复率的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
recover_sp = self.cta[self.akind] * 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
self.hp += recover_hp
#这里修改为对各种属性SP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if self.is_a?(Game_Actor)
case item.i_rkind
when 255 #对自己所有的SP都起作用
for ii in 0...self.cta.size
current_sp = self.ammo[ii]
if ii==self.akind #最大SP值的限制只对当前SP起作用
current_maxsp=self.cta[ii]
current_sp += recover_sp
if current_sp > current_maxsp
current_sp = current_maxsp
end
else
current_sp += recover_sp
end
self.ammo[ii] = current_sp
end
when nil #对自己当前正在使用的SP起作用
current_sp=self.ammo[self.akind]
current_maxsp=self.cta[self.akind] #最大SP值的限制只对当前SP起作用
current_sp += recover_sp
if current_sp > current_maxsp
current_sp = current_maxsp
end
self.ammo[self.akind] = current_sp
else #对自己某种特定属性的SP起作用
current_sp=self.ammo[item.i_rkind]
current_sp += recover_sp
if item.i_rkind==self.akind #对不可见的SP就不加限制以防出错
current_maxsp=self.cta[self.akind] #对可见的SP就规定上限
if current_sp > current_maxsp
current_sp = current_maxsp
end
end
self.ammo[item.i_rkind] = current_sp
end
last_sp = current_sp
effective =true
else
last_sp = self.sp
self.sp += recover_sp
effective |= self.sp != last_sp
end
# ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
effective |= self.hp != last_hp
# 状态变化
@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 = "Miss"
end
end
end
# Miss 的情况下
else
# 伤害设置为 "Miss"
self.damage = "Miss"
end
# 不在战斗中的情况下
unless $game_temp.in_battle
# 伤害设置为 nil
self.damage = nil
end
# 过程结束
return effective
end
end
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
#--------------------------------------------------------------------------
# ● 描绘 SP
# actor : 角色
# x : 描画目标 X 坐标
# y : 描画目标 Y 坐标
# width : 描画目标的宽
#--------------------------------------------------------------------------
def draw_actor_sp(actor, x, y, width = 144)
# 描绘字符串 "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
current_sp=actor.ammo[actor.akind]
current_maxsp=actor.cta[actor.akind]
self.contents.font.color = current_sp == 0 ? knockout_color :
current_sp <= current_maxsp / 4 ? crisis_color : normal_color
self.contents.draw_text(sp_x, y, 48, 32, current_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, current_maxsp.to_s)
end
end
#--------------------------------------------------------------------------
# ● 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.cta[actor.akind]
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:実ゲージライトカラー
#区分SP属性的颜色＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
case actor.akind
when 0 #　火
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 192, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 64, 192)
color5 = Color.new(128 * rate, 0, 0, 192)
color6 = Color.new(255 * rate, 0, 0, 192)
when 3 #　水
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 192, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 64, 0, 192)
color5 = Color.new(0, 0, 128 * rate, 192)
color6 = Color.new(0, 0, 255 * rate, 192)
when 5 #　风
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 255, 224, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(0, 128 * rate, 96 * rate, 192)
color6 = Color.new(0, 255 * rate, 192 * rate, 192)
when 4 #　地
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 224, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(128 * rate, 64 * rate, 0, 192)
color6 = Color.new(255 * rate, 128 * rate, 0, 192)
when 2 #　雷
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 224, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(0, 96 * rate, 128 * rate, 192)
color6 = Color.new(0, 192 * rate, 255 * rate, 192)
when 6 #　光
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, 0, 64, 192)
color5 = Color.new(128 * rate, 128 * rate, 64 * rate, 192)
color6 = Color.new(255 * rate, 255 * rate, 96 * rate, 192)
when 7 #　暗
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(160, 0, 224, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(32 * rate, 0, 64 * rate, 192)
color6 = Color.new(128 * rate, 0 * rate, 192 * rate, 192)
when 8 #　毒
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(128, 224, 128, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(0, 96 * rate, 0, 192)
color6 = Color.new(0, 192 * rate, 0, 192)
else
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(64 * rate, 64 * rate, 64 * rate, 192)
color6 = Color.new(192 * rate, 192 * rate, 192 * rate, 192)
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 変数spに描画するゲージの幅を代入
current_sp=actor.ammo[actor.akind]
current_maxsp=actor.cta[actor.akind]
if current_maxsp != 0
sp = (width + plus_width) * current_sp * rate_width / 100 / current_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
#--------------------------------------------------------------------------
# ● ゲージの描画
#--------------------------------------------------------------------------
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

复制代码

禾西 · 发表于 2008-6-5 08:51:10

發布完成 slick.vip +=2

雪流星 · 发表于 2008-6-6 16:16:28

我尝试做了VX版
但是未完成
有人有兴趣继续做下去吧
剩餘部分:
Scene_Battle部分
Game_Battler回復部分
Window繪製血條部分

PS:
把名称定义SP改成使用备注
把SP改成MP

# 不同种类的MP分开用　改进版 V1.02
# 制作　SLICK
# 技术指导/测试　禾西
# 修正了几个BUG
# 修正了V1.01版中卸掉武器就会出脚本错
# 修正了V1.01版中特定药物使用后MP超上限的BUG
class RPG::Weapon < RPG::BaseItem
# 武器名称所能决定MP种类及属性的定义方法
# 格式: MP種類 [w_maxmp 2000]
# MP種類 [w_akind 0]
attr_writer :w_maxmp
attr_writer :w_akind
def w_maxmp
self.note.mplit(/[\r\n]+/).each { |line|
if line =~ /\[w_maxmp \d+\]/
a = line.mplit(/ /)[1]
d = ""
while ((c = a.slice!(/./m)) != nil)
d += c if c.is_a?(Integer)
end
end
}
return d ? d.to_i : nil
end
def w_akind
self.note.mplit(/[\r\n]+/).each { |line|
if line =~ /\[w_akind \d+\]/
a = line.mplit(/ /)[1]
d = ""
while ((c = a.slice!(/./m)) != nil)
d += c if c.is_a?(Integer)
end
end
}
return d ? d.to_i : nil
end
end
class RPG::Item < RPG::UsableItem
# 定义某种物品能回复哪种MP
# 格式: MP種類 [i_rkind 2000]
attr_writer :i_rkind
self.note.mplit(/[\r\n]+/).each { |line|
if line =~ /\[i_rkind \d+\]/
a = line.mplit(/ /)[1]
d = ""
while ((c = a.slice!(/./m)) != nil)
d += c if c.is_a?(Integer)
end
end
}
return d ? d.to_i : nil
end
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
attr_accessor :ammo # MP残留量
attr_accessor :akind # 使用何种MP
attr_accessor :cta # MP最大容量
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#感谢禾大人帮助精简＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#--------------------------------------------------------------------------
# ● セットアップ
# actor_id : アクター ID
#--------------------------------------------------------------------------
alias ooo_setup setup
def setup(actor_id)
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
@ammo = [0,0,0,0,0,0,0,0,0]#　目前只使用九种能量
@akind = 1 #　缺省情况下使用格斗技能量
@cta = [0,0,0,0,0,0,0,0,0]# 这个新版本中每一种能量的最大值都要设定
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
ooo_setup(actor_id)
end
end
class Scene_Equip < Scene_Base
#--------------------------------------------------------------------------
# ● 更新裝備區域選擇
#--------------------------------------------------------------------------
def update_equip_selection
# 按下 B 键的情况下
if Input.trigger?(Input::B)
# 演奏取消 SE
Sound.play_cancel
#装备结束时再次判断一下属性MP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
neomaxmp=0
if @actor.weapon_id !=0
@actor.akind=$data_weapons[@actor.weapon_id].w_akind
neomaxmp+=$data_weapons[@actor.weapon_id].w_maxmp
@actor.cta[@actor.akind]=neomaxmp
@actor.ammo[@actor.akind] = [$lammo[@actor.akind],@actor.cta[@actor.akind]].min#弹药种类相同取弹匣小值
else #如果扔掉武器，MP就是0
@actor.akind=1
@actor.cta[@actor.akind]=0
@actor.ammo[@actor.akind]=0
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 切换到菜单画面
return_scene
end
# 按下 R 键的情况下
elsif Input.trigger?(Input::R)
Sound.play_cursor # 演奏光标 SE
next_actor # 移至下一位角色
# 按下 L 键的情况下
elsif Input.trigger?(Input::L)
Sound.play_cursor # 演奏光标 SE
prev_actor # 移至上一位角色
# 按下 C 键的情况下
if Input.trigger?(Input::C)
# 固定装备的情况下
if @actor.fix_equipment
Sound.play_buzzer
else
# 演奏确定 SE
Sound.play_decision
# 激活物品窗口
@equip_window.active = false
@item_window.active = true
@item_window.index = 0
#开始装备武器时判断一下属性MP值＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
$lkind = @actor.akind #弹药种类是否与以前相同？
$lammo = []
for ii in [email protected]
$lammo[ii][email protected][ii]
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
return
end
end
end
# 需要在Game_Battler內修改
class Scene_Battle < Scene_Base
def make_skill_action_result
# 获取特技
@skill = $data_skills[@active_battler.current_action.skill_id]
# 如果不是强制行动
unless @active_battler.current_action.forcing
# 因为 MP 耗尽而无法使用的情况下
unless @active_battler.skill_can_use?(@skill.id)
# 清除强制行动对像的战斗者
$game_temp.forcing_battler = nil
# 移至步骤 1
@phase4_step = 1
return
end
end
# 消耗 MP（区分不同种类）＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if @active_battler.is_a?(Game_Actor)
@active_battler.ammo[@active_battler.akind] -= @skill.mp_cost
else
@active_battler.mp -= @skill.mp_cost
end if
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 刷新状态窗口
@status_window.refresh
# 在帮助窗口显示特技名
@help_window.set_text(@skill.name, 1)
# 设置动画 ID
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
# 设置公共事件 ID
@common_event_id = @skill.common_event_id
# 设置对像侧战斗者
set_target_battlers(@skill.scope)
# 应用特技效果
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
end
end
#==============================================================================
# 物品对不同MP分别起作用
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
SW_SET = [1,2,3,4,5,6,7,8,9] # 此处设定武器和技能关联的属性id
#--------------------------------------------------------------------------
def skill_can_use?(skill)
return false unless skill.is_a?(RPG::Skill)
return false unless movable?
if self.is_a?(Game_Actor) and self.weapon_id > 0
sw_boolean = false # 判断武器和技能关联
s = SW_SET & skill.element_set
if s.empty?
sw_boolean = true
else
for i in s
if $data_weapons[self.weapon_id].element_set .include?(i)
sw_boolean = true
break
end
end
end
if sw_boolean == false
return false
end
#这里修改为对各种MP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
current_mp=self.ammo[self.akind]
current_maxmp=self.cta[self.akind]
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
return false if calc_mp_cost(skill) > current_mp
end
return false if dead?
return false if silent? and skill.mpi_f > 0
occasion = skill.occasion
if $game_temp.in_battle
return skill.battle_ok?
else
return skill.menu_ok?
end
end
#--------------------------------------------------------------------------
# ● 發動物品效果
# user : 物品使用者
# item : 物品
#--------------------------------------------------------------------------
def item_effect(user, item)
clear_action_results
unless item_effective?(user, item)
@skipped = true
return
end
if rand(100) >= calc_hit(user, item) # 計算命中率
@missed = true
return
end
if rand(100) < calc_eva(user, item) # 計算閃躲率
@evaded = true
return
end
hp_recovery = calc_hp_recovery(user, item) # 計算體力回復量
mp_recovery = calc_mp_recovery(user, item) # 計算魔力回復量
make_obj_damage_value(user, item) # 計算傷害
@hp_damage -= hp_recovery # 體力傷害減去回復量
@mp_damage -= mp_recovery # 魔力傷害減去回復量
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
# 未修改
#--------------------------------------------------------------------------
# ● 应用物品效果
# item : 物品
#--------------------------------------------------------------------------
def item_effect(user, item)
clear_action_results
unless item_effective?(user, item)
@skipped = true
return
end
if rand(100) >= calc_hit(user, item) # 計算命中率
@missed = true
return
end
if rand(100) < calc_eva(user, item) # 計算閃躲率
@evaded = true
return
end
# 计算回复量
hp_recovery = calc_hp_recovery(user, item) # 計算體力回復量
make_obj_damage_value(user, item) # 計算傷害
@hp_damage -= hp_recovery # 體力傷害減去回復量
@mp_damage -= mp_recovery # 魔力傷害減去回復量
make_obj_absorb_effect(user, item) # 計算吸收效果
execute_damage(user) # 傷害效果
#这里修改了对MP回复率的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
recover_mp = self.cta[self.akind] * item.recover_mp_rate / 100 + item.recover_mp
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
recover_mp *= elements_correct(item.element_set)
recover_mp /= 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_mp.abs > 0
amp = [recover_mp.abs * item.variance / 100, 1].max
recover_mp += 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 以及 MP 的回复
last_hp = self.hp
self.hp += recover_hp
#这里修改为对各种属性MP的判断＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
if self.is_a?(Game_Actor)
case item.i_rkind
when 255 #对自己所有的MP都起作用
for ii in 0...self.cta.size
current_mp = self.ammo[ii]
if ii==self.akind #最大MP值的限制只对当前MP起作用
current_maxmp=self.cta[ii]
current_mp += recover_mp
if current_mp > current_maxmp
current_mp = current_maxmp
end
else
current_mp += recover_mp
end
self.ammo[ii] = current_mp
end
when nil #对自己当前正在使用的MP起作用
current_mp=self.ammo[self.akind]
current_maxmp=self.cta[self.akind] #最大MP值的限制只对当前MP起作用
current_mp += recover_mp
if current_mp > current_maxmp
current_mp = current_maxmp
end
self.ammo[self.akind] = current_mp
else #对自己某种特定属性的MP起作用
current_mp=self.ammo[item.i_rkind]
current_mp += recover_mp
if item.i_rkind==self.akind #对不可见的MP就不加限制以防出错
current_maxmp=self.cta[self.akind] #对可见的MP就规定上限
if current_mp > current_maxmp
current_mp = current_maxmp
end
end
self.ammo[item.i_rkind] = current_mp
end
last_mp = current_mp
effective =true
else
last_mp = self.mp
self.mp += recover_mp
effective |= self.mp != last_mp
end
# ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
item_growth_effect(user, item) # 能力值提升效果
# HP 回复率与回复量为 0 的情况下
if item.recover_hp_rate == 0 and item.recover_hp == 0
# 设置伤害为空的字符串
self.damage = ""
# MP 回复率与回复量为 0、能力上升值无效的情况下
if item.recover_mp_rate == 0 and item.recover_mp == 0 and
(item.parameter_type == 0 or item.parameter_points == 0)
# 状态没有变化的情况下
unless @state_changed
# 伤害设置为 "Miss"
self.damage = "Miss"
end
end
end
# 不在战斗中的情况下
unless $game_temp.in_battle
# 伤害设置为 nil
self.damage = nil
end
# 过程结束
return effective
end
end
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
#--------------------------------------------------------------------------
# ● 繪製角色魔力
# actor : 角色
# x : 描畫目標 X 坐標
# y : 描畫目標 Y 坐標
# width : 描畫目標寬度
#--------------------------------------------------------------------------
def draw_actor_mp(actor, x, y, width = 120)
draw_actor_mp_gauge(actor, x, y, width)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 30, WLH, Vocab::mp_a)
self.contents.font.color = mp_color(actor)
last_font_size = self.contents.font.size
xr = x + width
if width < 120
self.contents.draw_text(xr - 44, y, 44, WLH, actor.ammo[actor.akind], 2)
else
self.contents.draw_text(xr - 99, y, 44, WLH, actor.ammo[actor.akind], 2)
self.contents.font.color = normal_color
self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
self.contents.draw_text(xr - 44, y, 44, WLH, actor.cta[actor.akind], 2)
end
end
def mp_color(actor)
return crisis_color if actor.ammo[actor.akind] < actor.cta[actor.akind] / 4
return normal_color
end
#--------------------------------------------------------------------------
# ● 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)
# 変数mpに描画するゲージの幅を代入
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
#--------------------------------------------------------------------------
# ● MP ゲージの描画
#--------------------------------------------------------------------------
# オリジナルのMP描画を draw_actor_mp_original と名前変更
alias :draw_actor_mp_original :draw_actor_mp
def draw_actor_mp(actor, x, y, width = 144)
# 変数rateに現在のMP/MMPを代入
if actor.maxmp != 0
rate = actor.mp.to_f / actor.cta[actor.akind]
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:実ゲージライトカラー
#区分MP属性的颜色＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
case actor.akind
when 0 #　火
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 192, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 64, 192)
color5 = Color.new(128 * rate, 0, 0, 192)
color6 = Color.new(255 * rate, 0, 0, 192)
when 3 #　水
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 192, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 64, 0, 192)
color5 = Color.new(0, 0, 128 * rate, 192)
color6 = Color.new(0, 0, 255 * rate, 192)
when 5 #　风
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 255, 224, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(0, 128 * rate, 96 * rate, 192)
color6 = Color.new(0, 255 * rate, 192 * rate, 192)
when 4 #　地
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 224, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(128 * rate, 64 * rate, 0, 192)
color6 = Color.new(255 * rate, 128 * rate, 0, 192)
when 2 #　雷
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(192, 224, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(0, 96 * rate, 128 * rate, 192)
color6 = Color.new(0, 192 * rate, 255 * rate, 192)
when 6 #　光
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, 0, 64, 192)
color5 = Color.new(128 * rate, 128 * rate, 64 * rate, 192)
color6 = Color.new(255 * rate, 255 * rate, 96 * rate, 192)
when 7 #　暗
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(160, 0, 224, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(32 * rate, 0, 64 * rate, 192)
color6 = Color.new(128 * rate, 0 * rate, 192 * rate, 192)
when 8 #　毒
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(128, 224, 128, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(0, 96 * rate, 0, 192)
color6 = Color.new(0, 192 * rate, 0, 192)
else
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
color5 = Color.new(64 * rate, 64 * rate, 64 * rate, 192)
color6 = Color.new(192 * rate, 192 * rate, 192 * rate, 192)
end
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
# 変数mpに描画するゲージの幅を代入
current_mp=actor.ammo[actor.akind]
current_maxmp=actor.cta[actor.akind]
if current_maxmp != 0
mp = (width + plus_width) * current_mp * rate_width / 100 / current_maxmp
else
mp = (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, mp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# オリジナルのMP描画処理を呼び出し
draw_actor_mp_original(actor, x, y, width)
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

复制代码

禾西 · 发表于 2008-6-6 16:57:58

其實可以嘗試這種思路：
class Game_Actor < Game_Battler
  attr_accessor :ammo                   # MP残留量
  attr_accessor :akind                   # 使用何种MP
  attr_accessor :cta                   # MP最大容量

  alias ooo_setup setup
  def setup(actor_id)
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#这里做修改＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
@ammo = [0,0,0,0,0,0,0,0,0]#　目前只使用九种能量
@akind = 1 #　缺省情况下使用格斗技能量
@cta = [0,0,0,0,0,0,0,0,0]#  这个新版本中每一种能量的最大值都要设定
#＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
ooo_setup(actor_id)
  end
  def sp=(sp, val=@akind)
@ammo[val] = [[sp, maxsp].min, 0].max
  end
  def sp(val=@kind)
return @ammo[val]
  end
  def maxsp
n = @cta[@kind] + @maxsp_plus
for i in @states
   n *= $data_states.maxsp_rate / 100.0
end
n = [[Integer(n), 0].max, 9999].min
return n
  end
end

其他不說了...看得明就看吧...

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

同一角色不同种类的SP分开使用(13楼做出第二次改进版)

贵宾

开拓者

第3届短篇游戏大赛主流游戏组亚军

第5届短篇游戏比赛亚军