[RGSS]Sistema de CP - Equipar Habilidades

#==============================================================================
# ? Sistema de CP
# por KGC
# modificado por Atoa
#==============================================================================
=begin
Esse script adiciona o sistema de CP que funciona como um limitador
para as habilidades que o personagem pode usar.

Os personagens ganham um novo atributo: o CP.
O CP são pontos que devem ser usados para equipar as habilidades.
Se você não tiver CPs suficientes não poderá equipar a habilidade.

O Valo máximo de CP aumenta de acordo com o nível.

Modificações por Atoa:
Agora é possivel definir o Múltiplo do CP máximo individualmente, assim cada
personagem pode ter um valor de CP diferente

Adicionado menu com a opção Equipar Habilidade.

- Configuração:
Você pode mudar vários parâmetros no modulo KGC

SCP_SKILL_MAX = X
- Define o numero máximo de Habilidades que o personagem poder equipar
  X = valor numérico

SCP_CP_COST_DEFAULT = X
- Custo de CP de Habilidades que não possuem custo individual de CP
  X = valor numérico

SCP_CP_MAX = X
- CP máximo que o personagem pode ter, independetente do seu nível.
  X = valor numérico

SCP_CP_MIN
- Mínimo de CP que cada personagem terá, independentede do seu nível.
  X = valor numérico

SCP_CP_FORMULA = Hash.new(X)
- Múltiplo de CP para os personagens que não tiveram seu CP definido individualmente
  X = Valor que será multiplicado pelo Nível do personagem
 
SCP_CP_FORMULA[ID] = X
- Múltiplo individual de CP
  X = Valor que será multiplicado pelo Nível do personagem
  ID = ID do personagem
 
SCP_DISABLE_BATTLETEST = X
- Se false desabilita o sistema de CP nas batalhas, use apenas para testes.
  X = true/false
 
SCP_DISABLE_MAPTEST = X
- Se false desabilita o sistema de CP no mapa, use apenas para testes.
  X = true/false
 
SCP_SELECT_BS_BACK_TRANSPARENT = X
- Se true adiciona efeito de transparencia ao menu de CP, use se você
  tiver um menu semi tranparente
  X = true/false
 
Definindo valor específico de CP para skill:
Para definit um valor de CP diferente do padrão para uma skill
adicione ao nome dela no database [CPX], onde X é o valor em CP
Ex.:
Média Cura [CP2]
Labareda [CP3]

Isso significa que a Skill Média cura custa 2 CPs para equipar
e a skill Labareda custa 3 CPs

Caso você não deseje usar o menu modificado com a opção de Equipar Habilidade
você pode chamar o menu de equipar com o seguinte comando
call_select_battleskill(ID)
ID = a ID da posição do personagem no grupo (um valor entre 0 e 3)

=end
module KGC
  SCP_SKILL_MAX = 8
  SCP_CP_COST_DEFAULT = 1
  SCP_CP_MAX = 20
  SCP_CP_MIN = 1

  SCP_CP_FORMULA = {} # Não altere essa linha
 
  SCP_CP_FORMULA = Hash.new(0.6)
  SCP_CP_FORMULA[1] = 0.7
  SCP_CP_FORMULA[2] = 0.5
  SCP_CP_FORMULA[7] = 0.8
  SCP_CP_FORMULA[8] = 0.9
 
  SCP_CP_NAME = "CP"

  SCP_COMMANDS = [
    "Equipar",   
    "Remover", 
    "Sair"         
  ]
  SCP_HELP = [
    "Adicionar habilidades ao personagem",           
    "Remove todas as habilidades", 
    "Voltar ao menu"       
  ]
  SCP_BLANK_TEXT = "-----------"
  SCP_RELEASE_TEXT = "- REMOVER -"
  SCP_DISABLE_BATTLETEST = true
  SCP_DISABLE_MAPTEST = true
  SCP_UNUSABLE_SKILL_SHOW = true
  SCP_SELECT_BS_BACK_TRANSPARENT = false
end


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

$imported["SkillCPSystem"] = true

#--------------------------------------------------------------------------
def call_select_battleskill(actor_index = 0)
  $game_player.straighten
  $scene = Scene_SelectBattleSkill.new(actor_index, true)
