求解这段脚本为毛不生效

cjlzbb

这是个给技能装备上crystal的脚本
其中这段，作为一个脚本小白看了好久觉得应该是
当技能能够装备crystal时，槽里装上该crystal，队伍物品栏扣除该crystal一个并且获得原先槽里的crystal一个。
但是实际上发现在槽里已经有crystal后再装备一个新的crystal来替换掉时，只会更换装备并不会获得原先的那个crystal

1.   def add_grathnode(skill, crystal, slot)
   
2.     if @installs[skill.id].nil?
   
3.       @installs[skill.id] = Array.new(skill.grathnode_slots, nil)
   
4.     elsif @installs[skill.id][slot] != nil
   
5.       $game_party.gain_item(@installs[skill.id][slot], 1)
   
6.     end
   
7.     $game_party.lose_item(crystal, 1) unless crystal.nil?
   
8.     @installs[skill.id][slot] = crystal.nil? ? nil : crystal.id
   
9.   end

复制代码

Sion

还是发个范例吧。光看这个method是找不到问题的。

cjlzbb

Sion 发表于 2013-1-15 11:52
还是发个范例吧。光看这个method是找不到问题的。

[pre lang="ruby" line="1"]#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#  ▼ Grathnode Install
#  Author: Kread-EX
#  Version 1.12
#  Release date: 31/12/2011
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

#------------------------------------------------------------------------------
#  ▼ UPDATES
#------------------------------------------------------------------------------
# # 28/12/2012. Fixed another bug with savefiles.
# # 30/01/2012. Added option to disable grathnode menu for certain characters.
# # 30/01/2012. Added option to remove grathnodes when a skill is forgetted.
# # 20/01/2012. Compatibility fix.
# # 19/01/2012. Loads of compatibility fixes.
# # 14/01/2012. Fixed two crashing bugs with the DBS implementation.
# # 10/01/2012. <max_grathnodes: 0> now works.
# # 07/01/2012. Fixed a critical bug preventing the installs to be saved.
# # 05/01/2012. Fixed a crashing bug in the Install menu if no skill is
# # available.
# # 01/01/2012. Fixed compatibility with Yanfly's TP Manager (thanks Adalwulf)
# # NOW DEPRECATED. Use Yanfly's Ace Skill Menu to ensure compat. However, in
# # case you don't want to, just uncomment the code at the end of the script.
#------------------------------------------------------------------------------
#  ▼ TERMS OF USAGE
#------------------------------------------------------------------------------
# #  You are free to adapt this work to suit your needs.
# #  You can use this work for commercial purposes if you like it.
# #  Credit is appreciated.
# #
# # For support:
# # grimoirecastle.wordpress.com
# # rpgmakerweb.com
#------------------------------------------------------------------------------
#  ▼ INTRODUCTION
#------------------------------------------------------------------------------
# # This script is inspired from the Ar Tonelico series. In a nutshell,
# # it allows the player to assign special items called Grathnode crystals to
# # skills in order to add special effects.
# # The upgrades are actor-dependant: if two actors have the same skill, they
# # can use a different set of crystals.
#------------------------------------------------------------------------------
#  ▼ INSTRUCTIONS
#------------------------------------------------------------------------------
# # First, you need to create the desired grathnode crystals. They are regular
# # items, but tagged as <grathnode> in their notebox.
# # Certain grathnodes are suited only for a certain type of skill. To ensure
# # that a defensive skill doesn't use an offensive effect, you can choose
# # the kind of scope:
# # <scope: string> in the item notebox.
# # String can be different values:
# # for_opponent?
# # for_friend?
# # for_dead_friend?
# # for_user?
# # for_all?
# #
# # Every skill can contain up to 6 crystals by default, but you can lower the
# # number either individually (by putting <max_grathnodes: x> if the skill
# # notebox, or globally by altering the ABSOLUTE_MAX_GRATHNODES value within
# # the script.
# #
# # The scene can be called with SceneManager.call(Scene_Grathnode), however
# # I strongly recommend you to use Yanfly's Ace Menu Engine, as I prepared
# # special compatibility for it.
#------------------------------------------------------------------------------
#  ▼ COMPATIBILITY
#------------------------------------------------------------------------------
# # Works with Yanfly's Battle Engine Ace. Actually, it may work better than with
# # the DBS, thanks to the nice pop-ups, very GUST-ish at the conception.
# #
# # List of aliases and overwrites:
# #
# # DataManager
# # load_database (alias)
# # load_grathnode_notetags (new method)
# #
# # RPG::Item
# # load_grathnode_notetags (new method)
# # is_grathnode? (new method)
# # grathnode_scope (new attr method)
# # mp_inflation (new attr method)
# # tp_inflation (new attr method)
# #
# # RPG::Skill
# # load_grathnode_notetags (new method)
# # grathnode_slots (new method)
# #
# # Game_Actor
# # installs (new attr method)
# # barring_grathnode (new attr method)
# # setup (alias)
# # forget_skill (alias)
# # add_grathnode (new method)
# # skill_mp_cost (new child method)
# # skill_tp_cost (new child method)
# # process_grathnode_mp_cost (new method)
# # process_grathnode_tp_cost (new method)
# #
# # Game_Party
# # last_selected_skill (new attr method)
# # menu_actor (alias)
# # menu_actor_next (alias)
# # menu_actor_prev (alias)
# #
# # Scene_Grathnode (new class)
# #
# # Window_UpSkillList (new class)
# #
# # Window_GrathnodeList (new class)
# #
# # Window_GrathnodeInstall (new class)
# #
# # Scene_Battle
# # apply_item_effects (alias)
# # apply_grathnode_effects (new method - YEA Battle Engine only)
#------------------------------------------------------------------------------

