让技能像装备一样装备吧~技能SP系统

千葉玖濑

◆ 技能SP点--让技能像装备一样装备吧~
看到了VX中KGC的技能CP制脚本，然后到KGC和6R找了好久都没找到ACE版本，就参照着KGCVX版的思路了弄了个技能SP的脚本~
功能：
让技能像装备一样装备，只有装备后的技能可以在战斗中使用。
技能可在备注设定消耗的SP，角色升级可增加SP，装备也可追加SP（或者扣除SP上限）。
可定义技能栏上限，这样即使SP再多也只能携带特定数目技能。

一点都不特别的使用技♂巧：
         SceneManager.call(Scene_SetBattleSkill) 呼出技能配置界面。
         在数据库技能备注中添加<CP X>
         若要让装备可以增加最大CP在装备备注中添加<最大CP X>
         若要让装备可以增加技能栏容量在备注中添加<技能栏追加 X>
         脚本内置在菜单中添加了“魔装”选项，不需要请删除脚本之后对Window_Menucommand和Scene_Menu的追加。
         关于其他对SP和技能栏的操作见范例或者注释（范例才没有卖萌呢）
[pre lang="ruby" line="1"]#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/                ◆ 技能SP点--让技能像装备一样装备吧~
#_/
#_/  看到了VX中KGC的技能CP制脚本，然后到KGC和6R找了好久都没找到ACE版本，就参照着
#_/  KGCVX版的思路移植了个技能SP的脚本~
#_/  功能：
#_/   让技能像装备一样装备，只有装备后的技能可以在战斗中使用。
#_/   技能可在备注设定消耗的SP，角色升级可增加SP，装备也可追加SP（或者扣除SP上限）。
#_/   可定义技能栏上限，这样即使SP再多也只能携带特定数目技能。
#_/                                                            ---千叶玖濑
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#==============================================================================
# ☆系统设置
#==============================================================================
module Skill_SP
  # ◆ 技能栏最大空位
  MAX_SKILLS = 7
  # ◆ SP 的名字
  VOCAB_SP   = "SP"
  # ◆ SP 的简称
  VOCAB_SP_A = "技"
  # ◆ 在角色状态中显示SP数值（适合默认菜单）
  SHOW_STATUS_SP = true
  # ◆ 未设定消耗SP的技能，默认消耗的SP值。
  DEFAULT_SP_COST = 1
  # ◆ 人物升级所获得得SP值上限
  SP_MAX = 25
  # ◆ 人物SP值下限
  SP_MIN = 0
  # ◆ 本来的SP加上装备提供的SP上限
  REVISED_SP_MAX = 25
  # ◆ 经过装备扣除后的SP下限
  REVISED_SP_MIN = 0
  # ◆通用的SP最大值的计算公式
  #   level代表角色当前等级
  #   结果自动取整
  SP_ABOUT_EXP = "level * 0.6 + 1.0"
  # ◆ 对于特定角色角色最大SP计算公式
  #   PERSONAL_SP_ABOUT_EXP[角色 ID] = "公式"
  #   公式格式和最大值计算公式举例如下
  PERSONAL_SP_ABOUT_EXP = [] # 此行不要改动
  PERSONAL_SP_ABOUT_EXP[1] = "level * 1.0 - 10.0"
  PERSONAL_SP_ABOUT_EXP[3] = "level * 1.0 + 5.0"
  # ◆ 在技能装备栏中允许显示不可使用的技能
  SHOW_UNUSABLE_SKILL    = true
  # ◆ 新学习到的技能自动装备
  AUTO_SET_NEW_SKILL     = true
  # ◆ SP 最小值时的颜色
  #  （数值为\C[n]表示的颜色）
  GAUGE_START_COLOR = 13
  # ◆ SP 最大值时的颜色
  GAUGE_END_COLOR   = 5
  # ◆ 菜单中进入技能SP的名称
  VOCAB_MENU_SET_SKILL = "魔装"
  # ◆ 未设定技能时显示的名称
  BLANK_TEXT   = "-   空技能框   -"
  # ◆ 技能解除时候显示的名称
  RELEASE_TEXT = "( 解除技能 )"
end
#==============================================================================
# ☆对于在数据库备注中的设定方法~
#==============================================================================
module Skill_SP
  module Regexp
    module BaseItem
      # 最大SP增加：在装备栏备注中填写<最大SP X>或<MAXSP X>（X可为负数）
      MAXSP_PLUS = /<(?:MAX|最大)SP\s*([\-\+]?\d+)>/
      # 技能框增加：在装备栏备注中填写<技能栏追加 X>
      BATTLE_SKILL_MAX = /<(?:BATTLE_SKILL_MAX|技能栏追加)\s*([\-\+]?\d+)>/i
    end
    module Skill
      # 消费SP设定 ：在技能备注中填写<SP X>
      SP_COST = /<SP\s*(\d+)>/i
    end
  end
end
#==============================================================================
## ☆ Game_Interpreter----用事件脚本来获取SP的方法~
#==============================================================================
module Skill_SP
  #--------------------------------------------------------------------------
  # ○ 获得角色SP最大值
  #     actor_id    : 角色编号
  #     variable_id : SP赋值的变量号（不填则不代入）
  #--------------------------------------------------------------------------
  def get_actor_sp(actor_id, variable_id = 0)
    value = $game_actors[actor_id].maxsp_plus
    $game_variables[variable_id] = value if variable_id > 0
    return value
  end
  #--------------------------------------------------------------------------
  # ○ 变更角色SP最大值
  #     actor_id : 角色编号
  #     value    : 变更后的SP最大值
  #--------------------------------------------------------------------------
  def set_actor_sp(actor_id, value)
    $game_actors[actor_id].maxsp_plus = value
  end
  #--------------------------------------------------------------------------
  # ○ 角色最大SP增加
  #     actor_id : 角色编号
  #     value    : SP最大值增加量
  #--------------------------------------------------------------------------
  def gain_actor_sp(actor_id, value)
    $game_actors[actor_id].maxsp_plus += value
  end
  #--------------------------------------------------------------------------
  # ○ 技能栏最大数获得
  #     actor_id : 角色编号
  #     variable_id : 技能栏最大数赋值的变量号（不填则不代入）
  #--------------------------------------------------------------------------
  def get_battle_skill_max(actor_id, variable_id = 0)
    value = $game_actors[actor_id].battle_skill_max
    $game_variables[variable_id] = value if variable_id > 0
    return value
  end
  #--------------------------------------------------------------------------
  # ○ 技能栏最大数变更
  #     actor_id : 角色ID
  #     value    : 变更后的技能栏数目
  #--------------------------------------------------------------------------
  def set_battle_skill_max(actor_id, value = -1)
    $game_actors[actor_id].battle_skill_max = value
  end
  #--------------------------------------------------------------------------
  # ○ 确认某技能是否已装备
  #     actor_id : 角色ID
  #     skill_id : 技能ID
  #--------------------------------------------------------------------------
  def battle_skill_set?(actor_id, skill_id)
    return $game_actors[actor_id].battle_skill_ids.include?(skill_id)
  end
  #--------------------------------------------------------------------------
  # ○ 装备技能
  #     actor_id : 角色编号
  #     index    : 装备的技能栏位
  #     skill_id : 技能ID(nil则为解除装备)
  #--------------------------------------------------------------------------
  def set_battle_skill(actor_id, index, skill_id = nil)
    actor = $game_actors[actor_id]
    if skill_id.is_a?(Integer)
      # 装备
      skill = $data_skills[skill_id]
      return unless actor.battle_skill_settable?(index, skill)  # 无法装备
      actor.set_battle_skill(index, skill)
      actor.restore_battle_skill
    else
      # 解除
      actor.remove_battle_skill(index)
    end
  end
  #--------------------------------------------------------------------------
  # ○ 直接装备某技能
  #     actor_id : 角色编号
  #     skill_id : 技能编号
  #--------------------------------------------------------------------------
  def add_battle_skill(actor_id, skill_id)
    actor = $game_actors[actor_id]
    skill = $data_skills[skill_id]
    return if actor == nil || skill == nil
    actor.add_battle_skill(skill)
  end
  #--------------------------------------------------------------------------
  # ○ 卸下全部技能
  #     actor_id : 角色编号
  #--------------------------------------------------------------------------
  def clear_battle_skill(actor_id)
    $game_actors[actor_id].clear_battle_skill
  end
  end
  class Game_Interpreter
    include Skill_SP
  end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★


#==============================================================================
# ■ RPG::BaseItem
#==============================================================================

class RPG::BaseItem
  #--------------------------------------------------------------------------
  # ○ 读取装备备注
  #--------------------------------------------------------------------------
  def create_skill_sp_system_cache
    @__maxsp_plus = 0
    @__battle_skill_max_plus = 0
    self.note.each_line { |line|
      case line
      when Skill_SP::Regexp::BaseItem::MAXSP_PLUS
        @__maxsp_plus += $1.to_i
      when Skill_SP::Regexp::BaseItem::BATTLE_SKILL_MAX
        @__battle_skill_max_plus += $1.to_i
      end
    }
  end
  #--------------------------------------------------------------------------
  # ○ 最大 SP
  #--------------------------------------------------------------------------
  def maxsp_plus
    create_skill_sp_system_cache if @__maxsp_plus == nil
    return @__maxsp_plus
  end
  #--------------------------------------------------------------------------
  # ○ 技能框追加
  #--------------------------------------------------------------------------
  def battle_skill_max_plus
    create_skill_sp_system_cache if @__battle_skill_max_plus == nil
    return @__battle_skill_max_plus
  end
