[XP Script] KSkillMax XP - Printable Version

Code:
#   KSkillMax XP

#   Scripter : Kyonides-Arkanthos

#   v 1.2.12 - 2016-12-02

#   Plug & Play Script



#   This script allows the game dev to limit the maximum number of skills that a

#   hero can use during gameplay. Whenever they have reached this maximum, a new

#   menu will show up to tell the player that there is a need to replace some

#   skills if they really want to learn new ones.



#   The CLEAR_SKILLS_NOT_LEARNED Constant allows the game dev to define whether

#   or not the skills heroes will not learn will be discarded before going back

#   to the map scene.



#   OPTIONAL

#     The following script calls may allow the game dev to change the maximum

#     number of skills a heroe may remember.



#   SCRIPT CALLS



#      #  INCREASE or DECREASE Maximum Number of Skills  #

#      $game_party.actors[INDEX].skill_limit += NUMBER

#      $game_party.actors[INDEX].skill_limit -= NUMBER



#      The Following Script Call is optional, you would only use it if you

#      want to let the player check and modify their unlearned skills even if

#      they didn't learn a new skill by leveling up or by purchasing a skill at

#      a skill shop (that would be possible if you add my KSkill Shop XP script

#      and place it below KSkillMax XP).

#         $scene = Scene_SkillMax.new

module KSkill

  # Maximum Number of Skills to be learned by a hero

  MAX = 3

  # Will the Maximum Number of Skills be increased by Leveling Up?

  LVLUPINCREASE = true

  # Increase of Skills After reaching specific Levels : Level => Increase

  LVLUPMAX = { 10 => 1, 20 => 1, 40 => 2 }

  # Replacement Icon Name

  OLD_SKILL_ICON = '047-Skill04'

  NEW_SKILL_ICON = '048-Skill05'

  # Buttons to display Old and New Skill Data Windows

  INFOBUTTONID = Input::A

  # Delete Skills Heroes did not learn: YES - true, NO - false or nil

  CLEAR_SKILLS_NOT_LEARNED = false

  # Help Menu Titles

  NOEXTRASKILLS = 'There is no need for any hero to learn new skills'

  REACHEDMAX = 'There are heroes that cannot learn more skills'

  REPLACESKILLS = 'Which skills do you want to replace with new ones?'

  AREYOUSURE = 'Are you really positive about applying these changes?'

  REPLACEMENTSLEFT = "Replacement Skills Left: %s"

  HEROES = 'Heroes'

  LEARNEDSKILLS = 'Learned Skills'

  NEWSKILLS = 'New Skills'

  EXITOPTIONS = ['Apply Changes', 'Review Changes', 'No Changes']

  LABELS = {} # DO NOT EDIT THIS LINE

  LABELS[nil]       = 'None'

  LABELS[:target]   = 'Target'

  LABELS[0]         = LABELS[nil]

  LABELS[1]         = '1 Enemy'

  LABELS[2]         = 'Enemies'

  LABELS[3]         = '1 Ally'

  LABELS[4]         = 'Allies'

  LABELS[5]         = 'Dead Ally'

  LABELS[6]         = 'Dead Allies'

  LABELS[7]         = 'User'

  LABELS[:cost]     = 'Cost' # Costo de Habilidad o Técnica

  LABELS[:power]    = 'Power' # Poder o Fuerza de la Técnica

  LABELS[:str]      = 'STR' # Fuerza de la Técnica

  LABELS[:int]      = 'INT' # Inteligencia de la Técnica

  LABELS[:agi]      = 'AGI' # Agilidad de la Técnica

  LABELS[:dex]      = 'DEX' # Destreza de la Técnica

  LABELS[:pdef]     = 'PDEF' # Defensa Física de la Técnica

  LABELS[:mdef]     = 'MDEF' # Defensa Mágica de la Técnica

  LABELS[:eva]      = 'EVA' # Evasión de la Técnica

  OCCASIONS = {} # DO NOT EDIT THIS LINE

  OCCASIONS[:occasion] = 'Occasion'

  OCCASIONS[0] = 'Always'

  OCCASIONS[1] = 'In Battle'

  OCCASIONS[2] = 'From Menu'

  OCCASIONS[3] = 'Never'

  # STOP! NO MORE EDITS REQUIRED

  @help_actors = []

  @replacements = 0

  LVLUPMAX.default = 0

  class << self

    attr_accessor :help_actors, :replacements, :open_menu

  end