($imported || {})['KRX-GrathnodeInstall'] = true

puts 'Load: Grathnode Install v1.12 by Kread-EX'

module KRX
#===========================================================================
# ■ CONFIGURATION
#===========================================================================
  ABSOLUTE_MAX_GRATHNODES = 5
  CLEAR_FORGET_SKILL = true
  SINGLE_ACTOR_INSTALL = false
  SINGLE_ACTOR_INSTALL_ID = 9
  
  module VOCAB
    GRATHNODE = 'Grathnode'
  end
#===========================================================================
# ■ CONFIGURATION ENDS HERE
#===========================================================================
  module REGEXP
    MAX_GRATHNODES = /<max_grathnodes:[ ]*(\d+)>/i
    GRATHNODE_ITEM = /<grathnode>/i
    GRATHNODE_SCOPE = /<scope:[ ]*(\w+.)>/
    MP_INFLATION = /<mp_inflation:[ ]*(\d+)>/i
    TP_INFLATION = /<tp_inflation:[ ]*(\d+)>/i
  end
end
  
#===========================================================================
# ■ DataManager
#===========================================================================

module DataManager  
        #--------------------------------------------------------------------------
        # ● Loads the database
        #--------------------------------------------------------------------------
        class << self
                alias_method(:krx_grathnode_dm_load_database, :load_database)
        end
        def self.load_database
                krx_grathnode_dm_load_database
                load_grathnode_notetags
        end  
        #--------------------------------------------------------------------------
        # ● Loads the note tags
        #--------------------------------------------------------------------------
        def self.load_grathnode_notetags
                groups = [$data_items, $data_skills]
                for group in groups
                        for obj in group
                                next if obj.nil?
                                obj.load_grathnode_notetags
                        end
                end
                puts "Read: Grathnode Install Notetags"
        end
end

#==========================================================================
# ■ RPG::Item
#==========================================================================

class RPG::Item < RPG::UsableItem
        #--------------------------------------------------------------------------
        # ● Public instance variables
        #--------------------------------------------------------------------------
  attr_reader     :grathnode_scope
  attr_reader     :mp_inflation
  attr_reader     :tp_inflation
        #--------------------------------------------------------------------------
        # ● Loads the note tags
        #--------------------------------------------------------------------------
        def load_grathnode_notetags
    @mp_inflation = @tp_inflation = 0
                @note.split(/[\r\n]+/).each do |line|
                        case line
                        when KRX::REGEXP::GRATHNODE_ITEM
                                @is_grathnode = true
                        when KRX::REGEXP::GRATHNODE_SCOPE
                                @grathnode_scope = $1
      when KRX::REGEXP::MP_INFLATION
        @mp_inflation = $1.to_i
      when KRX::REGEXP::TP_INFLATION
        @tp_inflation = $1.to_i
                        end
                end
        end
        #--------------------------------------------------------------------------
        # ● Determine if the item is a grathnode crystal
        #--------------------------------------------------------------------------
        def grathnode?
    @is_grathnode
  end