end
#==============================================================================
# ■ RPG::Skill
#==============================================================================
class RPG::Skill < RPG::UsableItem
  #--------------------------------------------------------------------------
  # ○ 技能SP生成
  #--------------------------------------------------------------------------
  def create_skill_sp_system_cache
    @__sp_cost = Skill_SP::DEFAULT_SP_COST
    self.note.each_line { |line|
      case line
      when Skill_SP::Regexp::Skill::SP_COST
        # 消费SP
        @__sp_cost = $1.to_i
      end
    }
  end
  #--------------------------------------------------------------------------
  # ○ 消費 SP
  #--------------------------------------------------------------------------
  def sp_cost
    create_skill_sp_system_cache if @__sp_cost == nil
    return @__sp_cost
  end
end
#==============================================================================
# ■ Vocab
#==============================================================================
module Vocab
  #SP
  def self.sp
    return Skill_SP::VOCAB_SP
  end
  #SP略
  def self.sp_a
    return Skill_SP::VOCAB_SP_A
  end
  # 技能设定
  def self.set_battle_skill
    return Skill_SP::VOCAB_MENU_SET_SKILL
  end
end
#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ○ 战斗技能配置确定
  #--------------------------------------------------------------------------
  def battle_skill_set?(skill)
    return true
  end
end

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

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 实例变量
  #--------------------------------------------------------------------------
  attr_writer   :maxsp_plus               # 最大SP补正值
  #--------------------------------------------------------------------------
  # ○ MaxSP 取得
  #--------------------------------------------------------------------------
  def maxsp
    about_exp = Skill_SP::PERSONAL_SP_ABOUT_EXP[self.id]
    if about_exp == nil
      about_exp = Skill_SP::SP_ABOUT_EXP
    end
    n = Integer(eval(about_exp))
    n = [[n, sp_limit].min, Skill_SP::SP_MIN].max
    n += maxsp_plus + maxsp_plus_equip
    return [[n, revised_sp_limit].min, Skill_SP::REVISED_SP_MIN].max
  end
  #--------------------------------------------------------------------------
  # ○ SP 取得
  #--------------------------------------------------------------------------
  def sp
    return [maxsp - consumed_sp, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ SP 消耗量取得
  #--------------------------------------------------------------------------
  def consumed_sp
    n = 0
    battle_skills.compact.each { |skill| n += skill.sp_cost }
    return n
  end
  #--------------------------------------------------------------------------
  # ○ SP 上限取得
  #--------------------------------------------------------------------------
  def sp_limit
    return Skill_SP::SP_MAX
  end
  #--------------------------------------------------------------------------
  # ○ 补正后SP上限获得
  #--------------------------------------------------------------------------
  def revised_sp_limit
    return Skill_SP::REVISED_SP_MAX
  end
  #--------------------------------------------------------------------------
  # ○ 补正值获得
  #--------------------------------------------------------------------------
  def maxsp_plus
    if @maxsp_plus == nil
      if @own_sp != nil
        @maxsp_plus = @own_sp
        @own_sp = nil
      else
        @maxsp_plus = 0
      end
    end
    return @maxsp_plus
  end
  #--------------------------------------------------------------------------
  # ○ 装备补正
  #--------------------------------------------------------------------------
  def maxsp_plus_equip
    n = 0
    equips.compact.each { |item| n += item.maxsp_plus }
    return n
  end
  #--------------------------------------------------------------------------
  # ● 技能取得
  #--------------------------------------------------------------------------
  alias skills_SkillSP skills
  def skills
    return (skill_sp_restrict? ? restricted_skills : skills_SkillSP)
  end
  #--------------------------------------------------------------------------
  # ○ 战斗测试
  #--------------------------------------------------------------------------
  def skill_sp_restrict?
    if $game_party.in_battle
    return true unless $BTEST
    end
    return false
  end
  #--------------------------------------------------------------------------
  # ○ 技能限制
  #--------------------------------------------------------------------------
  def restricted_skills
    # 战斗技能加入
    result = battle_skills
    result.sort! { |a, b| a.id <=> b.id }
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 全部技能取得
  #--------------------------------------------------------------------------
  def all_skills
    last_in_battle = $game_party.in_battle
    $game_party.in_battle = false
    result = skills_SkillSP
    $game_party.in_battle = last_in_battle
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 技能栏最大数取得
  #--------------------------------------------------------------------------
  def battle_skill_max
    @battle_skill_max = -1 if @battle_skill_max == nil
    n = (@battle_skill_max < 0 ?
     Skill_SP::MAX_SKILLS : @battle_skill_max)
    n += equipment_battle_skill_max_plus
    return [n, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ 扩充技能栏
  #--------------------------------------------------------------------------
  def equipment_battle_skill_max_plus
    n = 0
    equips.compact.each { |item| n += item.battle_skill_max_plus }
    return n
  end
  #--------------------------------------------------------------------------
  # ○ 技能栏最大值设定
  #--------------------------------------------------------------------------
  def battle_skill_max=(value)
    @battle_skill_max = value
    if @battle_skills == nil
      @battle_skills = []
    else
      @battle_skills = @battle_skills[0...value]
    end
  end
  #--------------------------------------------------------------------------
  # ○ 战斗使用技能ID
  #--------------------------------------------------------------------------
  def battle_skill_ids
    @battle_skills = [] if @battle_skills == nil
    return @battle_skills
  end
  #--------------------------------------------------------------------------
  # ○ 战斗用技能取得
  #--------------------------------------------------------------------------
  def battle_skills
    result = []
    battle_skill_ids.each { |i|
      next if i == nil           
      result << $data_skills
    }
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 战斗技能登陆
  #     index : 位置
  #     skill : 技能编号
  #--------------------------------------------------------------------------
  def set_battle_skill(index, skill)
    if skill == nil
      @battle_skills[index] = nil
    else
      return unless skill.is_a?(RPG::Skill)  
      return if sp < skill.sp_cost           
      @battle_skills[index] = skill.id
    end
  end
  #--------------------------------------------------------------------------
  # ○ 战斗技能追加
  #     skill : 技能
  #--------------------------------------------------------------------------
  def add_battle_skill(skill)
    return unless skill.is_a?(RPG::Skill)  
    skills = battle_skill_ids
    return if skills.include?(skill.id)   
    return if sp < skill.sp_cost           
    battle_skill_max.times { |i|
      if skills == nil
        set_battle_skill(i, skill)
        break
      end
    }
    restore_battle_skill
  end
  #--------------------------------------------------------------------------
  # ○ 战斗技能解除
  #     index : 位置
  #--------------------------------------------------------------------------
  def remove_battle_skill(index)
    @battle_skills[index] = nil
  end
  #--------------------------------------------------------------------------
  # ○ 战斗技能全部解除
  #--------------------------------------------------------------------------
  def clear_battle_skill
    @battle_skills = []
  end
  #--------------------------------------------------------------------------
  # ○ 技能能否设置判定
  #     index : 位置
  #     skill : 技能
  #--------------------------------------------------------------------------
  def battle_skill_settable?(index, skill)
    return false if battle_skill_max <= index  # 超出范围
    return true  if skill == nil               # 解除技能
    return false if battle_skill_ids.include?(skill.id)  #已经设定
    skill_id = battle_skill_ids[index]
    curr_skill = (skill_id != nil ? $data_skills[skill_id] : nil)
    offset = (curr_skill != nil ? curr_skill.sp_cost : 0)
    return false if self.sp < (skill.sp_cost - offset)  # SP 不足
    return true
  end
  #--------------------------------------------------------------------------
  # ○ 战斗技能存储
  #--------------------------------------------------------------------------
  def restore_battle_skill
    result = battle_skill_ids.clone
    usable_skills = all_skills
    result.each_with_index { |n, i|
      next if n == nil
      # 未学习的情况
      if (usable_skills.find { |s| s.id == n }) == nil
        result = nil
      end
    }
    @battle_skills = result[0...battle_skill_max]
    # SP不足的时候排除
    (battle_skill_max - 1).downto(0) { |i|
      @battle_skills = nil if maxsp - consumed_sp < 0
    }
  end
  #--------------------------------------------------------------------------
  # ● 换装备的时候
  #     equip_type : 装备部位
  #     item       : 道具
  #     test       : 在战斗测试中
  #--------------------------------------------------------------------------
  alias change_equip_SkillSP change_equip
  def change_equip(equip_type, item, test = false)
    change_equip_SkillSP(equip_type, item)
      restore_battle_skill
  end
  #--------------------------------------------------------------------------
  # ● 装备丢弃时
  #--------------------------------------------------------------------------
  alias discard_equip_SkillSP discard_equip
  def discard_equip(item)
    discard_equip__SkillSP(item)
     restore_battle_skill
  end
  #--------------------------------------------------------------------------
  # ● 经验变更
  #--------------------------------------------------------------------------
  alias change_exp_SP change_exp
  def change_exp(exp, show)
    last_in_battle = $game_party.in_battle
    $game_party.in_battle = false

    change_exp_SP(exp, show)

    $game_party.in_battle = last_in_battle
  end
  if Skill_SP::AUTO_SET_NEW_SKILL
   alias learn_skill_SP learn_skill
  def learn_skill(skill_id)
    learn_skill_SP(skill_id)
    add_battle_skill($data_skills[skill_id])
  end
  end  
  #--------------------------------------------------------------------------
  # ● 技能遗忘
  #--------------------------------------------------------------------------
  alias forget_skill_SkillSP forget_skill
  def forget_skill(skill_id)
    # 忘れるスキルを戦闘用スキルから削除
    battle_skill_ids.each_with_index { |s, i|
      remove_battle_skill(i) if s == skill_id
    }
    forget_skill_SkillSP(skill_id)
  end
  #--------------------------------------------------------------------------
  # ● 判定技能是否装备
  #--------------------------------------------------------------------------
  def battle_skill_set?(skill)
    return false unless skill.is_a?(RPG::Skill)
    return battle_skill_ids.include?(skill.id)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ○ SP颜色取得
  #--------------------------------------------------------------------------
  def sp_color(actor)
    return knockout_color if actor.maxsp > 0 && actor.sp == 0
    return normal_color
  end
  #--------------------------------------------------------------------------
  # ○ SP渐变色1
  #--------------------------------------------------------------------------
  def sp_gauge_color1
    color = Skill_SP::GAUGE_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ SP渐变色2
  #--------------------------------------------------------------------------
  def sp_gauge_color2
    color = Skill_SP::GAUGE_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ SP描绘
  #--------------------------------------------------------------------------
  def draw_actor_sp(actor, x, y, width = 120)
    draw_actor_sp_gauge(actor, x, y, width)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, 24, Vocab::sp_a)
    self.contents.font.color = sp_color(actor)
    xr = x + width
    if width < 120
      self.contents.draw_text(xr - 40, y, 40, 24, actor.sp, 2)
    else
      self.contents.draw_text(xr - 90, y, 40, 24, actor.sp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 50, y, 10, 24, "/", 2)
      self.contents.draw_text(xr - 40, y, 40, 24, actor.maxsp, 2)
    end
    self.contents.font.color = normal_color
  end
  #--------------------------------------------------------------------------
  # ○ SP条描绘
  #--------------------------------------------------------------------------
  def draw_actor_sp_gauge(actor, x, y, width = 120)
    gw = width * actor.sp / [actor.maxsp, 1].max
    gs1 = sp_gauge_color1
    gs2 = sp_gauge_color2
    self.contents.fill_rect(x, y + 24 - 8, width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + 24 - 8, gw, 6, gs1, gs2)
  end
end
#==============================================================================
# ■ Window_Status
#==============================================================================

if Skill_SP::SHOW_STATUS_SP
class Window_Status < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 绘制基本信息
  #--------------------------------------------------------------------------
  alias draw_basic_info_SkillSP draw_basic_info
  def draw_basic_info(x, y)
    draw_basic_info_SkillSP(x, y)
    draw_actor_sp(@actor, x, y + 24 * 4)
  end
end
end
#==============================================================================
# □ Window_BattleSkillStatus
#------------------------------------------------------------------------------
#   显示基本信息的窗口
#==============================================================================

class Window_BattleSkillStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● 初始化
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    super(x, y, Graphics.width, 24 + 32)
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● 刷新
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_level(@actor, 140, 0)
    draw_actor_sp(@actor, 240, 0)
  end
end
#==============================================================================
# □ Window_BattleSkillSlot
#------------------------------------------------------------------------------
#   已装备的技能窗口。
#==============================================================================

class Window_BattleSkillSlot < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 初始化
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, actor)
    super(x, y, width, height)
    @actor = actor
    @data = []
    self.index = 0
    self.active = false
    refresh
  end
  #--------------------------------------------------------------------------
  # ○ 获取最大值
  #--------------------------------------------------------------------------
  def item_max
    @data ? @data.size : 1
  end
  #--------------------------------------------------------------------------
  # ○ 获取技能
  #--------------------------------------------------------------------------
  def skill
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # ● 刷新
  #--------------------------------------------------------------------------
  def refresh
    @data=[]
        skill_ids = @actor.battle_skill_ids
    @actor.battle_skill_max.times { |i|
      if skill_ids != nil
        @data << $data_skills[skill_ids]
      else
        @data << nil
      end
    }
    create_contents
    draw_all_items
  end
  #--------------------------------------------------------------------------
  # ○ 绘制内容
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    skill = @data[index]
    if skill != nil
      rect.width -= 4
      draw_item_name(skill, rect.x, rect.y)
      self.contents.draw_text(rect, skill.sp_cost, 2)
    else
      self.contents.draw_text(rect, Skill_SP::BLANK_TEXT, 1)
    end
  end
  #--------------------------------------------------------------------------
  # ● 更新帮助窗口
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(skill == nil ? "" : skill.description)
  end