end



class Game_Actor

  attr_accessor :pending_skills

  attr_reader :skills_not_learned

  alias kyon_skill_limit_gm_actor_init initialize

  def initialize(actor_id)

    @limit_breaker = 0

    @skills_not_learned = []

    kyon_skill_limit_gm_actor_init(actor_id)

  end



  def learn_skill(sid)

    return unless sid > 0 and !skill_learn?(sid)

    if @skills.size == KSkill::MAX + @limit_breaker

      KSkill.help_actors << @actor_id if !KSkill.help_actors.include?(@actor_id)

      @skills_not_learned << sid

      @skills_not_learned = @skills_not_learned.uniq.sort

      return

    end

    @skills << sid

    @skills.sort!

  end



  def exp=(exp)

    @exp = [[exp, 9999999].min, 0].max

    check_level_up

    check_level_down

    @hp = [@hp, self.maxhp].min

    @sp = [@sp, self.maxsp].min

  end



  def check_level_up

    old_size = @skills_not_learned.size

    while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0

      @level += 1

      self.skill_limit += KSkill::LVLUPMAX[@level] if KSkill::LVLUPINCREASE

      $data_classes[@class_id].learnings.each {|j|

        learn_skill(j.skill_id) if j.level == @level }

      @pending_skills = old_size < @skills_not_learned.size

    end

  end



  def check_level_down

    while @exp < @exp_list[@level]

      @level -= 1

      self.skill_limit -= KSkill::LVLUPMAX[@level] if KSkill::LVLUPINCREASE

    end

  end



  def skill_max() KSkill::MAX + @limit_breaker end

  def skill_limit() @limit_breaker end

  def skill_limit=(int) @limit_breaker = [int, 0].max end

end



class Window_KSkillHelp < Window_Base

  def initialize(width=640)

    super(0, 0, width, 64)

    self.contents = Bitmap.new(width - 32, height - 32)

  end



  def set_text(text, align=0)

    contents.clear

    contents.draw_text(0, 0, self.width - 32, 32, text, align)

  end

end



class Window_ActorSelection < Window_Selectable

  def initialize

    empty = KSkill.help_actors.size == 0

    h = 32 + KSkill.help_actors.size * 80

    h += 80 if empty

    super(0, 128, 120, h)

    self.contents = Bitmap.new(width - 32, height - 32)

    @item_max = KSkill.help_actors.size

    self.index = empty ? -2 : 0

    refresh unless empty

  end



  def refresh

    self.contents.clear

    self.contents.font.bold, self.contents.font.size = true, 18

    ny, sy = -80, -64

    KSkill.help_actors.each {|id| actor = $data_actors[id]

      self.contents.draw_text(0, ny += 80, 88, 28, actor.name, 1)

      draw_actor_graphic(actor, 44, ny + 74) }

  end



  def update_cursor_rect

    return if @item_max == 1

    self.cursor_rect.set(0, @index * 80, 88, 80)

  end

end



class Window_ActorSkills < Window_Selectable

  attr_reader :replaced, :replace_index

  def initialize

    super(120, 128, 260, 288)

    @replaced = {}

    one_choice = KSkill.help_actors.size == 1

    self.index = one_choice ? 0 : -1

  end



  def replace_skills?() @replaced[@actor_id].size > 0 end

  def replace_max() @replaced[@actor_id].size end

  def skill_id() @data[@index].id end



  def refresh

    self.contents.dispose if self.contents

    @data = []

    @actor.skills.size.times {|i| skill = $data_skills[@actor.skills[i]]

      @data << skill if skill != nil }

    @item_max = @data.size

    return unless @item_max > 0

    self.contents = Bitmap.new(width - 32, row_max * 32)

    self.contents.font.size = 20

    self.contents.font.bold = true

    @item_max.times {|i| draw_item(i) }

  end



  def actor=(new_actor)

    @actor, @actor_id, @index = new_actor, new_actor.id, 0

    @replaced[@actor_id] ||= []

    refresh

  end



  def update_replacement_check

    if !@replaced[@actor_id].include?(@index)

      if KSkill.replacements == 0

        $game_system.se_play($data_system.buzzer_se)

        return @replace_index = nil

      elsif @replaced[@actor_id].size < @actor.skills_not_learned.size

        $game_system.se_play($data_system.decision_se)

        @replaced[@actor_id] << @index

        KSkill.replacements -= 1

        @replace_index = @index

      else

        $game_system.se_play($data_system.buzzer_se)

        return @replace_index = nil

      end

    else

      $game_system.se_play($data_system.decision_se)

      @replaced[@actor_id].delete(@index)

      KSkill.replacements += 1

      @replace_index = nil

    end

    refresh

  end



  def draw_item(index)

    skill, y = @data[index], index * 32

    rect = Rect.new(4, y, self.width - 32, 32)

    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

    if @replaced[@actor_id].include?(index)

      bitmap = RPG::Cache.icon(KSkill::OLD_SKILL_ICON)

      self.contents.blt(0, y + 4, bitmap, Rect.new(0, 0, 24, 24))

    end

    bitmap = RPG::Cache.icon(skill.icon_name)

    self.contents.blt(28, y + 4, bitmap, Rect.new(0, 0, 24, 24))

    self.contents.draw_text(60, y, 204, 32, skill.name, 0)

  end



  def dispose

    @replaced.clear

    @replaced = nil

    super

  end