end

#==========================================================================
# ■ RPG::Skill
#==========================================================================

class RPG::Skill < RPG::UsableItem
        #--------------------------------------------------------------------------
        # ● Loads the note tags
        #--------------------------------------------------------------------------
        def load_grathnode_notetags
                @max_grathnodes = nil
                @note.split(/[\r\n]+/).each do |line|
                        case line
                        when KRX::REGEXP::MAX_GRATHNODES
        @max_grathnodes = [$1.to_i, KRX::ABSOLUTE_MAX_GRATHNODES].min
                        end
                end
  end
        #--------------------------------------------------------------------------
        # ● Returns the maximum number of grathnode slots
        #--------------------------------------------------------------------------
        def grathnode_slots
    (@max_grathnodes == nil ? KRX::ABSOLUTE_MAX_GRATHNODES : @max_grathnodes)
  end
end

#==========================================================================
# ■ Game_Actor
#==========================================================================

class Game_Actor < Game_Battler
        #--------------------------------------------------------------------------
        # ● Public instance variables
        #--------------------------------------------------------------------------
        attr_accessor        :installs
  attr_accessor :barring_grathnode
        #--------------------------------------------------------------------------
        # ● Setup
        #--------------------------------------------------------------------------
        alias_method(:krx_grathnode_gp_setup, :setup)
        def setup(actor_id)
                krx_grathnode_gp_setup(actor_id)
                @installs = {}
    @barring_grathnode = false
        end
        #--------------------------------------------------------------------------
        # ● Adds a grathnode crystal to a specific skill slot
        #--------------------------------------------------------------------------
  def add_grathnode(skill, crystal, slot)
    if @installs[skill.id].nil?
      @installs[skill.id] = Array.new(skill.grathnode_slots, nil)
    elsif @installs[skill.id][slot] != nil
      $game_party.gain_item(@installs[skill.id][slot], 1)
    end
    $game_party.lose_item(crystal, 1) unless crystal.nil?
    @installs[skill.id][slot] = crystal.nil? ? nil : crystal.id
  end
  #--------------------------------------------------------------------------
  # ● Returns the MP cost for a skill
  #--------------------------------------------------------------------------
  def skill_mp_cost(skill)
    cost = super
    (cost + cost * process_grathnode_mp_cost(skill) / 100).round
  end
  #--------------------------------------------------------------------------
  # ● Returns the TP cost for a skill
  #--------------------------------------------------------------------------
  def skill_tp_cost(skill)
    cost = super
    (cost + cost * process_grathnode_tp_cost(skill) / 100).round
  end
        #--------------------------------------------------------------------------
        # ● Calculates the MP cost inflation
        #--------------------------------------------------------------------------
  def process_grathnode_mp_cost(skill)
    result = 0.0
    return result if @installs[skill.id].nil?
    @installs[skill.id].compact.each do |grathnode|
      result += $data_items[grathnode].mp_inflation
    end
    return result
  end
        #--------------------------------------------------------------------------
        # ● Calculates the TP cost inflation
        #--------------------------------------------------------------------------
  def process_grathnode_tp_cost(skill)
    result = 0.0
    return result if @installs[skill.id].nil?
    @installs[skill.id].compact.each do |grathnode|
      result += $data_items[grathnode].tp_inflation
    end
    return result
  end
  #--------------------------------------------------------------------------
  # ● Forgets a skill
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_ga_fs, :forget_skill)
  def forget_skill(skill_id)
    krx_grathnode_ga_fs(skill_id)
    if KRX::CLEAR_FORGET_SKILL
      skill = $data_skills[skill_id]
      (0...skill.grathnode_slots).each do |i|
        add_grathnode(skill, nil, i)
      end
    end
  end
end

#==========================================================================
# ■ Game_Party
#==========================================================================