end
#==============================================================================
# □ Window_BattleSkillList
#------------------------------------------------------------------------------
#   右侧显示技能列表的窗口。
#==============================================================================

class Window_BattleSkillList < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 定义实例变量
  #--------------------------------------------------------------------------
  attr_accessor :slot_index               # 技能栏编号
  #--------------------------------------------------------------------------
  # ● 初始化对象
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, actor)
    super(x, y, width, height)
    @actor = actor
    @slot_index = 0
    @data = []
    self.index = 0
    self.active = false
    refresh
  end
  #--------------------------------------------------------------------------
  # ○ 技能取得
  #--------------------------------------------------------------------------
  def skill
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # ○ 最大技能数取得
  #--------------------------------------------------------------------------
  def item_max
    @data ? @data.size : 1
  end
  #--------------------------------------------------------------------------
  # ○ 显示技能列表
  #--------------------------------------------------------------------------
  def make_item_list
    @data = [nil]
    @actor.all_skills.each { |skill|
      @data.push(skill) if selectable?(skill)
    }
  end
  #--------------------------------------------------------------------------
  # ● 刷新
  #--------------------------------------------------------------------------
  def refresh
    make_item_list
    create_contents
    draw_all_items
  end
  #--------------------------------------------------------------------------
  # ○ 技能可否选择判定
  #--------------------------------------------------------------------------
  def selectable?(skill)
    return false if skill == nil
    return true if skill.battle_ok?
    if Skill_SP::SHOW_UNUSABLE_SKILL && skill.occasion == 3
      return true
    end
    return false
  end
  #--------------------------------------------------------------------------
  # ○ 绘制项目
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    skill = @data[index]
    if skill != nil
      rect.width -= 4
      enabled = @actor.battle_skill_settable?(@slot_index, skill)
      draw_item_name(skill, rect.x, rect.y, enabled)
      self.contents.draw_text(rect, skill.sp_cost, 2)
    else
      self.contents.draw_text(rect, Skill_SP::RELEASE_TEXT, 1)
    end
  end
  #--------------------------------------------------------------------------
  # ● 更新帮助窗口
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(skill == nil ? "" : skill.description)
  end
end
#==============================================================================
# □ Scene_SetBattleSkill
#------------------------------------------------------------------------------
#   技能设定的场景。
#==============================================================================

class Scene_SetBattleSkill < Scene_MenuBase
  #--------------------------------------------------------------------------
  # ● 初始化
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, menu_index = 0)
    @actor_index = actor_index
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # ● 开始处理
  #--------------------------------------------------------------------------
  def start
    super
    create_background
    @actor = $game_party.menu_actor
    create_windows
  end
  #--------------------------------------------------------------------------
  # ○ 创建窗口
  #--------------------------------------------------------------------------
  def create_windows
    @help_window = Window_Help.new
    dy = @help_window.height
    @status_window = Window_BattleSkillStatus.new(0, dy, @actor)

    dy += @status_window.height
    @slot_window = Window_BattleSkillSlot.new(
      0,
      dy,
      Graphics.width / 2,
      Graphics.height - dy,
      @actor)
    @slot_window.help_window = @help_window
    @slot_window.active = true

    @list_window = Window_BattleSkillList.new(
      Graphics.width - @slot_window.width,
      dy,
      Graphics.width - @slot_window.width,
      Graphics.height - dy,
      @actor)
    @list_window.help_window = @help_window
  end
  #--------------------------------------------------------------------------
  # ● 结束处理
  #--------------------------------------------------------------------------
  def terminate
    super
    @help_window.dispose
    @status_window.dispose
    @slot_window.dispose
    @list_window.dispose
  end
  #--------------------------------------------------------------------------
  # ● 更新
  #--------------------------------------------------------------------------
  def update
    super
    if @slot_window.active
      update_slot
    elsif @list_window.active
      update_list
    end
  end
  #--------------------------------------------------------------------------
  # ○ 刷新窗口
  #--------------------------------------------------------------------------
  def refresh_window
    @status_window.refresh
    @slot_window.refresh
    @list_window.refresh
  end
  #--------------------------------------------------------------------------
  # ○ 左侧窗口更新
  #--------------------------------------------------------------------------
  def update_slot
    if @last_slot_index != @slot_window.index
      @list_window.slot_index = @slot_window.index
      @list_window.refresh
      @last_slot_index = @slot_window.index
    end
    if Input.trigger?(Input::A)
      Sound.play_ok
      @actor.remove_battle_skill(@slot_window.index)
      refresh_window
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      SceneManager.return
    elsif Input.trigger?(Input::C)
      Sound.play_ok
      # 切换活动窗口
      @slot_window.active = false
      @list_window.active = true
    end
  end
  #--------------------------------------------------------------------------
  # ○ 右侧窗口更新
  #--------------------------------------------------------------------------
  def update_list
    if Input.trigger?(Input::B)
      Sound.play_cancel
      # 切换活动窗口
      @slot_window.active = true
      @list_window.active = false
    elsif Input.trigger?(Input::C)
      skill = @list_window.skill
      # 无法设置的场合
      unless @actor.battle_skill_settable?(@slot_window.index, skill)
        Sound.play_buzzer
        return
      end
      Sound.play_ok
      set_skill(@slot_window.index, skill)
      @slot_window.active = true
      @list_window.active = false
    end
  end
  #--------------------------------------------------------------------------
  # ○ 设置技能
  #--------------------------------------------------------------------------
  def set_skill(index, skill)
    @actor.remove_battle_skill(index)
    if skill != nil
      @actor.set_battle_skill(index, skill)
    end
    refresh_window
  end
