¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 KSkillMax XP y VX el Sáb Sep 08, 2018 7:13 am

Reputación del mensaje :100% (2 votos)

kyonides

avatar
KSkillMax XP y VX



por Kyonides-Arkanthes


Introducción

Este script existe para simular una situación como la de Pokemon donde Uds. pueden ponerle un límite a la cantidad de técnicas o skills que cada héroe puede aprender en el transcurso del juego. Digamos que le ponen de límite 6 técnicas, entonces cuando vayan a aprender la sétima, tendrán que escoger entre dejarla ahí en espera o ignorarla o aprenderla. Lo último hará que olviden una técnica anterior inmediatamente.

Captura de Pantalla



Versión para XP
Código:
#   KSkillMax XP
#   Scripter : Kyonides-Arkanthes
#   v 1.2.13 - 2016-12-05
#   Plug & Play Script


#   Este script les permite limitar el número de técnicas que sus héroes pueden
#   aprender durante el juego. Cuando están por rebasar el límite, aparecerá
#   un menú para que el jugador elija cuáles técnicas desea reemplazar, si es
#   que desea reemplazar alguna por otra nueva...

#   En la Constante CLEAR_SKILLS_NOT_LEARNED Uds. deciden si las Técnicas
#   serán descartadas al regresar al mapa o guardadas para usarlas en el futuro.

#   OPCIONAL
#      Hay 2 llamados a script que pueden cambiar el número máximo de técnicas
#      que cada héroe puede mantener en su lista de técnicas aprendidas.


#   LLAMADOS A SCRIPT

#      AUMENTAR o DISMINUIR Límite de Técnicas
#         $game_party.actors[INDICE].skill_limit += NUMERO
#         $game_party.actors[INDICE].skill_limit -= NUMERO

#      # Este Llamado No Es Necesario a menos que quieran que el jugador pueda
#      # revisar las técnicas sin aprender en algún momento que Uds. definan y
#      # que se deba a que algún héroe subió de nivel.
#         $scene = Scene_KSkillMax.new