class Game_Party < Game_Unit
  #--------------------------------------------------------------------------
  # ● Public instance variables
  #--------------------------------------------------------------------------
  attr_accessor   :last_selected_skill
  #--------------------------------------------------------------------------
  # ● Next actor
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_gp_man, :menu_actor_next)
  def menu_actor_next
    if SceneManager.scene.is_a?(Scene_Grathnode)
      return menu_actor if KRX::SINGLE_ACTOR_INSTALL
      val = members.select {|act| !act.barring_grathnode}
      index = val.index(menu_actor) || -1
      index = (index + 1) % val.size
      self.menu_actor = val[index]
    else
      krx_grathnode_gp_man
    end
  end
  #--------------------------------------------------------------------------
  # ● Previous actor
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_gp_map, :menu_actor_prev)
  def menu_actor_prev
    if SceneManager.scene.is_a?(Scene_Grathnode)
      return menu_actor if KRX::SINGLE_ACTOR_INSTALL
      val = members.select {|act| !act.barring_grathnode}
      index = val.index(menu_actor) || 1
      index = (index + val.size - 1) % val.size
      self.menu_actor = val[index]
    else
      krx_grathnode_gp_map
    end
  end
  #--------------------------------------------------------------------------
  # ● Get the current actor for menus
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_gp_ma, :menu_actor)
  def menu_actor
    if SceneManager.scene.is_a?(Scene_Grathnode)
      val = members.select {|act| !act.barring_grathnode}
      return $game_actors[@menu_actor_id] || val[0]
    end
    return krx_grathnode_gp_ma
  end
end

#==========================================================================
# ■ Scene_Grathnode
#==========================================================================

class Scene_Grathnode < Scene_Skill
        #--------------------------------------------------------------------------
        # ● Object Initializate
        #--------------------------------------------------------------------------
  def initialize
    if KRX::SINGLE_ACTOR_INSTALL
      $game_party.menu_actor = $game_actors[KRX::SINGLE_ACTOR_INSTALL_ID]
    end
  end
        #--------------------------------------------------------------------------
        # ● Scene start
        #--------------------------------------------------------------------------
        def start
    super
    create_install_window
        end
        #--------------------------------------------------------------------------
        # ● Creates the window displaying the grathnodes currently installed
        #--------------------------------------------------------------------------
  def create_install_window
    wy = @status_window.y + @status_window.height
    ww = Graphics.width / 2
    wh = Graphics.height - wy
                @install_window = Window_GrathnodeInstall.new(ww, wy, ww, wh)
                @install_window.viewport = @viewport
    @install_window.set_handler(:ok,     method(:on_slot_ok))
    @install_window.set_handler(:cancel,     method(:on_slot_cancel))
    @item_window.install_window = @install_window
  end
        #--------------------------------------------------------------------------
        # ● Creates the window displaying the grathnodes currently owned
        #--------------------------------------------------------------------------
        def create_grathnodes_window
    wx = 0
    wy = @status_window.y + @status_window.height
    ww = Graphics.width / 2
    wh = Graphics.height - wy
    @grathnode_window = Window_GrathnodeList.new(wx, wy, ww, wh)
    @grathnode_window.viewport = @viewport
    @grathnode_window.help_window = @help_window
    @grathnode_window.refresh
    @grathnode_window.select(0)
    @grathnode_window.activate
    @grathnode_window.set_handler(:ok,     method(:on_grath_ok))
    @grathnode_window.set_handler(:cancel, method(:on_grath_cancel))
        end
        #--------------------------------------------------------------------------
        # ● Creates the window displaying the skills
        #--------------------------------------------------------------------------
        def create_item_window
    wx = 0
    wy = @status_window.y + @status_window.height
    ww = Graphics.width / 2
    wh = Graphics.height - wy
    @item_window = Window_UpSkillList.new(wx, wy, ww, wh)
    @item_window.actor = @actor
    @item_window.viewport = @viewport
    @item_window.help_window = @help_window
    @item_window.set_handler(:ok,     method(:on_item_ok))
    @item_window.set_handler(:cancel, method(:on_item_cancel))
    @command_window.skill_window = @item_window
        end
  #--------------------------------------------------------------------------
  # ● Validates the skill selection
  #--------------------------------------------------------------------------
  def on_item_ok
    @item_window.hide
    @last_index = @item_window.index
    $game_party.last_selected_skill = @item_window.item
    create_grathnodes_window
  end
  #--------------------------------------------------------------------------
  # ● Cancels the skill selection
  #--------------------------------------------------------------------------
  def on_item_cancel
    @item_window.unselect
    @item_window.update_help
    @command_window.activate
  end
  #--------------------------------------------------------------------------
  # ● Validates the slot selection
  #--------------------------------------------------------------------------
  def on_slot_ok
    sk = @item_window.item
    gr = @grathnode_window.item
    slot = @install_window.index
    @actor.add_grathnode(sk, gr, slot)
    @item_window.refresh
    @install_window.unselect
    @install_window.set_item(@item_window.item)
    @grathnode_window.refresh
    @grathnode_window.activate
  end
  #--------------------------------------------------------------------------
  # ● Cancels the slot selection
  #--------------------------------------------------------------------------
  def on_slot_cancel
    @install_window.unselect
    @grathnode_window.activate
  end
  #--------------------------------------------------------------------------
  # ● Validates the grathnode selection
  #--------------------------------------------------------------------------
  def on_grath_ok
    @install_window.activate
    @install_window.select(0)
  end
  #--------------------------------------------------------------------------
  # ● Cancels the grathnode selection
  #--------------------------------------------------------------------------
  def on_grath_cancel
    @item_window.select(@last_index)
    @item_window.show
    @item_window.activate
    @grathnode_window.dispose ; @grathnode_window = nil
  end
  #--------------------------------------------------------------------------
  # ● Confirms the actor switch
  #--------------------------------------------------------------------------
  def on_actor_change
    super
    @install_window.actor = @actor
  end