end
#==============================================================================
# ■ Window_MenuCommand
#------------------------------------------------------------------------------
# 　菜单画面中显示指令的窗口
#==============================================================================

class Window_MenuCommand < Window_Command
  alias add_main_commands_kunase add_main_commands
  def add_main_commands
    add_main_commands_kunase
    add_command(Skill_SP::VOCAB_MENU_SET_SKILL, :skillsp, main_commands_enabled)
  end
end
#==============================================================================
# ■ Scene_Menu
#------------------------------------------------------------------------------
# 　菜单画面
#==============================================================================
class Scene_Menu < Scene_MenuBase
  alias create_command_window_kunase create_command_window
  def create_command_window
    create_command_window_kunase
    @command_window.set_handler(:skillsp,     method(:command_personal))
  end
  def on_personal_ok
    case @command_window.current_symbol
    when :skill
      SceneManager.call(Scene_Skill)
    when :equip
      SceneManager.call(Scene_Equip)
    when :status
      SceneManager.call(Scene_Status)
    when :skillsp
      SceneManager.call(Scene_SetBattleSkill)
      end
    end
  end
#==============================================================================
# ■ Game_Unit
#------------------------------------------------------------------------------
# 　管理游戏单位的类。是 Game_Party 和 Game_Troop 类的父类。
#==============================================================================
class Game_Unit
  #--------------------------------------------------------------------------
  # ● 定义实例变量
  #--------------------------------------------------------------------------
  attr_accessor   :in_battle                # 战斗中的标志
end[/pre]
技能SP系统.zip (1.44 MB, 下载次数: 569)

2015-2-9 17:41 上传

点击文件名下载附件
嘛来看下载量

VIPArcher

妙妙妙，
酒濑大触(๑• . •๑)
待编辑

chd114

我居然是第一个下的

如果明年有整合系统制作赛的话介意我整合一下发出来吗？


发现个BUG，范例里面的第三个角色的治愈如果卸掉了，在战斗中是不会显示出来，但是技能那里还是会显示


这个脚本和https://rpg.blue/thread-373928-1-1.html有冲突，顺序靠前的那个脚本的窗口会无法打开···

千葉玖濑

因为有些地图上使用的技能就算不装备也得能用吧(*/ω＼*)
顺带冲突问题过几天我看下，因为我也需要用那个脚本

chd114

千葉玖濑 发表于 2015-2-9 05:09
因为有些地图上使用的技能就算不装备也得能用吧(*/ω＼*)
顺带冲突问题过几天我看下，因为我也需要用那个脚 ...

我已经解决了

1. class Scene_Menu < Scene_MenuBase
   
2.   def on_personal_ok
   
3.     case @command_window.current_symbol
   
4.     when :skill
   
5.       SceneManager.call(Scene_Skill)
   
6.     when :equip
   
7.       SceneManager.call(Scene_Equip)
   
8.     when :status
   
9.       SceneManager.call(Scene_Status)
   
10.     when :skillsp
    
11.       SceneManager.call(Scene_SetBattleSkill)
    
12.     end
    
13.   end
    
14. end

复制代码

这里的问题，要去掉两个的其中一个，整合成

1. class Scene_Menu < Scene_MenuBase
   
2.   def on_personal_ok
   
3.     case @command_window.current_symbol
   
4.     when :skill
   
5.       SceneManager.call(Scene_Skill)
   
6.     when :equip
   
7.       SceneManager.call(Scene_Equip)
   
8.     when :status
   
9.       SceneManager.call(Scene_Status)
   
10.     when :skillsp
    
11.       SceneManager.call(Scene_SetBattleSkill)
    
12.     when :addskill
    
13.       SceneManager.call(Scene_AddSkill)
    
14.     end
    
15.   end
    
16. end

复制代码

就可以了

cjlzbb

以前有看过个VA的版本，不是6R上的，是日文的。已找到，不知道还有没有前置脚本。给楼主做个参考吧

[pre lang="ruby"]#==============================================================================
#  ■スキルメモライズシステム for RGSS3 Ver1.21-β6
#　□author kure、星潟
#
#　呼び出し方法　SceneManager.call(Scene_SkillMemorize)
#　
#==============================================================================
#　※追加イベントコマンド(スクリプトに挿入して使用)
#　　・memory_skill_ad(アクターID, スキルID)
#　　　アクターにメモライズを追加、メモライズ制限無視
#
#　　・memory_skill_ad_l(アクターID, スキルID)
#　　　アクターにメモライズを追加、メモライズ制限適用
#
#　　・memory_skill_dl(アクターID, スキルID)
#  　　アクターのメモライズから指定スキルを削除
#
#　　・memory_skill_dl_all(アクターID)
#　　　アクターのメモライズを初期化
#
#==============================================================================
#　※メモライズ追加設定
#　　メモ欄に「<メモライズ不要>」と書かれたスキルはメモライズ無しで使用可
#　　アクター毎に個別設定したい場合は「<メモライズ不要 1>」と書いて下さい
#==============================================================================
module KURE
  module SkillMemorize
    #基本設定(変更しない事)
    CHAIN_MEMORIZE = []
   
    #動作設定-------------------------------------------------------------------
    #记忆系统适用范围(0=一直 1=战斗中适用)
    ADOPT_MEMORIZE = 0
    #升级时自动记忆(0=OFF、1=ON)
    AUTO_MEMORIZE = 0
    #升级时不自动记忆的技能类型ID
    NOT_AUTO_MEMORIZE = []
   
    #表示設定-------------------------------------------------------------------
    #是否显示技能类型记忆容量(0=不显示 1=表示)
    #VIEW_MEMORIZE_GAGE = [スキルタイプ1,スキルタイプ2,…]
    VIEW_MEMORIZE_GAGE = [1,1,1]
    #是否显示记忆容量(0=不显示 1=表示)
    VIEW_MEMORIZE_CAPACITY = 1
    #不显示的技能类型
    #NOT_VIEW_SKILLTYPE = [スキルタイプID]
    NOT_VIEW_SKILLTYPE = []
   
    #スキルメモライズ数(記憶数)に関する設定-------------------------------------
    #记忆数不适用的技能类型
    #NOT_ADOPT_SKILL_TYPE = [スキルタイプID]
    NOT_ADOPT_MAX_MEMORY_SKILL_TYPE = []
   
    #基础的各类型技能记忆数
    #BASE_MAX_MEMORY = [スキルタイプ1,スキルタイプ2,…]
    BASE_MAX_MEMORY = [5,5,5]
   
    #每升一级各类型技能记忆数提高
    #Lv_MAX_MEMORY = [スキルタイプ1,スキルタイプ2,…]
    Lv_MAX_MEMORY = [0,0,0]
   
    #各类型技能记忆数的上限(0=无上限)
    #MAX_MEMORY_CAP = [スキルタイプ1,スキルタイプ2,…]
    MAX_MEMORY_CAP = [0,0,0]
   
    #メモライズ容量(記憶容量)に関する設定---------------------------------------
    #记忆容量不适用的技能类型
    #NOT_ADOPT_SKILL_TYPE = [スキルタイプID]
    NOT_ADOPT_MEMORIZE_CAPACITY_SKILL_TYPE = []
   
    #基础的各类型技能记忆容量
    #BASE_MEMORIZE_CAPACITY = [スキルタイプ1,スキルタイプ2,…]　
    BASE_MEMORIZE_CAPACITY = [50,50,50]
   
    #每升一级各类型技能记忆容量提高
    #Lv_MEMORIZE_CAPACITY = [スキルタイプ1,スキルタイプ2,…]
    Lv_MEMORIZE_CAPACITY = [0.1,1.5,1]
   
    #各类型技能记忆容量的上限(0=无上限)
    #MAX_MEMORY_CAP = [スキルタイプ1,スキルタイプ2,…]
    MAX_MEMORIZE_CAP = [0,0,0]
   
    #记忆容量の表示名
    MEMORIZE_CAPACITY_NAME = "记忆力"

    #スキルに関する設定---------------------------------------------------------
    #チェインメモライズ
    #CHAIN_MEMORIZE[判定順(0〜数字を入れていってください)] = [追加スキルID,要求スキルID,要求スキルID,…]
#    CHAIN_MEMORIZE[0] = [74,76,77,78]
#    CHAIN_MEMORIZE[1] = [73,96,77,78]
#    CHAIN_MEMORIZE[2] = [72,96,95,78]
  end