end

#==============================================================================
# ? RPG::Skill
#==============================================================================

class RPG::Skill
  #--------------------------------------------------------------------------
  def name
    return @name.gsub(/\\[.*\\]/) {""}
  end
  #--------------------------------------------------------------------------
  def original_name
    return @name
  end
  #--------------------------------------------------------------------------
  def cp_cost
    return @name =~ /\\[CP[ ]*(\\d+)\\]/i ? $1.to_i : KGC::SCP_CP_COST_DEFAULT
  end
end

#==============================================================================
# ? Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  attr_accessor :own_cp
  #--------------------------------------------------------------------------
  alias setup_KGC_SkillCPSystem setup
  def setup(actor_id)
    setup_KGC_SkillCPSystem(actor_id)
    @battle_skills = []
    @own_cp = 0
  end
  #--------------------------------------------------------------------------
 
  def max_cp
    formula = "lv".gsub(/lv/i) {"@level"}
    if KGC::SCP_CP_FORMULA[@actor_id]
      n = (Integer(eval(formula)) * KGC::SCP_CP_FORMULA[@actor_id]).to_i
    end
    n += @own_cp if @own_cp != nil
    return [[n, KGC::SCP_CP_MIN].max, KGC::SCP_CP_MAX].min
  end
  #--------------------------------------------------------------------------
  def cp
    @battle_skills = [] if @battle_skills == nil
    b_skills = self.battle_skills.compact
    if b_skills.size > 0
      n = 0
      b_skills.each { |bs|
        if (skill = $data_skills[bs]) != nil
          n += skill.cp_cost
        end
      }
      return self.max_cp - n
    else
      return self.max_cp
    end
  end
  #--------------------------------------------------------------------------
  alias skills_KGC_SkillCPSystem skills
  def skills(all_skills = false)
    if ($game_temp.in_battle && !($BTEST && KGC::SCP_DISABLE_BATTLETEST)) ||
        (!$game_temp.in_battle && KGC::SCP_DISABLE_MAPTEST ) && !all_skills
      return_skills = skills_KGC_SkillCPSystem.compact
      return_skills.each_with_index { |rs, i|
        return_skills[i] = nil if $data_skills[rs].cp_cost > 0
      }
      return (self.battle_skills | return_skills).compact.sort
    else
      return skills_KGC_SkillCPSystem.compact
    end
  end
  #--------------------------------------------------------------------------
  def battle_skills
    @battle_skills = [] if @battle_skills == nil
    if @battle_skills.size > 0
      (0...@battle_skills.size).each { |i|
        if @battle_skills[i] != nil &&
            !self.learn_skills.include?(@battle_skills[i])
          @battle_skills[i] = nil
        end
      }
    end
    return @battle_skills
  end
  #--------------------------------------------------------------------------
  def learn_skills
    return skills_KGC_SkillCPSystem
  end
  #--------------------------------------------------------------------------
  def set_battle_skill(index, skill_id)
    @battle_skills = [] if @battle_skills == nil
    @battle_skills[index] = skill_id
    restore_rev if $imported["PassiveSkill"]
  end
  #--------------------------------------------------------------------------
  def remove_battle_skill(index)
    @battle_skills = [] if @battle_skills == nil
    @battle_skills[index] = nil
    restore_rev if $imported["PassiveSkill"]
  end
  #--------------------------------------------------------------------------
  def clear_battle_skill
    @battle_skills = []
    restore_rev if $imported["PassiveSkill"]
  end
  #--------------------------------------------------------------------------
  alias forget_skill_KGC_SkillCPSystem forget_skill
  def forget_skill(skill_id)
    forget_skill_KGC_SkillCPSystem(skill_id)
    @battle_skills = [] if @battle_skills == nil
    @battle_skills.delete(skill_id)
    restore_rev if $imported["PassiveSkill"]
  end
end