end



class Window_NewSkills < Window_Selectable

  attr_reader :selected

  attr_writer :replace_max

  def initialize(index, skills)

    super(380, 128, 260, 288)

    self.index = index

    @skills = skills

    self.active = nil

    @replace_max = 0

    @selected = {}

    @s = []

    @data = []

    ds = $data_skills

    @skills.each{|d| @s[@s.size] = d.map{|i| [id,ds[i].icon_name,ds[i].name]}}

    @actor_index = 0 if @skills.size == 1

    refresh unless index < 0

  end



  def skills_size() @item_max end

  def skill_ids() @data.map {|values| values[0] } end



  def skills(actor_index, new_index, new_skills)

    @actor_index = actor_index

    self.index = new_index

    @skills = new_skills

    refresh

  end



  def update_single_skill

    @selected[@actor_index][0] = 0

    refresh

  end



  def update_selection

    $game_system.se_play($data_system.decision_se)

    reached_max = @replace_max == @selected[@actor_index].compact.size

    selected = @selected[@actor_index].include?(@index)

    @selected[@actor_index][@index] = ((reached_max or selected)? nil : @index)

    refresh

  end



  def refresh

    self.contents.dispose if self.contents

    @data = @s[@actor_index]

    @item_max = @data.size

    return unless @item_max > 0

    @selected[@actor_index] ||= Array.new(@item_max, nil)

    self.contents = Bitmap.new(width - 32, @item_max * 32)

    self.contents.font.size = 20

    self.contents.font.bold = true

    @item_max.times {|i| draw_item(i) }

  end



  def draw_item(index)

    skill, y = @data[index], index * 32

    rect = Rect.new(4, y, self.width - 32, 32)

    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

    if @selected[@actor_index].include?(index) 

      bitmap = RPG::Cache.icon(KSkill::NEW_SKILL_ICON)

      self.contents.blt(0, y + 4, bitmap, Rect.new(0, 0, 24, 24))

    end

    bitmap = RPG::Cache.icon(skill[1])

    self.contents.blt(28, y + 4, bitmap, Rect.new(0, 0, 24, 24))

    self.contents.draw_text(60, y, 204, 32, skill[2], 0)

  end



  def dispose

    @data.clear

    @s.clear

    super

  end

end