end

#==============================================================================
# ■ Scene_SkillMemorize
#==============================================================================
class Scene_SkillMemorize < Scene_Skill
  #--------------------------------------------------------------------------
  # ● 開始処理
  #--------------------------------------------------------------------------
  def start
    super
    #保存変数
    @keep_index = -1
   
    create_help_window
    create_command_window
    create_status_window
    create_item_window
    create_pop_window
   
    setup_actor
    setup_window
  end
  #--------------------------------------------------------------------------
  # ● アイテムウィンドウの作成(再定義)
  #--------------------------------------------------------------------------
  def create_item_window
    create_memorized_skill_window
    create_all_skill_window
    @memorized_skill_window.stype_id = @command_window.current_ext
    @learnd_skill_window.stype_id = @command_window.current_ext
  end
  #--------------------------------------------------------------------------
  # ● コマンドウィンドウの作成
  #--------------------------------------------------------------------------
  def create_command_window
    wy = @help_window.height
    @command_window = Window_k_Skillmemorize_SkillCommand.new(0, wy)
    @command_window.set_handler(:skill,    method(:command_skill))
    @command_window.set_handler(:cancel,   method(:return_scene))
    @command_window.set_handler(:pagedown, method(:next_actor))
    @command_window.set_handler(:pageup,   method(:prev_actor))
  end
  #--------------------------------------------------------------------------
  # ● ステータスウィンドウの作成
  #--------------------------------------------------------------------------
  def create_status_window
    y = @help_window.height
    @status_window = Window_k_SkillMemorize_SkillStatus.new(0, y)
    @status_window.opacity = 0
  end
  #--------------------------------------------------------------------------
  # ● 記憶スキルウィンドウの作成
  #--------------------------------------------------------------------------
  def create_memorized_skill_window
    wx = 0
    wy = @status_window.y + @status_window.height
    ww = Graphics.width / 2
    wh = Graphics.height - wy
    @memorized_skill_window = Window_k_SkillMemorize_SkillList.new(wx, wy, ww, wh)
    @memorized_skill_window.set_handler(:ok,     method(:on_memorize_ok))
    @memorized_skill_window.set_handler(:cancel, method(:on_memorize_cancel))
    @memorized_skill_window.deactivate
    @memorized_skill_window.unselect
  end
  #--------------------------------------------------------------------------
  # ● 習得スキルウィンドウの作成
  #--------------------------------------------------------------------------
  def create_all_skill_window
    wx = Graphics.width / 2
    wy = @status_window.y + @status_window.height
    ww = Graphics.width / 2
    wh = Graphics.height - wy
    @learnd_skill_window = Window_k_LearndSkill_SkillList.new(wx, wy, ww, wh)
    @learnd_skill_window.set_handler(:ok,     method(:on_learnd_ok))
    @learnd_skill_window.set_handler(:cancel, method(:on_learnd_cancel))
    @learnd_skill_window.deactivate
    @learnd_skill_window.unselect
  end
  #--------------------------------------------------------------------------
  # ● ポップウィンドウの作成
  #--------------------------------------------------------------------------
  def create_pop_window
    wx = Graphics.width / 4 - 40
    wy = @status_window.y + @status_window.height - 30
    ww = Graphics.width / 2 + 80
    wh = 24 * 2
    @pop_window = Window__k_SkillMemorize_Popup.new(wx,wy,ww,wh)
    @pop_window.z += 100
    @pop_window.back_opacity = 255
    @pop_window.hide
  end
  #--------------------------------------------------------------------------
  # ● アクターのセットアップ
  #--------------------------------------------------------------------------
  def setup_actor
    @command_window.actor = @actor
    @status_window.actor = @actor
    @memorized_skill_window.actor = @actor
    @learnd_skill_window.actor = @actor
    @pop_window.actor = @actor
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウセットアップ
  #--------------------------------------------------------------------------
  def setup_window
    @command_window.help_window = @help_window
    @command_window.memorized_skill_window = @memorized_skill_window
    @command_window.learnd_skill_window = @learnd_skill_window
    @memorized_skill_window.help_window = @help_window
    @learnd_skill_window.help_window = @help_window
    @memorized_skill_window.pop_window = @pop_window
    @command_window.select(0)
  end
  #--------------------------------------------------------------------------
  # ● コマンド［スキル］
  #--------------------------------------------------------------------------
  def command_skill
    @command_window.deactivate
    @memorized_skill_window.activate
    @memorized_skill_window.select(0)
  end
  #--------------------------------------------------------------------------
  # ● 呼び出し元のシーンへ戻る
  #--------------------------------------------------------------------------
  def return_scene
    @actor.set_passive_skills
    @actor.release_unequippable_items
    SceneManager.return
  end
  #--------------------------------------------------------------------------
  # ● 記憶ウィンドウ［決定］
  #--------------------------------------------------------------------------
  def on_memorize_ok
    if @pop_window.visible == true
      @pop_window.hide
      @memorized_skill_window.activate
      return
    end  
    #選択位置を保存
    @keep_memorize_index = @memorized_skill_window.index
   
    if @memorized_skill_window.data[@keep_memorize_index] != nil
      @learnd_skill_window.select_skill = @memorized_skill_window.data[@keep_memorize_index].id
    end
   
    @memorized_skill_window.deactivate
    @learnd_skill_window.refresh
    @learnd_skill_window.activate
    @learnd_skill_window.select(0)
  end
  #--------------------------------------------------------------------------
  # ● 記憶ウィンドウ［キャンセル］
  #--------------------------------------------------------------------------
  def on_memorize_cancel
    set_memorize_to_command
  end
  #--------------------------------------------------------------------------
  # ● 習得ウィンドウ［決定］
  #--------------------------------------------------------------------------
  def on_learnd_ok
    #エクストラ配列をセット
    @actor.chain_memorize_set
   
    #セット前のエクストラ配列を取得
    @before_memorize = @actor.extra_skills.collect {|skill| skill.id}

   
    if @learnd_skill_window.data[@learnd_skill_window.index] != nil
      index = @actor.memory_skills.index(@memorized_skill_window.data[@keep_memorize_index])
      @actor.add_memorize_skill(@learnd_skill_window.data[@learnd_skill_window.index].id,index)
    end
    if @memorized_skill_window.data[@keep_memorize_index] != nil
      @actor.delete_memorize_skill(@memorized_skill_window.data[@keep_memorize_index].id)
      max_memorize_cheack
    end

    #エクストラ配列をセット
    @actor.chain_memorize_set
    #セット後のエクトラ配列を取得
    @after_memorize = @actor.extra_skills.collect {|skill| skill.id}
   
    @learnd_skill_window.select_skill = 0
    @command_window.refresh
    @learnd_skill_window.refresh
    @memorized_skill_window.refresh
    set_learnd_to_memorize
    view_popup
  end
  #--------------------------------------------------------------------------
  # ● 習得ウィンドウ［キャンセル］
  #--------------------------------------------------------------------------
  def on_learnd_cancel
    set_learnd_to_memorize
  end
  #--------------------------------------------------------------------------
  # ● 次のアクターに切り替え
  #--------------------------------------------------------------------------
  def next_actor
    @actor.set_passive_skills
    @actor.release_unequippable_items
    @actor = $game_party.menu_actor_next
    on_actor_change
  end
  #--------------------------------------------------------------------------
  # ● 前のアクターに切り替え
  #--------------------------------------------------------------------------
  def prev_actor
    @actor.set_passive_skills
    @actor.release_unequippable_items
    @actor = $game_party.menu_actor_prev
    on_actor_change
  end
  #--------------------------------------------------------------------------
  # ● アクターの切り替え
  #--------------------------------------------------------------------------
  def on_actor_change
    setup_actor
    @command_window.select(0)
    @command_window.activate
  end
  #--------------------------------------------------------------------------
  # ● 習得→記録の切り替え
  #--------------------------------------------------------------------------
  def set_learnd_to_memorize
    @learnd_skill_window.deactivate
    @learnd_skill_window.unselect
    @learnd_skill_window.select_skill = 0
    @learnd_skill_window.refresh
    @memorized_skill_window.activate
    @memorized_skill_window.select(@keep_memorize_index)
    @pop_window.hide
  end
  #--------------------------------------------------------------------------
  # ● 記録→コマンドの切り替え
  #--------------------------------------------------------------------------
  def set_memorize_to_command
    @memorized_skill_window.deactivate
    @memorized_skill_window.select(0)
    @memorized_skill_window.unselect
    @command_window.activate
    @command_window.select(0)
    @pop_window.hide
  end
  #--------------------------------------------------------------------------
  # ● 記録容量確認
  #--------------------------------------------------------------------------
  def max_memorize_cheack
    unless KURE::SkillMemorize::NOT_ADOPT_MAX_MEMORY_SKILL_TYPE.include?(@command_window.current_ext)
      if @memorized_skill_window.data.size > @actor.max_memorize[@command_window.current_ext - 1]
        for i in @actor.max_memorize[@command_window.current_ext - 1]..@memorized_skill_window.data.size - 1
          @actor.delete_memorize_skill(@memorized_skill_window.data.id)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● ポップアップを表示
  #--------------------------------------------------------------------------
  def view_popup
    flag = 0
   
    if (@before_memorize - @after_memorize).size > 0
      @pop_window.delete_skill = (@before_memorize - @after_memorize)
      flag = 1
    else
      @pop_window.delete_skill = []
    end
   
    if (@after_memorize - @before_memorize).size > 0
      @pop_window.add_skill = (@after_memorize - @before_memorize)
      flag = 1
    else
      @pop_window.add_skill = []
    end
   
    if flag == 1
      @pop_window.refresh
      Audio.se_play("Audio/SE/Chime2")
      @pop_window.show      
    end
  end