end

#==========================================================================
# ■ Window_UpSkillList
#==========================================================================
       
class Window_UpSkillList < Window_SkillList
        #--------------------------------------------------------------------------
        # ● Assigns the install window
        #--------------------------------------------------------------------------
        def install_window=(value)
                @install_window = value
        end
        #--------------------------------------------------------------------------
        # ● Determine if the skill can be selected
        #--------------------------------------------------------------------------
        def enable?(item)
                return item != nil && item.grathnode_slots > 0
        end
        #--------------------------------------------------------------------------
        # ● Refreshes the help and install windows
        #--------------------------------------------------------------------------
        def update_help
                super
                @install_window.set_item(item)
        end
        #--------------------------------------------------------------------------
        # ● Returns the number of columns
        #--------------------------------------------------------------------------
        def col_max
                return 1
        end
end

#==========================================================================
# ■ Window_GrathnodeInstall
#==========================================================================
       
class Window_GrathnodeInstall < Window_Selectable
        #--------------------------------------------------------------------------
        # ● Public instance variables
        #--------------------------------------------------------------------------
  attr_accessor   :actor
        #--------------------------------------------------------------------------
        # ● Object Initialize
        #--------------------------------------------------------------------------
        def initialize(x, y, width, height)
                super
                set_item
    @actor = $game_party.menu_actor
        end
        #--------------------------------------------------------------------------
        # ● Refresh the contents
        #--------------------------------------------------------------------------
        def set_item(item = nil)
                contents.clear
                return if item.nil?
    @data = Array.new(item.grathnode_slots, nil)
    @installs = @actor.installs[item.id]
                draw_item_installs(item)
        end
        #--------------------------------------------------------------------------
        # ● Displays the skill's current installs
        #--------------------------------------------------------------------------
        def draw_item_installs(item)
    draw_horz_line(line_height * 6)
                change_color(system_color)
                contents.draw_text(4, 0, width, line_height, KRX::VOCAB::GRATHNODE)
                change_color(normal_color)
    m = item.grathnode_slots
                (1..m).each {|i| contents.draw_text(4, line_height * i, width, line_height, "#{i}.")}
    return if @installs.nil? || @installs.empty?
                @installs.each_index do |i|
                        grath = @installs.nil? ? nil : $data_items[@installs]
                        draw_item_name(grath, 28, line_height * (i + 1), true, width - 24)
    end
    draw_mp(item) if @actor.process_grathnode_mp_cost(item).round > 0
    draw_tp(item) if @actor.process_grathnode_tp_cost(item).round > 0
  end
        #--------------------------------------------------------------------------
        # ● Displays the skill's MP inflation rate
        #--------------------------------------------------------------------------
  def draw_mp(item)
    change_color(system_color)
    contents.draw_text(4, line_height * 7, width, line_height, Vocab.basic(5))
    change_color(normal_color)
    contents.draw_text(28, line_height * 7, width, line_height,
    "+#{@actor.process_grathnode_mp_cost(item).round.to_s}%")
  end
        #--------------------------------------------------------------------------
        # ● Displays the skill's TP inflation rate
        #--------------------------------------------------------------------------
  def draw_tp(item)
    change_color(system_color)
    w = width / 4
    contents.draw_text(w, line_height * 7, width, line_height, Vocab.basic(7))
    change_color(normal_color)
    contents.draw_text(w + 28, line_height * 7, width, line_height,
    "+#{@actor.process_grathnode_tp_cost(item).round.to_s}%")
        end
        #--------------------------------------------------------------------------
        # ● Returns the number of columns
        #--------------------------------------------------------------------------
        def col_max
                return 1
        end
  #--------------------------------------------------------------------------
  # ● Returns the max number of rows
  #--------------------------------------------------------------------------
  def item_max
    @data ? @data.size : 1
  end
  #--------------------------------------------------------------------------
  # ● Sets the rectangle for selections
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new
    rect.width = item_width
    rect.height = item_height
    rect.x = index % col_max * (item_width + spacing)
    rect.y = (index / col_max * item_height) + line_height
    rect
  end
        #--------------------------------------------------------------------------
        # ● Displays an horizontal line
        #--------------------------------------------------------------------------
        def draw_horz_line(y)
                line_y = y + line_height / 2 - 1
                contents.fill_rect(0, line_y, contents_width, 2, line_color)
        end
        #--------------------------------------------------------------------------
        # ● Returns the color used for horizontal lines
        #--------------------------------------------------------------------------
        def line_color
                color = normal_color
                color.alpha = 48
                return color
        end