#==============================================================================
# ? Window_Status
#==============================================================================
class Window_Status < Window_Base
  #--------------------------------------------------------------------------
  alias refresh_KGC_SkillCPSystem refresh
  def refresh
    refresh_KGC_SkillCPSystem
    self.contents.font.color = system_color
    self.contents.draw_text(320,112, 48, 32, KGC::SCP_CP_NAME)
    self.contents.font.color = @actor.cp == 0 ? knockout_color : normal_color
    self.contents.draw_text(356,112, 48, 32, @actor.cp.to_s, 2)
    self.contents.font.color = normal_color
    self.contents.draw_text(400,112, 24, 32, "/", 1)
    self.contents.draw_text(420,112, 48, 32, @actor.max_cp.to_s)
  end
end

#==============================================================================
# ? Window_BattleSkillCommand
#==============================================================================
class Window_BattleSkillCommand < Window_Selectable
  #--------------------------------------------------------------------------
  def initialize
    super(0, 64, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    @commands = KGC::SCP_COMMANDS
    @item_max = @commands.size
    @column_max = @commands.size
    @item_width = (width - 32) / @commands.size
    self.back_opacity = 160 if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    self.index = 0
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    for i in 0...@commands.size
      rect = Rect.new(@item_width * i, 0, @item_width, 32)
      self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
      self.contents.font.color = system_color
      self.contents.draw_text(rect, @commands[i], 1)
    end
  end
  #--------------------------------------------------------------------------
  def update_cursor_rect
    self.cursor_rect.set(@item_width * index, 0, @item_width, 32) if index != -1
  end
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(KGC::SCP_HELP[self.index])
  end
end

#==============================================================================
# ? Window_BattleSkillStatus
#==============================================================================
class Window_BattleSkillStatus < Window_Base
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 128, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.back_opacity = 160 if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_level(@actor, 140, 0)
    self.contents.font.color = system_color
    self.contents.draw_text(256, 0, 48, 32, KGC::SCP_CP_NAME)
    self.contents.font.color = @actor.cp == 0 ? knockout_color : normal_color
    self.contents.draw_text(308, 0, 32, 32, @actor.cp.to_s, 2)
    self.contents.font.color = normal_color
    self.contents.draw_text(340, 0, 24, 32, "/", 1)
    self.contents.draw_text(368, 0, 32, 32, @actor.max_cp.to_s, 2)
  end
end

#==============================================================================
# ? Window_BattleSkillSet
#==============================================================================
class Window_BattleSkillSet < Window_Selectable
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 192, 320, 288)
    self.back_opacity = 160 if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    self.active = false
    self.index = -1
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  def skill
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
      end
    @data = []
    for i in 0...KGC::SCP_SKILL_MAX
      if @actor.battle_skills[i] != nil
        skill = $data_skills[@actor.battle_skills[i]]
      else
        skill = nil
      end
      @data.push(skill)
    end
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    y = index * 32
    if skill == nil
      self.contents.font.color = disabled_color
      self.contents.draw_text(0, y, 288, 32, KGC::SCP_BLANK_TEXT, 1)
      return
    else
      self.contents.font.color = normal_color
    end
    rect = Rect.new(4, y, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    icon = RPG::Cache.icon(skill.icon_name)
    self.contents.blt(4, y + 4, icon, icon.rect)
    self.contents.draw_text(32, y, 204, 32, skill.name)
    self.contents.draw_text(236, y, 48, 32, skill.cp_cost.to_s, 2)
    self.contents.font.color = text_color(6)
    self.contents.draw_text(228, y, 32, 32, "CP")
    end
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(self.skill == nil ? "" : self.skill.description)
  end
end

#==============================================================================
# ? Window_BattleSkillList
#==============================================================================
class Window_BattleSkillList < Window_Selectable
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(320, 192, 320, 288)
    self.back_opacity = 160 if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    self.active = false
    self.index = -1
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  def skill
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = [nil]
    @actor.skills(true).each { |i|
      skill = $data_skills[i]
      if (skill != nil && skill.cp_cost > 0) && (
          (KGC::SCP_DISABLE_MAPTEST && skill.occasion != 3) ||
          (!KGC::SCP_DISABLE_MAPTEST && skill.occasion < 2) ||
          (KGC::SCP_UNUSABLE_SKILL_SHOW && skill.occasion == 3))
        @data.push(skill)
      end
    }
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    y = index * 32
    if skill == nil
      self.contents.font.color = normal_color
      self.contents.draw_text(0, y, 288, 32, KGC::SCP_RELEASE_TEXT, 1)
      return
    end
    if @actor.cp >= skill.cp_cost && !@actor.battle_skills.include?(skill.id)
      self.contents.font.color = normal_color
      opacity = 255
    else
      self.contents.font.color = disabled_color
      opacity = 128
    end
    rect = Rect.new(4, y, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    icon = RPG::Cache.icon(skill.icon_name)
    self.contents.blt(4, y + 4, icon, icon.rect, opacity)
    self.contents.draw_text(32, y, 204, 32, skill.name)
    self.contents.draw_text(236, y, 48, 32, skill.cp_cost.to_s, 2)
    self.contents.font.color = text_color(5)
    self.contents.draw_text(228, y, 32, 32, "CP")
    end
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(self.skill == nil ? "" : self.skill.description)
  end
end

#==============================================================================
# ? Scene_SelectBattleSkill
#==============================================================================
class Scene_SelectBattleSkill
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, call_map = false)
    @actor_index = actor_index
    @actor = $game_party.actors[actor_index]
    @call_map = call_map
  end
  #--------------------------------------------------------------------------
  def main
    @spriteset = Spriteset_Map.new if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    @help_window = $imported["HelpExtension"] ?
      Window_HelpExtension.new : Window_Help.new
    @help_window.back_opacity = 160 if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    @command_window = Window_BattleSkillCommand.new
    @status_window = Window_BattleSkillStatus.new(@actor)
    @set_window = Window_BattleSkillSet.new(@actor)
    @list_window = Window_BattleSkillList.new(@actor)
    @command_window.help_window = @help_window
    @set_window.help_window = @help_window
    @list_window.help_window = @help_window
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @spriteset.dispose if KGC::SCP_SELECT_BS_BACK_TRANSPARENT
    @help_window.dispose
    @command_window.dispose
    @status_window.dispose
    @set_window.dispose
    @list_window.dispose
  end
  #--------------------------------------------------------------------------
  def update
    @help_window.update
    @command_window.update
    @status_window.update
    @set_window.update
    @list_window.update
    if @command_window.active
      update_command
      return
    end
    if @set_window.active
      update_set
      return
    end
    if @list_window.active
      update_list
      return
    end
  end
  #--------------------------------------------------------------------------
  def update_command
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      if @call_map
        $scene = Scene_Map.new
      else
        if $imported["MenuAlter"]
          index = KGC::MA_COMMANDS.index(8)
          if index != nil
            $scene = Scene_Menu.new(index)
          else
            $scene = Scene_Menu.new
          end
        elsif $imported["MenuAlterAtoa"]
          $scene = Scene_Menu.new(4)
        end
      end
      return
    end
    if Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      case @command_window.index
      when 0
        @command_window.active = false
        @command_window.visible = !$imported["HelpExtension"]
        @set_window.active = true
        @set_window.index = 0 if @set_window.index == -1
      when 1
        @actor.clear_battle_skill
        @status_window.refresh
        @set_window.refresh
        @list_window.refresh
      when 2
        if @call_map
          $scene = Scene_Map.new
        else
          if $imported["MenuAlter"]
            index = KGC::MA_COMMANDS.index(8)
            if index != nil
              $scene = Scene_Menu.new(index)
            else
              $scene = Scene_Menu.new
            end
          elsif $imported["MenuAlterAtoa"]
            $scene = Scene_Menu.new(4)
          end
        end
      end
      return
    end
    if Input.trigger?(Input::R)
      $game_system.se_play($data_system.cursor_se)
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      $scene = Scene_SelectBattleSkill.new(@actor_index)
      return
    end
    if Input.trigger?(Input::L)
      $game_system.se_play($data_system.cursor_se)
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      $scene = Scene_SelectBattleSkill.new(@actor_index)
      return
    end
  end
  #--------------------------------------------------------------------------
  def update_set
    if Input.trigger?(Input::A)
      if @set_window.skill == nil
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_system.se_play($data_system.decision_se)
      @actor.remove_battle_skill(@set_window.index)
      @status_window.refresh
      @set_window.refresh
      @list_window.refresh
    end
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      @command_window.visible = true
      @set_window.active = false
      return
    end
    if Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      @set_window.active = false
      @list_window.active = true
      @list_window.index = 0 if @list_window.index == -1
    end
  end
  #--------------------------------------------------------------------------
  def update_list
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @set_window.active = true
      @list_window.active = false
      return
    end
    if Input.trigger?(Input::C)
      skill = @list_window.skill
      if skill != nil && (@actor.cp < skill.cp_cost || @actor.battle_skills.include?(skill.id))
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_system.se_play($data_system.decision_se)
      if skill == nil
        @actor.remove_battle_skill(@set_window.index)
      else
        @actor.set_battle_skill(@set_window.index, @list_window.skill.id)
      end
      @status_window.refresh
      @set_window.refresh
      @list_window.refresh
      @set_window.active = true
      @list_window.active = false
    end
  end
end

#==============================================================================
# ? Menu com opção de Equipar Habilidades
# Esse é um scene menu modificado para acrescentar a opção
# de Equipar Habilidades
# É totalmente opicional
#==============================================================================

$imported["MenuAlterAtoa"] = true

#==============================================================================
# ? Scene_Menu
#==============================================================================
class Scene_Menu
  #--------------------------------------------------------------------------
  alias main_menu main
  #--------------------------------------------------------------------------
  def main
    h1 = "Usar"
    h2 = "Equipar"
    @skill_equip_window = Window_Command.new(160, [h1, h2])
    @skill_equip_window.x = 152
    @skill_equip_window.y = 32
    @skill_equip_window.z = 999
    @skill_equip_window.index = 0
    @skill_equip_window.active = false
    @skill_equip_window.visible = false
    main_menu
  end
  #--------------------------------------------------------------------------
  def update_command
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Map.new
      return
    end
    if Input.trigger?(Input::C)
      if $game_party.actors.size == 0 and @command_window.index < 4
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      case @command_window.index
      when 0  # Itens
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Item.new
      when 1  # Habilidades
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @skill_equip_window.visible = true
        @skill_equip_window.active = true
        @skill_equip_window.index = 0
      when 2  # Equipamentos
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 3  # Status
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 4  # Salvar
        if $game_system.save_disabled
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Save.new
      when 5  # Fim de Jogo
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_End.new
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  def update
    @command_window.update
    @playtime_window.update
    @steps_window.update
    @gold_window.update
    @status_window.update
    @skill_equip_window.update
    if @command_window.active
      update_command
      return
    end
    if @status_window.active
      update_status
      return
    end
    if @skill_equip_window.active
      update_skill_equip
      return
    end
  end
  #--------------------------------------------------------------------------
  def update_status
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    if Input.trigger?(Input::C)
      case @command_window.index
      when 1  # Habilidades
        if @skill_equip_window_index == 1
          if $game_party.actors[@status_window.index].restriction >= 2
            $game_system.se_play($data_system.buzzer_se)
            return
          end
          $game_system.se_play($data_system.decision_se)
          $scene = Scene_Skill.new(@status_window.index)
        elsif @skill_equip_window_index == 2
          $game_system.se_play($data_system.decision_se)
          $scene = Scene_SelectBattleSkill.new(@status_window.index)
        end
      when 2  # Equipamento
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Equip.new(@status_window.index)
      when 3  # Status
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Status.new(@status_window.index)
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  def update_skill_equip
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      @skill_equip_window.active = false
      @skill_equip_window.visible = false
      return
    end
    if Input.trigger?(Input::C)
      case @skill_equip_window.index
      when 0  # Usar Habilidades
        $game_system.se_play($data_system.decision_se)
        @skill_equip_window.active = false
        @skill_equip_window.visible = false
        @status_window.active = true
        @status_window.index = 0
        @skill_equip_window_index = 1
      when 1  # Equipar Habilidades
        $game_system.se_play($data_system.decision_se)
        @skill_equip_window.active = false
        @skill_equip_window.visible = false
        @status_window.active = true
        @status_window.index = 0
        @skill_equip_window_index = 2
      end
      return
    end
  end
end