end

#==============================================================================
# ■ Game_Interpreter(追加定義)
#==============================================================================
class Game_Interpreter
  #--------------------------------------------------------------------------
  # ● メモライズ追加(記憶容量無制限)(追加定義)
  #--------------------------------------------------------------------------
  def memory_skill_ad(index, s_id)
    $game_actors[index].add_memorize_skill_ir(s_id, false)
  end
  #--------------------------------------------------------------------------
  # ● メモライズ追加(記憶容量制限)(追加定義)
  #--------------------------------------------------------------------------
  def memory_skill_ad_l(index, s_id)
    $game_actors[index].add_memorize_skill_ir(s_id, true)
  end
  #--------------------------------------------------------------------------
  # ● メモライズ削除(記憶容量制限)(追加定義)
  #--------------------------------------------------------------------------
  def memory_skill_dl(index, s_id)
    $game_actors[index].delete_memorize_skill(s_id)
  end
  #--------------------------------------------------------------------------
  # ● メモライズ初期化(追加定義)
  #--------------------------------------------------------------------------
  def memory_skill_dl_all(index)
    $game_actors[index].memory_skills_dl
  end
end

#==============================================================================
# ■ Window_SkillList(再定義)
#==============================================================================
class Window_SkillList < Window_Selectable
  #--------------------------------------------------------------------------
  # ● アイテム名の描画(再定義)
  #     enabled : 有効フラグ。false のとき半透明で描画
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, enabled = true, width = 172)
    return unless item
    draw_icon(item.icon_index, x, y, enabled)
   
    if @actor.extra_skills.include?(item)
      change_color(crisis_color, enabled)
    else
      change_color(normal_color, enabled)
    end
    draw_text(x + 24, y, width, line_height, item.name)
  end
end

#==============================================================================
# ■ Game_Actor(再定義)
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 記憶スキルオブジェクトの配列取得(追加定義)
  #--------------------------------------------------------------------------
  def memory_skills
    fix_memorys
    @memory_skills.collect {|id| $data_skills[id] }
  end
  #--------------------------------------------------------------------------
  # ● 記憶オブジェクト修正(追加定義)
  #--------------------------------------------------------------------------
  def fix_memorys
    for i in 0..@memory_skills.size - 1
      if @skills.include?(@memory_skills) == false
        if @sub_class_skills.include?(@memory_skills) == false
          if added_skills.include?(@memory_skills) == false
            @memory_skills = nil
          end
        end
      end
    end
    @memory_skills.compact!
    chain_memorize_set
  end
  #--------------------------------------------------------------------------
  # ● チェインメモライズのセット(追加定義)
  #--------------------------------------------------------------------------
  def chain_memorize_set
    extra_skills_dl
    return if KURE::SkillMemorize::CHAIN_MEMORIZE.size == 0
   
    for i in 0..KURE::SkillMemorize::CHAIN_MEMORIZE.size - 1
      #判定フラグ
      add_flag = 0
      skill = 0
      
      if KURE::SkillMemorize::CHAIN_MEMORIZE.size >= 2
        for j in 1..KURE::SkillMemorize::CHAIN_MEMORIZE.size - 1
          if @memory_skills.include?(KURE::SkillMemorize::CHAIN_MEMORIZE[j]) == true
          else
            add_flag = 1
          end
        end
      end
      
      if add_flag == 0
        set_extra_skill(KURE::SkillMemorize::CHAIN_MEMORIZE[0])
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● エクストラメモライズの記憶済み判定(追加定義)
  #--------------------------------------------------------------------------
  def extra_skill_memorize?(skill)
    skill.is_a?(RPG::Skill) && @extra_skills.include?(skill.id)
  end
  #--------------------------------------------------------------------------
  # ● エクストラメモライズ初期化処理(追加定義)
  #--------------------------------------------------------------------------
  def extra_skills_dl
    @extra_skills = []
  end
  #--------------------------------------------------------------------------
  # ● エクストラメモライズの記憶設定(追加定義)
  #--------------------------------------------------------------------------
  def set_extra_skill(skill_id)
    unless skill_memorize?($data_skills[skill_id])
      @extra_skills.push(skill_id)
    end
  end
  #--------------------------------------------------------------------------
  # ● エクストラメモライズオブジェクトの配列取得(追加定義)
  #--------------------------------------------------------------------------
  def extra_skills
    @extra_skills.collect {|id| $data_skills[id] }
  end
  #--------------------------------------------------------------------------
  # ● スキルの記憶済み判定(追加定義)
  #--------------------------------------------------------------------------
  def skill_memorize?(skill)
    skill.is_a?(RPG::Skill) && @memory_skills.include?(skill.id)
  end
  #--------------------------------------------------------------------------
  # ● スキルを記憶する(追加定義)
  #--------------------------------------------------------------------------
  def add_memorize_skill(skill_id,index)
    unless skill_memorize?($data_skills[skill_id])
      if index != nil
        @memory_skills[index] = skill_id
        @memory_skills.compact!
      else
        @memory_skills.push(skill_id)
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● スキル記憶を削除する(追加定義)
  #--------------------------------------------------------------------------
  def delete_memorize_skill(skill_id)
    @memory_skills.delete(skill_id)
  end  
  #--------------------------------------------------------------------------
  # ● 最大数記憶数(追加定義)
  #--------------------------------------------------------------------------
  def max_memorize
    #基礎値配列を取得
    memorize = Marshal.load(Marshal.dump(KURE::SkillMemorize::BASE_MAX_MEMORY))
   
    #スキルタイプごとの職業補正を取得
    for i in 0..memorize.size - 1
      if self.class.max_memorize_revise != nil
        memorize = memorize + self.class.max_memorize_revise
      end
    end
   
    #Lv補正を加算
    for j in 0..memorize.size - 1
      memorize[j] = memorize[j] + (KURE::SkillMemorize::Lv_MAX_MEMORY[j] * @level).to_i
    end   
   
    #スキルタイプごとの変数補正を取得
    for i in 0..memorize.size - 1
      if self.class.add_max_memorize_var != nil
        memorize = memorize + $game_variables[self.class.add_max_memorize_var]
      end
    end
   
    #装備補正を加算
    if KURE::BaseScript::USE_ExEquip == 1
      for k in 0..memorize.size - 1
        memorize[k] += all_gain_max_memorize
      end
    end

    #上限値設定
    for j in 0..memorize.size - 1
      memorize[j] = [memorize[j],KURE::SkillMemorize::MAX_MEMORY_CAP[j]].min if KURE::SkillMemorize::MAX_MEMORY_CAP[j] != 0
      if KURE::SkillMemorize::NOT_ADOPT_MAX_MEMORY_SKILL_TYPE.include?(j+1)
        memorize[j] += 999999
      end
    end
   
    return memorize
  end
  #--------------------------------------------------------------------------
  # ● メモライズ容量最大値(追加定義)
  #--------------------------------------------------------------------------
  def max_memorize_capacity
    #基礎値配列を取得
    capacity = Marshal.load(Marshal.dump(KURE::SkillMemorize::BASE_MEMORIZE_CAPACITY))
   
    #スキルタイプごとの職業補正を取得
    for i in 0..capacity.size - 1
      if self.class.memorize_capacity_revise != nil
        capacity = capacity + self.class.memorize_capacity_revise
      end
    end
   
    #スキルタイプごとの変数補正を取得
    for i in 0..capacity.size - 1
      if self.class.add_max_memorize_cap_var != nil
        capacity = capacity + $game_variables[self.class.add_max_memorize_cap_var]
      end
    end
   
    #Lv補正を加算
    for j in 0..capacity.size - 1
      capacity[j] = capacity[j] + (KURE::SkillMemorize::Lv_MEMORIZE_CAPACITY[j] * @level).to_i
    end   
   
    #装備補正を加算
    if KURE::BaseScript::USE_ExEquip == 1
      for k in 0..capacity.size - 1
        capacity[k] += all_gain_memorize
      end
    end
   
    #上限値設定
    for j in 0..capacity.size - 1
      capacity[j] = [capacity[j],KURE::SkillMemorize::MAX_MEMORIZE_CAP[j]].min if KURE::SkillMemorize::MAX_MEMORIZE_CAP[j] != 0
      if KURE::SkillMemorize::NOT_ADOPT_MEMORIZE_CAPACITY_SKILL_TYPE.include?(j+1)
        capacity[j] += 999999
      end
    end     
   
    return capacity
  end
  #--------------------------------------------------------------------------
  # ● メモライズ容量(追加定義)
  #--------------------------------------------------------------------------
  def memorize_capacity(stype_id)
    fix_memorys
    capacity = 0
    for i in 0..@memory_skills.size - 1
      if $data_skills[@memory_skills].stype_id  == stype_id
        capacity = capacity + $data_skills[@memory_skills].memorize_capacity
      end
    end
    return capacity
  end
  #--------------------------------------------------------------------------
  # ● イベントコマンド用メモライズ追加処理(追加定義)
  #--------------------------------------------------------------------------
  def add_memorize_skill_ir(skill_id, limit)
    for i in @memory_skills
      delete_memorize_skill(i) unless skills.include?($data_skills)
    end
    skill = $data_skills[skill_id]
    return if unselect_skill?(skill.id)
    return if skill_memorize?(skill)
    value = 0
    value2 = 0
    if limit == true
      for i in @memory_skills
        value += 1 if $data_skills.stype_id == skill.stype_id
      end
      unless KURE::SkillMemorize::NOT_ADOPT_MAX_MEMORY_SKILL_TYPE.include?(skill.stype_id)
        return if max_memorize[skill.stype_id - 1] <= value
      end
        
      for i in @memory_skills
        value2 = memorize_capacity(skill.stype_id)
      end
      return if max_memorize_capacity[skill.stype_id - 1] < skill.memorize_capacity + value2
      
    end
    @memory_skills.push(skill_id)
  end
  #--------------------------------------------------------------------------
  # ● イベントコマンド用メモライズ初期化処理(追加定義)
  #--------------------------------------------------------------------------
  def memory_skills_dl
    @memory_skills = []
  end