module KSkill
  # Máximo Número Permitido de Técnicas por Actor
  MAX = 3
  # ¿Se Incrementará el Máximo según el Héroe suba de Nivel?
  LVLUPINCREASE = true
  # Incremento de Máximo de Técnicas Por Nivel del Héroe : Nivel => Incremento
  LVLUPMAX = { 10 => 1, 20 => 1, 40 => 2 }
  # Iconos que indican qué técnica será reemplazada por cuál otra
  OLD_SKILL_ICON = '047-Skill04'
  NEW_SKILL_ICON = '048-Skill05'
  # Botón para desplegar Info de Técnicas Viejas y Nuevas
  INFOBUTTONID = Input::A
  # Borrado de Técnicas No Aprendidas: SI - true, NO - false o nil
  CLEAR_SKILLS_NOT_LEARNED = nil
  # Frases que aparecerán en el Menú
  NOEXTRASKILLS = 'No hay ningún héroe con técnicas por aprender'
  REACHEDMAX = 'En tu equipo hay héroes que no pueden aprender más técnicas'
  REPLACESKILLS = '¿Cuáles técnicas deseas reemplazar?'
  AREYOUSURE = '¿Realmente desea aplicar estos cambios?'
  REPLACEMENTSLEFT = "No se han asignado %s reemplazos"
  HEROES = 'Héroes'
  LEARNEDSKILLS = 'Técnicas Actuales'
  NEWSKILLS = 'Técnicas Nuevas'
  EXITOPTIONS = ['Aplicar Cambios', 'Revisar Cambios', 'Sin Cambios']
  LABELS = {} # NO EDITAR ESTA LINEA
  LABELS[nil]       = 'Ninguno'
  LABELS[:target]   = 'Objetivo'
  LABELS[0]         = LABELS[nil]
  LABELS[1]         = '1 Enemigo'
  LABELS[2]         = 'Enemigos'
  LABELS[3]         = '1 Aliado'
  LABELS[4]         = 'Aliados'
  LABELS[5]         = '1 Aliado Muerto'
  LABELS[6]         = 'Aliados Muertos'
  LABELS[7]         = 'Usuario'
  LABELS[:cost]     = 'Costo' # Costo de Habilidad o Técnica
  LABELS[:power]    = 'Poder' # 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 = {} # NO EDITAR ESTA LINEA
  OCCASIONS[:occasion] = 'Ocasión'
  OCCASIONS[0] = 'Siempre'
  OCCASIONS[1] = 'En Batalla'
  OCCASIONS[2] = 'En Menú'
  OCCASIONS[3] = 'Nunca'
  # No Modifique Nada Más
  @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)
      index = @selection_window.index
      if @actors[index].nil?
        $scene = Scene_Map.new
        return
      elsif @actors[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
        if @actors.size > 1
          @selection_window.active = true
        else
          update_skills_info
        end
        @command_window.active = nil
        @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

Versión para VX
Código:
#  KSkillMax VX
#  VX v 1.2.2 - 2016-12-02
#  Scripter : Kyonides-Arkanthos
#  Plug & Play Script

#  Este script les permite limitar el número de técnicas que sus héroes pueden
#  aprender durante el juego. Cuando están por rebasar el límite, aparecerá
#  un menú para que el jugador elija cuáles técnicas desea reemplazar, si es
#  que desea reemplazar alguna por otra nueva...

#  Las Técnicas que no sean aprendidas pueden ser descartadas si el valor de las
#  Constate CLEAR_SKILLS_NOT_LEARNED es nil. Si es true, se mantendrán ahí.

#  OPCIONAL  -  A Partir de Versión 1.1.0

#    Los siguientes llamados a script pueden cambiar el número máximo de
#    técnicas que el héroe puede mantener en su lista.

#    Además pueden presionar 1 de 2 botones para revisar los datos de las
#    Técnicas Viejas o Nuevas para poder tomar una mejor decisión.

#  LLAMADOS A SCRIPT

#      $game_paty.members[INDICE].increase_skill_limit(NUMERO)  ##  AUMENTA
#      $game_paty.members[INDICE].decrease_skill_limit(NUMERO)  ##  DISMINUYE

module KSkill
  # Máximo Número Permitido de Técnicas por Actor
  MAX = 3
  # Icono que indica qué técnica será reemplazada
  ICON = '047-Skill04'
  # ¿Se Incrementará el Máximo según el Héroe suba de Nivel?
  LVLUPINCREASE = true
  # Incremento de Máximo de Técnicas Por Nivel del Héroe : Nivel => Incremento
  LVLUPMAX = { 10 => 1, 20 => 1, 40 => 2 }
  # Botones que abren Ventana de Info de Técnicas Viejas y Nuevas
  OLDBUTTONID = Input::A
  NEWBUTTONID = Input::X
  # Borrado de Técnicas No Aprendidas: SI - true, NO - false o nil
  CLEAR_SKILLS_NOT_LEARNED = nil
  # Frases que aparecerán en el Menú
  REACHEDMAX = 'Hay héroes que no pueden aprender más técnicas'
  REPLACESKILLS = '¿Cuáles técnicas deseas reemplazar?'
  AREYOUSURE = '¿Realmente desea aplicar estos cambios?'
  REPLACEMENTSLEFT = "No se han asignado %s reemplazos"
  HEROES = 'Héroes'
  LEARNEDSKILLS = 'Técnicas Actuales'
  NEWSKILLS = 'Técnicas Nuevas'
  EXITOPTIONS = ['Aplicar Cambios', 'Revisar Cambios', 'Sin Cambios']
  LABELS = {} # NO EDITAR ESTA LINEA
  LABELS[:increase] = 'Incremento'
  LABELS[nil]      = 'Ninguno'
  LABELS[:target]  = 'Objetivo'
  LABELS[0]        = LABELS[nil]
  LABELS[1]        = '1 Enemigo'
  LABELS[2]        = 'Enemigos'
  LABELS[3]        = 'Doble vs. Enemigo'
  LABELS[4]        = 'Enemigo Aleatorio'
  LABELS[5]        = '2 Enemigos Aleat.'
  LABELS[6]        = '3 Enemigos Aleat.'
  LABELS[7]        = '1 Aliado'
  LABELS[8]        = 'Aliados'
  LABELS[9]        = '1 Aliado Muerto'
  LABELS[10]        = 'Aliados Muertos'
  LABELS[11]        = 'Usuario'
  LABELS[:hitrate]  = '% Éxito'
  LABELS[:speed]    = 'Velocidad'
  LABELS[:hp]      = 'MAXHP'
  LABELS[:sp]      = 'MAXSP'
  LABELS[:cost]    = 'Costo' # Costo de Habilidad o Técnica
  LABELS[:damage]  = 'Daño' # Daño Base
  LABELS[:power_p]  = 'Poder F.' # Poder Físico
  LABELS[:power_m]  = 'Pdr M.' # Poder Mental o Mágico
  LABELS[:mp_dmg]  = 'Daño PM' # Daño a Puntos de Mana
  LABELS[:absorb]  = 'Absorbe Daño'
  LABELS[:ignore]  = 'Ignora Defensa'
  OCCASIONS = {} # NO EDITAR ESTA LINEA
  OCCASIONS[:occasion] = 'Ocasión'
  OCCASIONS[0] = 'Siempre'
  OCCASIONS[1] = 'En Batalla'
  OCCASIONS[2] = 'En Menú'
  OCCASIONS[3] = 'Nunca'
  # No Modifique Nada Más
  @help_actors = []
  @not_learned = {}
  @replacements = 0
  LVLUPMAX.default = 0
  @open_menu = nil
  class << self
    attr_accessor :help_actors, :not_learned, :replacements, :open_menu
  end
end

class Game_Actor
  alias kyon_skill_limit_gm_actor_init initialize
  alias kyon_skill_limit_gm_actor_lvlup level_up
  alias kyon_skill_limit_gm_actor_lvldown level_down
  def initialize(actor_id)
    @limit_breaker = 0
    KSkill.not_learned[actor_id] = []
    kyon_skill_limit_gm_actor_init(actor_id)
  end

  def learn_skill(sid)
    return unless sid > 0 and !skill_learn?($data_skills[sid])
    if @skills.size == KSkill::MAX + @limit_breaker
      KSkill.help_actors << @actor_id
      KSkill.help_actors = KSkill.help_actors.uniq.sort
      KSkill.not_learned[@actor_id] << sid
      KSkill.not_learned[@actor_id] = KSkill.not_learned[@actor_id].uniq.sort
      KSkill.open_menu = true
      return
    end
    @skills << sid
    @skills.sort!
  end

  def level_up
    kyon_skill_limit_gm_actor_lvlup
    @limit_breaker += KSkill::LVLUPMAX[@level] if KSkill::LVLUPINCREASE
    extra = KSkill::MAX + @limit_breaker - @skills.size
    return unless extra > 0 and !KSkill.not_learned[@actor_id].empty?
    learn_skill(KSkill.not_learned[@actor_id].shift)
    KSkill.help_actors.delete(@actor_id) if KSkill.not_learned[@actor_id].empty?
  end

  def level_down
    kyon_skill_limit_gm_actor_lvldown
    @limit_breaker -= KSkill::LVLUPMAX[@level] if KSkill::LVLUPINCREASE
  end

  def replace_skill(index, value) @skills[index] = value end
  def increase_skill_limit(int) @limit_breaker += int end
  def decrease_skill_limit(int) @limit_breaker -= int end
end

class Window_SkillHelp < Window_Base
  def initialize(width=544)
    super(0, 0, width, 56)
    contents = Bitmap.new(width - 32, height - 32)
  end

  def set_text(text, align=0)
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 0, self.width - 40, WLH, text, align)
  end