class Window_KSkillData < Window_Selectable

  def initialize(new_x, new_y)

    super(new_x, new_y, 272, 256)

    self.contents = Bitmap.new(width - 32, height - 32)

    self.z += 100

    @skill = nil

    refresh if @skill

  end



  def skill_id=(new_skill_id)

    @skill = $data_skills[new_skill_id]

    refresh

  end



  def refresh

    self.contents.clear

    draw_skill_labels

    draw_skill_data

  end



  def draw_skill_labels

    labels = KSkill::LABELS

    contents.font.color = system_color

    contents.draw_text(0, 28, 240, 28, labels[:target])

    contents.draw_text(0, 56, 240, 28, KSkill::OCCASIONS[:occasion])

    contents.draw_text(0, 84, 240, 28, labels[:cost])

    contents.draw_text(124, 84, 240, 28, labels[:power])

    contents.draw_text(0, 112, 240, 28, labels[:str])

    contents.draw_text(124, 112, 240, 28, labels[:int])

    contents.draw_text(0, 140, 240, 28, labels[:agi])

    contents.draw_text(124, 140, 240, 28, labels[:dex])

    contents.draw_text(0, 168, 240, 28, labels[:pdef])

    contents.draw_text(124, 168, 240, 28, labels[:mdef])

    contents.draw_text(0, 196, 240, 28, labels[:eva])

  end



  def draw_skill_data

    contents.font.color = normal_color

    bitmap = RPG::Cache.icon(@skill.icon_name)

    contents.blt(0, 4, bitmap, Rect.new(0, 0, 24, 24))

    contents.draw_text(32, 0, 204, 32, @skill.name, 0)

    contents.draw_text(0, 28, 240, 28, KSkill::LABELS[@skill.scope], 2)

    contents.draw_text(0, 56, 240, 28, KSkill::OCCASIONS[@skill.occasion], 2)

    contents.draw_text(0, 84, 108, 28, @skill.sp_cost.to_s, 2)

    contents.draw_text(0, 84, 240, 28, @skill.power.abs.to_s, 2)

    contents.draw_text(0, 112, 108, 28, @skill.str_f.to_s, 2)

    contents.draw_text(0, 112, 240, 28, @skill.int_f.to_s, 2)

    contents.draw_text(0, 140, 108, 28, @skill.agi_f.to_s, 2)

    contents.draw_text(0, 140, 240, 28, @skill.dex_f.to_s, 2)

    contents.draw_text(0, 168, 108, 28, @skill.pdef_f.to_s, 2)

    contents.draw_text(0, 168, 240, 28, @skill.mdef_f.to_s, 2)

    contents.draw_text(0, 196, 108, 28, @skill.eva_f.to_s, 2)

  end

end



class Interpreter

  def command_315

    value = operate_value(@parameters[1], @parameters[2], @parameters[3])

    iterate_actor(@parameters[0]){|actor| actor.exp += value }

    pending = $game_party.actors.select{|actor| actor.pending_skills }.size

    KSkill.open_menu = (!KSkill.help_actors.empty? and pending > 0)

    $game_party.actors.each {|actor| actor.pending_skills = nil }

    return true

  end

end



class Scene_Map

  alias kyon_kskillmax_scn_map_up update

  def update

    kyon_kskillmax_scn_map_up

    return unless KSkill.open_menu and !$game_temp.message_window_showing

    $scene = Scene_KSkillMax.new

  end

end



class Scene_Load

  alias kyon_kskillmax_scn_load_rsd read_save_data

  def read_save_data(file)

    kyon_kskillmax_scn_load_rsd(file)

    actors = $game_party.actors

    actors.each {|a| KSkill.help_actors << a.id if !a.skills_not_learned.empty?}

  end

end



class Scene_Battle

  def battle_end(result)

    $game_temp.in_battle = false

    $game_party.clear_actions

    $game_party.actors.each {|actor| actor.remove_states_battle }

    $game_troop.enemies.clear

    if $game_temp.battle_proc != nil

      $game_temp.battle_proc.call(result)

      $game_temp.battle_proc = nil

    end

    $scene = KSkill.help_actors.empty? ? Scene_Map.new : Scene_KSkillMax.new

  end

end