end

#==========================================================================
# ■ Window_GrathnodeList
#==========================================================================
       
class Window_GrathnodeList < Window_ItemList
        #--------------------------------------------------------------------------
        # ● Determine if an item goes in the list
        #--------------------------------------------------------------------------
        def include?(item)
    item.is_a?(RPG::Item) && item.grathnode?
        end
        #--------------------------------------------------------------------------
        # ● Determine if the grathnode can be used
        #--------------------------------------------------------------------------
        def enable?(item)
    return true if item.nil?
    actor = $game_party.menu_actor
    skill = $game_party.last_selected_skill
    if !actor.installs[skill.id].nil? && actor.installs[skill.id].include?(item.id)
      return false
    end
    if !item.grathnode_scope.nil? && !skill.send(item.grathnode_scope)
      return false
    end
    return true
        end
        #--------------------------------------------------------------------------
        # ● Creates the list based on the recipes
        #--------------------------------------------------------------------------
        def make_item_list
                @data = $game_party.items.select {|item| include?(item)}
    @data.push(nil)
        end
        #--------------------------------------------------------------------------
        # ● Returns the number of columns
        #--------------------------------------------------------------------------
        def col_max
                return 1
        end
end

#==========================================================================
# ■ Scene_Battle
#==========================================================================

class Scene_Battle < Scene_Base
  
  ## Yanfly's Ace Battle Engine implementation
  if $imported["YEA-BattleEngine"]
  #--------------------------------------------------------------------------
  # ● Applies the effects of the skill or item
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_sb_aie, :apply_item_effects)
  def apply_item_effects(target, item)
    apply_grathnode_effects(target, item)
    krx_grathnode_sb_aie(target, item)
  end
  #--------------------------------------------------------------------------
  # ● Applies the effects of grathnodes associated to the skill
  #--------------------------------------------------------------------------
  def apply_grathnode_effects(target, item)
    unless @subject.is_a?(Game_Actor)&& @subject.installs.keys.include?(item.id) &&
    @subject.installs[item.id] != nil
      return
    end
    @subject.installs[item.id].compact.each do |grath|
      target.item_apply(@subject, $data_items[grath])
    end
  end
  ## End of Yanfly's Ace Battle Engine implementation
  ## DBS implementation
  else
  #--------------------------------------------------------------------------
  # ● Applies the effects of the skill or item
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_sb_aie, :apply_item_effects)
  def apply_item_effects(target, item)
    krx_grathnode_sb_aie(target, item)
    apply_grathnode_effects(target, item)
  end
  #--------------------------------------------------------------------------
  # ● Applies the effects of grathnodes associated to the skill
  #--------------------------------------------------------------------------
  def apply_grathnode_effects(target, item)
    unless @subject.is_a?(Game_Actor)&& @subject.installs.keys.include?(item.id) &&
    @subject.installs[item.id] != nil || target.dead?
      return
    end
    return unless @subject.is_a?(Game_Actor)
    return if @subject.installs.nil? || @subject.installs[item.id].nil?
    @subject.installs[item.id].compact.each do |grath|
      target.item_apply(@subject, $data_items[grath])
      @log_window.display_action_results(target, $data_items[grath])
    end
  end # Method End
  end ## End of DBS implementation