end

class Window_ActorSelection < Window_Selectable
  def initialize
    super(0, 112, 120, (KSkill.help_actors.size * 68) + 32)
    contents = Bitmap.new(width - 32, height - 32)
    self.index, @item_max = 0, KSkill.help_actors.size
    refresh
  end

  def refresh
    contents.clear
    contents.font.bold = true
    self.contents.font.size = 18
    ny, sy = -72, -56
    KSkill.help_actors.each {|id| actor = $data_actors[id]
    contents.draw_text(0, ny += 72, 92, 24, actor.name, 1)
    draw_actor_graphic(actor, 44, ny + 60) }
  end

  def item_rect(index)
    rect = Rect.new(0, 0, 0, 0)
    rect.width = (contents.width + @spacing) / @column_max - @spacing
    rect.height = WLH
    rect.x = index % @column_max * (rect.width + @spacing)
    rect.y = index / @column_max * 72
    rect
  end
end

class Window_ActorSkills < Window_Selectable
  attr_reader :replaced
  def initialize
    super(120, 112, 212, 248)
    @replaced = {}
    self.index = KSkill.help_actors.size == 1 ? 0 : -1
  end

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

  def refresh
    contents.dispose if self.contents
    @data = @actor.skills
    @item_max = @data.size
    return if @item_max == 0
    self.contents = Bitmap.new(width - 32, [height - 32, row_max * WLH].max)
    @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 @replaced[@actor_id].size < KSkill.not_learned[@actor_id].size
        Sound.play_decision
        @replaced[@actor_id] << @index
        KSkill.replacements -= 1
      else
        Sound.play_buzzer
        return
      end
    else
      Sound.play_decision
      @replaced[@actor_id].delete(@index)
      KSkill.replacements += 1
    end
    refresh
  end

  def draw_item(index)
    skill, y = @data[index], index * WLH
    rect = Rect.new(4, y, self.width - 32, 32)
    icon_index = !@replaced[@actor_id].include?(index)? skill.icon_index : 143
    draw_icon(icon_index, 0, y)
    contents.draw_text(32, y, 188, WLH, skill.name, 0)
  end

  def dispose
    @replaced.clear
    @replaced = nil
    super
  end