end

#==============================================================================
# ■ Window_k_Skillmemorize_SkillCommand(新規)
#==============================================================================
class Window_k_Skillmemorize_SkillCommand < Window_Command
  attr_accessor :actor
  attr_accessor :memorized_skill_window
  attr_accessor :learnd_skill_window
  #--------------------------------------------------------------------------
  # ● 表示行数の取得
  #--------------------------------------------------------------------------
  def visible_line_number
    4
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ幅の取得
  #--------------------------------------------------------------------------
  def window_width
    return Graphics.width
  end
  #--------------------------------------------------------------------------
  # ● アクターの設定
  #--------------------------------------------------------------------------
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● カーソル位置の設定
  #--------------------------------------------------------------------------
  def index=(index)
    @index = index
    update_cursor
    call_update_help
   
    return if @index < 0
    @memorized_skill_window.stype_id = current_ext if @memorized_skill_window
    @learnd_skill_window.stype_id = current_ext if @learnd_skill_window
  end
  #--------------------------------------------------------------------------
  # ● 全項目の描画
  #--------------------------------------------------------------------------
  def draw_all_items
   
    item_max.times {|i| draw_item(i) }
   
    draw_actor_memorize
  end
  #--------------------------------------------------------------------------
  # ● 項目を描画する矩形の取得
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new
    rect.width = item_width - 270
    rect.height = item_height
    rect.x = index % col_max * (item_width + spacing) + 270
    rect.y = index / col_max * item_height
    rect
  end
  #--------------------------------------------------------------------------
  # ● 記憶容量の描画
  #--------------------------------------------------------------------------
  def draw_actor_memorize
    x = Graphics.width - 160
    i = 0
    return if @actor == nil
    #スキルタイプの配列を作成
    stype_list = Marshal.load(Marshal.dump(@actor.added_skill_types))
   
    stype_list.sort!
    counter = 0
    for i in 0..stype_list.size - 1
      skill_type = stype_list
      
      #表示しないスキルタイプは扱わない
      unless KURE::SkillMemorize::NOT_VIEW_SKILLTYPE.include?(skill_type)
      
      #容量表示をするのであれば描画する。
      if KURE::SkillMemorize::VIEW_MEMORIZE_GAGE[skill_type - 1] == 1
        memory = @actor.memorize_capacity(skill_type)
        memory_max = @actor.max_memorize_capacity[skill_type - 1]
        memorize_rate = memory.to_f / memory_max
        
        if memory_max > 999999
          memory_max = "∞"
          memorize_rate = 0
        end
         
        draw_gauge(x, line_height * counter, 124, memorize_rate, tp_gauge_color1, tp_gauge_color2)
        change_color(system_color)
        draw_text(x, line_height * counter, 30, line_height, KURE::SkillMemorize::MEMORIZE_CAPACITY_NAME)
        draw_current_and_max_values(x, line_height * counter, 124, memory, memory_max,
        mp_color(actor), normal_color)
      end
        counter += 1
      end
    end
  end   
  #--------------------------------------------------------------------------
  # ● 選択項目の拡張データを取得
  #--------------------------------------------------------------------------
  def current_ext
    current_data ? current_data[:ext] : nil
  end
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  def make_command_list
    return unless @actor
    @actor.added_skill_types.sort.each do |stype_id|
      name = $data_system.skill_types[stype_id]
      if KURE::SkillMemorize::NOT_VIEW_SKILLTYPE.include?(stype_id)
      else
        add_command(name, :skill, true, stype_id)
      end
    end
  end
end

#==============================================================================
# ■ Window_k_SkillMemorize_SkillList(新規)
#==============================================================================
class Window_k_SkillMemorize_SkillList < Window_Command
  attr_reader :data
  attr_accessor :pop_window
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(x, y,width,height)
    @stype_id = 0
    @width = width
    @height = height
    super(x, y)
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ幅の取得
  #--------------------------------------------------------------------------
  def window_width
    return @width
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ高さの取得
  #--------------------------------------------------------------------------
  def window_height
    return @height
  end
  #--------------------------------------------------------------------------
  # ● スキルの取得
  #--------------------------------------------------------------------------
  def item
    @data && index >= 0 ? @data[index] : nil
  end
  #--------------------------------------------------------------------------
  # ● カーソルを下に移動
  #--------------------------------------------------------------------------
  def cursor_down(wrap = false)
    if @pop_window.visible == true
      @pop_window.hide
      return
    end
   
    if index < item_max - col_max || (wrap && col_max == 1)
      select((index + col_max) % item_max)
    end
  end
  #--------------------------------------------------------------------------
  # ● カーソルを上に移動
  #--------------------------------------------------------------------------
  def cursor_up(wrap = false)
    if @pop_window.visible == true
      @pop_window.hide
      return
    end
   
    if index >= col_max || (wrap && col_max == 1)
      select((index - col_max + item_max) % item_max)
    end
  end
  #--------------------------------------------------------------------------
  # ● アクターの設定
  #--------------------------------------------------------------------------
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● スキルタイプ ID の設定
  #--------------------------------------------------------------------------
  def stype_id=(stype_id)
    return if @stype_id == stype_id
    @stype_id = stype_id
    refresh
  end
  #--------------------------------------------------------------------------
  # ● 項目を描画する矩形の取得（テキスト用）
  #--------------------------------------------------------------------------
  def item_rect_for_text(index)
    rect = item_rect(index)
    rect.x += 28
    rect.width -= 8
    rect
  end
  #--------------------------------------------------------------------------
  # ● 全項目の描画
  #--------------------------------------------------------------------------
  def draw_all_items
    item_max.times {|i| draw_item(i) }
    return if @stype_id == nil
    if @stype_id != 0
      if KURE::SkillMemorize::NOT_ADOPT_MAX_MEMORY_SKILL_TYPE.include?(@stype_id)
        (@data.size + 1).times {|i| draw_number(i) } if @actor != nil
      else
        @actor.max_memorize[@stype_id - 1].times {|i| draw_number(i) } if @actor != nil
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 項目の描画
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if skill
      rect = item_rect(index)
      rect.width -= 4
      draw_item_name(skill, rect.x + 30, rect.y)
      
      if KURE::SkillMemorize::VIEW_MEMORIZE_CAPACITY == 1
        change_color(power_down_color)
        draw_text(rect.width - 30, line_height * index, 30, line_height, skill.memorize_capacity, 2) if skill.memorize_capacity != 0
      end
      
      change_color(normal_color)
    else
      rect = item_rect(index)
      rect.width -= 4
      change_color(normal_color, command_enabled?(index))
      draw_text(item_rect_for_text(index), command_name(index), alignment)
    end
  end
  #--------------------------------------------------------------------------
  # ● 番号の描画
  #--------------------------------------------------------------------------
  def draw_number(index)
    draw_text(0, line_height * index, 24, line_height, index + 1, 2)
  end
  #--------------------------------------------------------------------------
  # ● 項目を描画する矩形の取得（テキスト用）
  #--------------------------------------------------------------------------
  def item_rect_for_text(index)
    rect = item_rect(index)
    rect.x += 54
    rect.width -= 8
    rect
  end
  #--------------------------------------------------------------------------
  # ● ヘルプテキスト更新
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_item(item)
  end
  #--------------------------------------------------------------------------
  # ● スキルをリストに含めるかどうか
  #--------------------------------------------------------------------------
  def include?(item)
    item && item.stype_id == @stype_id
  end
  #--------------------------------------------------------------------------
  # ● 記録最大数
  #--------------------------------------------------------------------------
  def max_select
    return @data.size if KURE::SkillMemorize::NOT_ADOPT_MAX_MEMORY_SKILL_TYPE.include?(@stype_id)
    return 0 if @actor == nil
    return 0 if @stype_id == nil
   
    if @actor.max_memorize[@stype_id - 1] > @data.size
      return @data.size
    else
      return @actor.max_memorize[@stype_id - 1] - 1
    end
  end  
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  def make_command_list
    @data = @actor ? @actor.memory_skills.select {|skill| include?(skill) } : []
   
    for i in 0..max_select
      if @data != nil
        add_command(@data.name, :ok)
      else
        add_command("", :ok)      
      end
    end
   
  end
