public
Rpg Maker Developers Group

Simple enough for a child, powerful enough for a developer
2 Followers
Mouse Script Compatibility Help with third Party Script

BMM Archive · July 15, 2026
BMM_Archive
LEVEL 14 Crown 47,300
Preserved forum archive. This topic stores the original first post and locally mirrored RPG Maker Web attachments when available. It is posted by the BMMPlay archive account, not by the original creator.
Original Source

Original title: Mouse Script Compatibility Help with third Party Script
Original author: Arkhanis
Original date: July 11, 2022
Source thread: https://forums.rpgmakerweb.com/threads/mouse-script-compatibility-help-with-third-party-script.149364/
Source forum path: Game Development Engines > Ruby Game System (RGSS) Scripts > RGSSx Script Support
Summary

Hi guys! Today i decided to get back to an old compatibility issue, between the Shaz's mouse script and Kread's Grathnode Install. I've created a new project, to test the compatibility and everything works good, except when i left the scene to install the grathnode on the skills, here i get the following error: {
Archived First Post

Hi guys!

Today i decided to get back to an old compatibility issue, between the Shaz's mouse script and Kread's Grathnode Install.
I've created a new project, to test the compatibility and everything works good, except when i left the scene to install the grathnode on the skills, here i get the following error:
I'm using those three script on the order bellow:
Mouse Script by Shaz
Yanfly Engine Ace - Ace Skill Menu
Grathnode Install by Kread-EX

As this script is too old and i couldn't find it anywhere else, i will post it bellow, hope it's ok to do that.


#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#  ▼ Grathnode Install
#  Author: Kread-EX
#  Version 1.11
#  Release date: 31/12/2011
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
 
#-------------------------------------------------------------------------------------------------
#  ▼ UPDATES
#-------------------------------------------------------------------------------------------------
# # 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
# # OR
# # rpgmakervxace.net
# # OR
# # rpgrevolution.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 = {} if $imported.nil?
$imported['KRX-GrathnodeInstall'] = true

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

module KRX

  ABSOLUTE_MAX_GRATHNODES = 5
  CLEAR_FORGET_SKILL = true
  SINGLE_ACTOR_INSTALL = false
  SINGLE_ACTOR_INSTALL_ID = 9
  
  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
  
  module VOCAB
    GRATHNODE = 'Grathnode'
  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
  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 += 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 += 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
    @grathnode_window.hide
  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[i]
            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)
      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, 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, grath)
      @log_window.display_action_results(target, 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
I already tried aliasing some methods, primarily the disposes on those scripts, but did not worked, i'm not really good at this.
Can anyone help me on sorting out what's happening and how to solve it?

I'm grateful for any help.

EDIT: I added the script inside the correct tags, thank you Shaz.
Downloads / Referenced Files

Log in to download
License / Terms Note

# # You can use this work for commercial purposes if you like it. # # Credit is appreciated. # # # # For support:
Creator Claims / Removal
If you are the original creator and want this listing reassigned, edited, or removed, join BMMPlay and contact the moderators with proof that matches the original RPG Maker Web profile, linked GitHub, itch.io page, or another public creator identity.
#039 #rpg-maker-archive #rgss-support
Replies (0)

No replies yet.
0 replies 1 view
Shopping Cart

Filter

Rpg Maker Developers Group