end

class Window_NewSkills < Window_Base
  attr_accessor :index
  def initialize(activate)
    super(332, 112, 212, 248)
    @index = activate ? 0 : -1
    refresh if activate
  end

  def skill_id() @data[index] end

  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32, height - 32)
  end

  def refresh
    @data = KSkill.not_learned[KSkill.help_actors[@index]].dup
    @item_max = @data.size
    return unless @item_max > 0
    contents.clear if contents
    contents = Bitmap.new(width - 32, @item_max * 32)
    @item_max.times {|i| draw_item(i) }
  end

  def draw_item(index)
    skill_id, y = @data[index], index * WLH
    rect = Rect.new(4, y, self.width - 32, 32)
    draw_icon($data_skills[skill_id].icon_index, 0, y)
    contents.draw_text(32, y, 188, WLH, $data_skills[skill_id].name, 0)
  end
end

class Window_SkillStatusExtended < Window_Base
  def initialize(x, y, skill=nil)
    super(x, y, 250, 264)
    @skill = skill
    return unless skill
    refresh
  end

  def skill_id=(new_skill_id)
    @skill = $data_skills[new_skill_id]
    refresh
  end

  def refresh
    self.contents.clear
    rect = Rect.new(4, 0, self.width - 32, 32)
    draw_icon($data_skills[@skill.id].icon_index, 0, 0)
    contents.font.color = system_color
    contents.font.color.alpha = 255
    contents.draw_text(0, 52, 140, 24, KSkill::OCCASIONS[:occasion])
    contents.draw_text(0, 78, 140, 24, KSkill::LABELS[:cost])
    contents.draw_text(108, 78, 160, 24, KSkill::LABELS[:hitrate])
    contents.draw_text(0, 104, 218, 24, KSkill::LABELS[:speed])
    contents.draw_text(128, 104, 140, 24, KSkill::LABELS[:damage])
    contents.draw_text(0, 130, 140, 24, KSkill::LABELS[:power_p])
    contents.draw_text(128, 130, 140, 24, KSkill::LABELS[:power_m])
    contents.font.color = normal_color
    contents.draw_text(32, 0, 188, 24, @skill.name, 0)
    contents.draw_text(0, 26, 218, 24, KSkill::LABELS[@skill.scope])
    contents.draw_text(0, 52, 218, 24, KSkill::OCCASIONS[@skill.occasion], 2)
    contents.draw_text(88, 78, 120, 24, @skill.mp_cost.to_s)
    contents.draw_text(120, 78, 96, 24, @skill.hit.to_s, 2)
    contents.draw_text(88, 104, 100, 24, @skill.speed.to_s)
    contents.draw_text(88, 104, 128, 24, @skill.base_damage.to_s, 2)
    contents.draw_text(88, 130, 128, 24, @skill.atk_f.to_s)
    contents.draw_text(88, 130, 128, 24, @skill.spi_f.to_s, 2)
    y = 130
    symbols = [:mp_dmg, :absorb, :ignore]
    attr = [@skill.damage_to_mp, @skill.absorb_damage, @skill.ignore_defense]
    attr.size.times {|n| contents.font.color.alpha = attr[n] ? 255 : 120
      y += 26
      contents.draw_text(0, y, 140, 24, KSkill::LABELS[symbols[n]]) }
  end