end

## Menu inclusion, with Yanfly's Ace Menu Engine
if $imported["YEA-AceMenuEngine"]

#==========================================================================
# ■ Scene_Menu
#==========================================================================
       
class Scene_Menu < Scene_MenuBase
        #--------------------------------------------------------------------------
        # ● Switch to the actor selection
        #--------------------------------------------------------------------------
        def command_install
    if KRX::SINGLE_ACTOR_INSTALL
      SceneManager.call(Scene_Grathnode)
      return
    end
    @status_window.select_last
    @status_window.activate
    @status_window.set_handler(:ok,     method(:on_install_ok))
    @status_window.set_handler(:cancel, method(:on_personal_cancel))
  end
        #--------------------------------------------------------------------------
        # ● Validates the actor selection
        #--------------------------------------------------------------------------
        def on_install_ok
    SceneManager.call(Scene_Grathnode)
  end
end

#==========================================================================
# ■ Window_MenuStatus
#==========================================================================
       
class Window_MenuStatus < Window_Selectable
        #--------------------------------------------------------------------------
        # ● Determine if a party member can be selected
        #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_wms_cie?, :current_item_enabled?)
  def current_item_enabled?
    if @handler[:ok].name == :on_install_ok
      return !$game_party.members[index].barring_grathnode
    end
    return krx_grathnode_wms_cie?
  end
end

end ## End of Yanfly's Menu inclusion

## Compatibility with Yanfly's TP Manager. Deprecated with the use of Ace Skill
## Menu
=begin
if $imported["YEA-TPManager"]

#==============================================================================
# ■ Window_SkillCommand
#==============================================================================

class Window_SkillCommand < Window_Command
  #--------------------------------------------------------------------------
  # ● Aliases YF's new method
  #--------------------------------------------------------------------------
  alias_method(:krx_grathnode_wsc_tp, :add_tp_modes)
  def add_tp_modes
    return if SceneManager.scene.is_a?(Scene_Grathnode)
    krx_grathnode_wsc_tp
  end
end

#==========================================================================
#  ■  Scene_Grathnode
#==========================================================================

class Scene_Grathnode < Scene_Skill
        #--------------------------------------------------------------------------
        # ● Creates the command window
        #--------------------------------------------------------------------------
  def create_command_window
    wy = @help_window.height
    @command_window = Window_SkillCommand.new(0, wy)
    @command_window.viewport = @viewport
    @command_window.help_window = @help_window
    @command_window.actor = @actor
    @command_window.set_handler(:skill,    method(:command_skill))
    @command_window.set_handler(:cancel,   method(:return_scene))
    @command_window.set_handler(:pagedown, method(:next_actor))
    @command_window.set_handler(:pageup,   method(:prev_actor))
  end  
end


end ## End of TP Manager compatibility
=end[/pre]

Sion

这样改……我居然没发现……

1.   def add_grathnode(skill, crystal, slot)
   
2.     if @installs[skill.id].nil?
   
3.       @installs[skill.id] = Array.new(skill.grathnode_slots, nil)
   
4.     elsif @installs[skill.id][slot] != nil
   
5.       item = $data_items[@installs[skill.id][slot]]
   
6.       $game_party.gain_item(item, 1)
   
7.     end
   
8.     $game_party.lose_item(crystal, 1) unless crystal.nil?
   
9.     @installs[skill.id][slot] = crystal.nil? ? nil : crystal.id
   
10.   end

复制代码

另外，120行左右少了个等号

1. ($imported ||= {})['KRX-GrathnodeInstall'] = true

复制代码

你运行不会报错吗……