class Scene_KSkillMax

  def initialize

    KSkill.open_menu = nil

    @skills = []

    @actors = []

    actors = $game_party.actors

    KSkill.replacements = 0

    actors.each {|a| skills = a.skills_not_learned

      next if skills.empty?

      number = [a.skill_max, skills.size].min

      next if number == 0

      KSkill.replacements += number

      @skills << skills

      @actors << a }

  end



  def main

    make_help_windows

    make_status_windows

    make_skill_windows

    @command_window = Window_Command.new(200, KSkill::EXITOPTIONS)

    @command_window.x = (640 - @command_window.width) / 2

    @command_window.y = (480 - @command_window.height) / 2

    @command_window.visible = nil

    @command_window.active = nil

    Graphics.transition

    loop do

      Graphics.update

      Input.update

      update

      break if $scene != self

    end

    Graphics.freeze

    @command_window.dispose

    @new_status_window.dispose

    @old_status_window.dispose

    @replace_window.dispose

    @skill_window.dispose

    @selection_window.dispose

    @help_windows.each {|window| window.dispose }

  end



  def make_status_windows

    @old_status_window = Window_KSkillData.new(368, 128)

    @old_status_window.visible = false

    @new_status_window = Window_KSkillData.new(108, 128)

    @new_status_window.visible = false

  end



  def make_help_windows

    @help_windows = [Window_KSkillHelp.new, Window_KSkillHelp.new(120)]

    @help_windows += [Window_KSkillHelp.new(260), Window_KSkillHelp.new(260)]

    @help_windows[4] = Window_KSkillHelp.new(520)

    @help_windows[2].x = 120

    @help_windows[3].x = 380

    @help_windows[4].x = 120

    @help_windows[1].y = @help_windows[2].y = @help_windows[3].y = 64

    @help_windows[4].y = 416

    @empty = KSkill.replacements == 0

    text = @empty ? KSkill::NOEXTRASKILLS : KSkill::REACHEDMAX

    @help_windows[0].set_text(text, 1)

    @help_windows[1].set_text(KSkill::HEROES, 1)

    @help_windows[2].set_text(KSkill::LEARNEDSKILLS, 1)

    @help_windows[3].set_text(KSkill::NEWSKILLS, 1)

    text = sprintf(KSkill::REPLACEMENTSLEFT, KSkill.replacements)

    @help_windows[4].set_text(text, 1)

  end



  def make_skill_windows

    @selection_window = Window_ActorSelection.new

    @skill_window = Window_ActorSkills.new

    if KSkill.help_actors.size == 1

      @selection_window.active = nil

      @skill_window.active = true

      @skill_window.actor = $game_actors[KSkill.help_actors[0]]

      @skill_window.index = 0

      @replace_window = Window_NewSkills.new(0, @skills)

      @help_windows[0].set_text(KSkill::REPLACESKILLS, 1)

    else

      @skill_window.active = nil

      @replace_window = Window_NewSkills.new(-1, @skills)

    end

  end



  def update

    @help_windows[0].update

    @selection_window.update

    @skill_window.update

    @replace_window.update

    @old_status_window.update

    @new_status_window.update

    @command_window.update

    if @selection_window.active

      update_actor_selection

      return

    elsif @skill_window.active

      update_skill_selection

      return

    elsif @replace_window.active

      update_replace_selection

      return

    elsif @old_status_window.visible

      update_old_skills_data

      return

    elsif @new_status_window.visible

      update_new_skills_data

      return

    elsif @command_window.active

      update_exit_selection

      return

    end

  end



  def update_skills_info

    @help_windows[0].set_text(KSkill::REPLACESKILLS, 1)

    @skill_window.actor = actor = @actors[@selection_window.index]

    @replace_window.skills(@selection_window.index, 0, @skills)

    @selection_window.active = nil

    @skill_window.active = true

    @skill_window.index = 0

  end



  def update_actor_selection

    if Input.trigger?(Input::B)

      $game_system.se_play($data_system.cancel_se)

      if @empty

        $scene = Scene_Map.new

        return

      end

      @help_windows[0].set_text(KSkill::AREYOUSURE, 1)

      @selection_window.active = nil

      @command_window.active = true

      @command_window.visible = true

    elsif Input.trigger?(Input::C)

      if @actors[@selection_window.index].nil?

        $scene = Scene_Map.new

        return

      elsif @actors[@selection_window.index].skills_not_learned.empty?

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      $game_system.se_play($data_system.decision_se)

      update_skills_info

    end

  end



  def update_skill_selection

    if Input.trigger?(Input::B)

      size1 = @skill_window.replaced.values.flatten.size

      size2 = @replace_window.selected.values.flatten.compact.size

      if size1 != size2

        $game_system.se_play($data_system.buzzer_se)

        return

      end

      $game_system.se_play($data_system.cancel_se)

      @help_windows[0].set_text(KSkill::REACHEDMAX, 1)

      @skill_window.active = nil

      if KSkill.help_actors.size == 1

        @help_windows[0].set_text(KSkill::AREYOUSURE, 1)

        @command_window.active = true

        @command_window.visible = true

      else

        @selection_window.active = true

      end

      @skill_window.index = -1

      @replace_window.index = -1

      if @skill_window.contents

        @skill_window.contents.clear

        @replace_window.contents.clear

      end

      return

    elsif Input.trigger?(Input::C)

      @skill_window.update_replacement_check

      text = sprintf(KSkill::REPLACEMENTSLEFT, KSkill.replacements)

      @help_windows[4].set_text(text, 1)

      return

    elsif Input.trigger?(KSkill::INFOBUTTONID)

      $game_system.se_play($data_system.decision_se)

      actor_id = KSkill.help_actors[@selection_window.index]

      @actor_skills = $game_actors[actor_id].skills

      @skills_size = @actor_skills.size

      @skill_index = @skill_window.index

      @old_status_window.skill_id = @skill_window.skill_id

      @skill_window.active = false

      @old_status_window.visible = true

      return

    elsif Input.trigger?(Input::L) or Input.trigger?(Input::R)

      update_active_window

    elsif Input.trigger?(Input::LEFT) or Input.trigger?(Input::RIGHT)

      update_active_window

    end

  end



  def update_replace_selection

    if Input.trigger?(Input::B) or Input.trigger?(Input::LEFT)

      $game_system.se_play($data_system.cancel_se)

      @replace_window.active = nil

      @skill_window.active = true

      return

    elsif Input.trigger?(KSkill::INFOBUTTONID)

      $game_system.se_play($data_system.decision_se)

      @actor_skills = @actors[@selection_window.index].skills_not_learned

      @skills_size = @actor_skills.size

      @skill_index = 0

      @new_status_window.skill_id = @actor_skills[0]

      @replace_window.active = false

      @new_status_window.visible = true

    elsif Input.trigger?(Input::C)

      @replace_window.update_selection

    end

  end



  def update_old_skills_data

    if Input.trigger?(Input::B) or Input.trigger?(KSkill::INFOBUTTONID)

      $game_system.se_play($data_system.cancel_se)

      $game_system

      @actor_skills = []

      @old_status_window.visible = false

      @skill_window.active = true

    elsif Input.trigger?(Input::UP)

      if @skills_size == 1

        $game_system.se_play($data_system.cancel_se)

        return

      end

      @skill_index = (@skill_index + @skills_size - 1) % @skills_size

      @old_status_window.skill_id = @actor_skills[@skill_index]

    elsif Input.trigger?(Input::DOWN)

      if @skills_size == 1

        $game_system.se_play($data_system.cancel_se)

        return

      end

      @skill_index = (@skill_index + 1) % @skills_size

      @old_status_window.skill_id = @actor_skills[@skill_index]

    end

  end



  def update_new_skills_data

    if Input.trigger?(Input::B) or Input.trigger?(KSkill::INFOBUTTONID)

      $game_system.se_play($data_system.cancel_se)

      @actor_skills = []

      @new_status_window.visible = false

      @replace_window.active = true

    elsif Input.trigger?(Input::UP)

      if @skills_size == 1

        $game_system.se_play($data_system.cancel_se)

        return

      end

      @skill_index = (@skill_index + @skills_size - 1) % @skills_size

      @new_status_window.skill_id = @actor_skills[@skill_index]

    elsif Input.trigger?(Input::DOWN)

      if @skills_size == 1

        $game_system.se_play($data_system.cancel_se)

        return

      end

      @skill_index = (@skill_index + 1) % @skills_size

      @new_status_window.skill_id = @actor_skills[@skill_index]

    end

  end



  def update_active_window

    $game_system.se_play($data_system.decision_se)

    @skill_window.active = nil

    @replace_window.replace_max = @skill_window.replace_max

    @replace_window.active = true

  end



  def update_exit_selection

    if Input.trigger?(Input::C)

      $game_system.se_play($data_system.decision_se)

      case @command_window.index

      when 0

        actor_index = -1

        @actors.each {|actor| id, actor_index = actor.id, actor_index + 1

          next if @skill_window.replaced[id].nil?

          index = -1

          s = @replace_window.selected[actor_index].compact

          @skill_window.replaced[id].each {|ix| index += 1

            not_learned = @actors[actor_index].skills_not_learned

            @actors[actor_index].skills[ix] = not_learned[s[index]]

            not_learned[s[index]] = nil }

            @actors[actor_index].skills_not_learned.compact! }

        clear_skills_info

      when 1

        @selection_window.active = true

        @command_window.active = @command_window.visible = nil

      when 2 then clear_skills_info end

      $scene = Scene_Map.new unless @command_window.index == 1

    end

  end



  def clear_skills_info

    KSkill.help_actors.delete_if {|i| $game_actors[i].skills_not_learned.empty?}

    return unless KSkill::CLEAR_SKILLS_NOT_LEARNED

    KSkill.help_actors.each {|id| $game_actors[id].skills_not_learned.clear }

    KSkill.help_actors.clear

  end

end