end

class Scene_Battle
  def battle_end(result)
    if result == 2 and not $game_troop.can_lose
      call_gameover
    else
      $game_party.clear_actions
      $game_party.remove_states_battle
      $game_troop.clear
      if $game_temp.battle_proc != nil
        $game_temp.battle_proc.call(result)
        $game_temp.battle_proc = nil
      end
      unless $BTEST
        $game_temp.map_bgm.play
        $game_temp.map_bgs.play
      end
      $scene = KSkill.help_actors.empty? ? Scene_Map.new : Scene_SkillMax.new
      @message_window.clear
      Graphics.fadeout(30)
    end
    $game_temp.in_battle = false
  end
end

class Scene_SkillMax
  def main
    start
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      break if $scene != self
    end
    Graphics.update
    Graphics.freeze
    @command_window.dispose
    @old_status_window.dispose
    @new_status_window.dispose
    @replace_window.dispose
    @skill_window.dispose
    @selection_window.dispose
    @help_windows.each {|window| window.dispose }
  end

  def start
    KSkill.open_menu = nil
    KSkill.replacements = KSkill.not_learned.values.flatten.size
    @help_windows =  [Window_SkillHelp.new, Window_SkillHelp.new(120)]
    @help_windows += [Window_SkillHelp.new(212), Window_SkillHelp.new(212)]
    @help_windows << Window_SkillHelp.new(424)
    @help_windows[2].x = 120
    @help_windows[3].x = 332
    @help_windows[4].x = 120
    @help_windows[1].y = 56
    @help_windows[2].y = 56
    @help_windows[3].y = 56
    @help_windows[4].y = 360
    @help_windows[0].set_text(KSkill::REACHEDMAX, 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)
    @selection_window = Window_ActorSelection.new
    @skill_window = Window_ActorSkills.new
    if KSkill.help_actors.size == 1
      @skill_window.actor = $game_actors[KSkill.help_actors[0]]
      @selection_window.active = nil
    else
      @skill_window.active = nil
    end
    @replace_window = Window_NewSkills.new(KSkill.help_actors.size == 1)
    @old_status_window = Window_SkillStatusExtended.new(36, 96)
    @old_status_window.visible = false
    @new_status_window = Window_SkillStatusExtended.new(292, 96)
    @new_status_window.visible = false
    @command_window = Window_Command.new(200, KSkill::EXITOPTIONS)
    @command_window.x = (544 - @command_window.width) / 2
    @command_window.y = (412 - @command_window.height) / 2
    @command_window.visible = @command_window.active = nil
  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
    elsif @skill_window.active
      update_skill_selection
    elsif @command_window.active
      update_exit_selection
    elsif @old_status_window.visible
      update_old_skills_info
    elsif @new_status_window.visible
      update_new_skills_info
    end
  end

  def update_actor_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @help_windows[0].set_text(KSkill::AREYOUSURE, 1)
      @selection_window.active = nil
      @command_window.active = @command_window.visible = true
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      @help_windows[0].set_text(KSkill::REPLACESKILLS, 1)
      id = KSkill.help_actors[@selection_window.index]
      @skill_window.actor = $game_actors[id]
      @replace_window.index = @selection_window.index
      @replace_window.refresh
      @skill_window.active, @selection_window.active = true, nil
      @skill_window.index = 0
    end
  end

  def update_skill_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @help_windows[0].set_text(KSkill::REACHEDMAX, 1)
      @skill_window.active, @selection_window.active = nil, true
      @skill_window.index = -1
      @skill_window.contents.clear
      @replace_window.contents.clear
      return
    elsif Input.trigger?(Input::C)
      @skill_window.update_replacement_check
      text = sprintf(KSkill::REPLACEMENTSLEFT, KSkill.replacements)
      @help_windows[4].set_text(text, 1)
    elsif Input.trigger?(KSkill::OLDBUTTONID)
      Sound.play_decision
      actor_id = KSkill.help_actors[@selection_window.index]
      @actor_skills = $game_actors[actor_id].skills
      @skills_size = @actor_skills.size
      @skill_index = @actor_skills.index(@skill_window.skill_id)
      @old_status_window.skill_id = @skill_window.skill_id
      @skill_window.active = false
      @old_status_window.visible = true
    elsif Input.trigger?(KSkill::NEWBUTTONID)
      Sound.play_decision
      actor_id = KSkill.help_actors[@selection_window.index]
      @actor_skills = KSkill.not_learned[actor_id]
      @skills_size = @actor_skills.size
      @skill_index = 0
      @new_status_window.skill_id = @actor_skills[0]
      @skill_window.active = false
      @new_status_window.visible = true
    end
  end

  def update_old_skills_info
    if Input.trigger?(Input::B) or Input.trigger?(KSkill::OLDBUTTONID)
      Sound.play_cancel
      @actor_skills.clear
      @old_status_window.visible = false
      @skill_window.active = true
    elsif Input.trigger?(Input::UP)
      if @skills_size == 1
        Sound.play_cancel
        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
        Sound.play_cancel
        return
      end
      @skill_index = (@skill_index + 1) % @skills_size
      @old_status_window.skill_id = @actor_skills[@skill_index]
    end
  end

  def update_new_skills_info
    if Input.trigger?(Input::B) or Input.trigger?(KSkill::NEWBUTTONID)
      Sound.play_cancel
      @actor_skills = nil
      @new_status_window.visible = false
      @skill_window.active = true
    elsif Input.trigger?(Input::UP)
      if @skills_size == 1
        Sound.play_cancel
        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
        Sound.play_cancel
        return
      end
      @skill_index = (@skill_index + 1) % @skills_size
      @new_status_window.skill_id = @actor_skills[@skill_index]
    end
  end

  def update_exit_selection
    if Input.trigger?(Input::C)
      Sound.play_decision
      case @command_window.index
      when 0
        KSkill.help_actors.each {|id| index = -1
          next if @skill_window.replaced[id].nil?
          @skill_window.replaced[id].each {|ix| index += 1
            skill_id = KSkill.not_learned[id][index]
            $game_actors[id].replace_skill(ix, skill_id) } }
        clear_skills_info
      when 1
        @selection_window.active = true
        @command_window.active = @command_window.visible = nil
      when 2 : clear_skills_info
      end
      $scene = Scene_Map.new unless @command_window.index == 1
    end
  end

  def clear_skills_info
    return unless KSkill::CLEAR_SKILLS_NOT_LEARNED
    KSkill.help_actors.each {|id| KSkill.not_learned[id].clear }
    KSkill.help_actors.clear
  end
end

class Scene_Map
  alias kyon_skill_limit_scn_map_up update
  def update
    kyon_skill_limit_scn_map_up
    if KSkill.open_menu and !$game_message.visible
      $scene = Scene_SkillMax.new
      return
    end
  end
end



Espero que aprovechen la oportunidad. Por cierto este script es gratis para quienes lo usen solo para demos o juegos 100% gratuitos.

Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.