end

#==============================================================================
# ■ Window_k_LearndSkill_SkillList(新規)
#==============================================================================
class Window_k_LearndSkill_SkillList < Window_Command
  attr_reader :data
  attr_accessor :select_skill
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(x, y,width,height)
    @select_skill = 0
    @stype_id = 0
    @width = width
    @height = height
    super(x, y)
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ幅の取得
  #--------------------------------------------------------------------------
  def window_width
    return @width
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ高さの取得
  #--------------------------------------------------------------------------
  def window_height
    return @height
  end
  #--------------------------------------------------------------------------
  # ● スキルの取得
  #--------------------------------------------------------------------------
  def item
    @data && index >= 0 ? @data[index] : nil
  end
  #--------------------------------------------------------------------------
  # ● アクターの設定
  #--------------------------------------------------------------------------
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● スキルタイプ ID の設定
  #--------------------------------------------------------------------------
  def stype_id=(stype_id)
    return if @stype_id == stype_id
    @stype_id = stype_id
    refresh
  end
  #--------------------------------------------------------------------------
  # ● 項目の描画
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if skill
      rect = item_rect(index)
      rect.width -= 4
      draw_item_name(skill, rect.x, rect.y, command_enabled?(index))
      
      if KURE::SkillMemorize::VIEW_MEMORIZE_CAPACITY == 1
        change_color(power_down_color)
        draw_text(rect.width - 30, line_height * index, 30, line_height, skill.memorize_capacity, 2) if skill.memorize_capacity != 0
      end
      
      change_color(normal_color)
    else
      change_color(normal_color, command_enabled?(index))
      draw_text(item_rect_for_text(index), command_name(index), alignment)
    end
  end
  #--------------------------------------------------------------------------
  # ● 項目を描画する矩形の取得（テキスト用）
  #--------------------------------------------------------------------------
  def item_rect_for_text(index)
    rect = item_rect(index)
    rect.x += 24
    rect.width -= 8
    rect
  end
  #--------------------------------------------------------------------------
  # ● ヘルプテキスト更新
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_item(item)
  end
  #--------------------------------------------------------------------------
  # ● スキルをリストに含めるかどうか
  #--------------------------------------------------------------------------
  def include?(item)
    return false if @actor.extra_skill_memorize?(item)
    return false if item.stype_id != @stype_id or @actor.unselect_skill?(item.id)
    if item.note.include?("<无需记忆>")
      return true
    else
      memo = item.note.scan(/<无需记忆\s?(\d+)>/)
      memo = memo.flatten
      if memo != nil and not memo.empty?
        return true if memo.include?(@actor_id)
      end
      return true
    end
  end
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  def make_command_list
    return if @stype_id == nil
    #データ配列を作成
    @data = @actor ? @actor.skills.select {|skill| include?(skill) } : []
    memory = 0
    memory_max = 0
    select = 0
    #メモライズ容量判定用の変数を設定
    if @stype_id > 0
      memory = @actor.memorize_capacity(@stype_id)
      memory_max = @actor.max_memorize_capacity[@stype_id - 1]
    end
   
    if @select_skill != 0
      select = $data_skills[@select_skill].memorize_capacity
    end
      
    if @data.size != 0
      for i in 0..@data.size - 1
        flag = 0
        #共存不可メモライズのチェック
        jumble_list = @data.not_jumble_memorize
        if jumble_list != ([] or empty?)
          for skill in 0..jumble_list.size - 1
            if @actor.skill_memorize?($data_skills[jumble_list[skill]])
              add_command(@data.name, :ok ,false)
              flag = 1
            end
          end
        end
        
        if flag == 0
          #メモリー合計数を計算
          totalmemory = memory + @data.memorize_capacity
          if @actor.skill_memorize?(@data)
            add_command(@data.name, :ok ,false)
          else
            if totalmemory > memory_max + select
              add_command(@data.name, :ok ,false)
            else
              add_command(@data.name, :ok ,true)
            end
          end
        end
        
      end
    end
   
    add_command("解除", :ok)
  end
end

#==============================================================================
# ■ Window_k_SkillMemorize_SkillStatus
#==============================================================================
class Window_k_SkillMemorize_SkillStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, window_width, fitting_height(4))
    @actor = nil
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ幅の取得
  #--------------------------------------------------------------------------
  def window_width
    280
  end
  #--------------------------------------------------------------------------
  # ● アクターの設定
  #--------------------------------------------------------------------------
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    return unless @actor
    draw_actor_face(@actor, 0, 0)
    draw_actor_name(@actor, 108, 0)
    draw_actor_level(@actor, 108, line_height * 1)
    draw_actor_class(@actor, 108, line_height * 2)
  end
end

#==============================================================================
# ■ Window__k_SkillMemorize_Popup
#==============================================================================
class Window__k_SkillMemorize_Popup < Window_Base
  attr_accessor :add_skill
  attr_accessor :delete_skill
  #--------------------------------------------------------------------------
  # ● アクターの設定
  #--------------------------------------------------------------------------
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    @add_skill = [] if @add_skill == nil
    @delete_skill = [] if @delete_skill == nil
   
    self.height = line_height * (4 + @add_skill.size + @delete_skill.size)
    self.height += line_height if @add_skill.size == 0
    self.height += line_height if @delete_skill.size == 0
    create_contents
    contents.clear
   
    #描画位置
    base_y = line_height * (1 + @add_skill.size)
   
    #追加スキルの描画
    draw_gauge(5,0, contents.width, 1, mp_gauge_color2,crisis_color)
    draw_text(5, 0, contents.width, line_height, "追加メモライズ")
   
    if @add_skill.size != 0
      for i in 0..@add_skill.size - 1
        draw_item_name($data_skills[@add_skill], 5, line_height * (1 + i))
        
        for j in 0..KURE::SkillMemorize::CHAIN_MEMORIZE.size - 1
          if KURE::SkillMemorize::CHAIN_MEMORIZE[j] != nil
            if KURE::SkillMemorize::CHAIN_MEMORIZE[j][0] == $data_skills[@add_skill].id
              for k in 1..KURE::SkillMemorize::CHAIN_MEMORIZE[j].size - 1
                draw_icon($data_skills[KURE::SkillMemorize::CHAIN_MEMORIZE[j][k]].icon_index, 180 + 30 * ( k -1 ), line_height * (1 + i))
              end
            end
          end
        end
        
      end
    end
   
    base_y += line_height if @add_skill.size == 0
   
    #削除スキルの描画
    draw_gauge(5, base_y, contents.width, 1, mp_gauge_color2,crisis_color)
    draw_text(5, base_y, contents.width, line_height, "削除メモライズ")
   
    if @delete_skill.size != 0
      for i in 0..@delete_skill.size - 1
        draw_item_name($data_skills[@delete_skill], 5, line_height * (1 + i) + base_y)
        
        for j in 0..KURE::SkillMemorize::CHAIN_MEMORIZE.size - 1
          if KURE::SkillMemorize::CHAIN_MEMORIZE[j] != nil
            if KURE::SkillMemorize::CHAIN_MEMORIZE[j][0] == $data_skills[@delete_skill].id
              for k in 1..KURE::SkillMemorize::CHAIN_MEMORIZE[j].size - 1
                draw_icon($data_skills[KURE::SkillMemorize::CHAIN_MEMORIZE[j][k]].icon_index, 180 + 30 * ( k -1 ), line_height * (1 + i) + base_y)
              end
            end
          end
        end        
        
      end
    end   
   
  end  
end[/pre]

chd114

cjlzbb 发表于 2015-2-9 05:49
以前有看过个VA的版本，不是6R上的，是日文的。已找到，不知道还有没有前置脚本。给楼主做个参考吧

#===== ...

能翻译一下这具体功能有哪些吗。。。

chd114

chd114 发表于 2015-2-9 05:37
我已经解决了这里的问题，要去掉两个的其中一个，整合成就可以了

这个问题出现的BUG（详见点评）明白了···因为装上技能以后右侧光标还在显示，再次移动过去也是在那个位置，如果技能已经全部装备就会出现不存在的选项也能下掉技能的情况···

1. #--------------------------------------------------------------------------
   
2.   # ○ 右侧窗口更新
   
3.   #--------------------------------------------------------------------------
   
4.   def update_list
   
5.     if Input.trigger?(Input::B)
   
6.       Sound.play_cancel
   
7.       # 切换活动窗口
   
8.       @slot_window.active = true
   
9.       @list_window.active = false
   
10.     elsif Input.trigger?(Input::C)
    
11.       skill = @list_window.skill
    
12.       return if skill==nil and @list_window.index>0#加上我
    
13.       # 无法设置的场合
    
14.       unless @actor.battle_skill_settable?(@slot_window.index, skill)
    
15.         Sound.play_buzzer
    
16.         return
    
17.       end
    
18.       Sound.play_ok
    
19.       set_skill(@slot_window.index, skill)
    
20.       @slot_window.active = true
    
21.       @list_window.active = false
    
22.     end
    
23.   end

复制代码

加一句return if skill==nil and @list_window.index>0可以解决掉不存在的选项也能移除技能的BUG，但是光标还是会显示在那···所以这解决方法有点不合理···@VIPArcher 有什么好的解决办法吗？

沉夜

这个拿来做武侠游戏的内功系统不错……

80023456

怎么让某些技能 固定无法卸下  ？