ycrpg/js/plugins/YEP_SkillLearnSystem.js

//=============================================================================
// Yanfly Engine Plugins - Skill Learn System
// YEP_SkillLearnSystem.js
//=============================================================================

var Imported = Imported || {};
Imported.YEP_SkillLearnSystem = true;

var Yanfly = Yanfly || {};
Yanfly.SLS = Yanfly.SLS || {};
Yanfly.SLS.version = 1.13;

//=============================================================================
 /*:
 * @plugindesc v1.13 技能学习系统☁️
 * @author Yanfly Engine Plugins
 *
 * @param ---命令---
 * @default
 *
 * @param Learn Command
 * @text 学习命令
 * @desc How the command for learning skills appear in the skill
 * command window.
 * @default 学习技能
 *
 * @param Show Command
 * @text 显示命令
 * @desc Show the Learn command in the main menu by default?
 * NO - false     YES - true
 * @default true
 *
 * @param Enable Command
 * @text 启用命令
 * @desc Enable the Learn command in the main menu by default?
 * NO - false     YES - true
 * @default true
 *
 * @param Integrate
 * @text 整合
 * @desc Integrate Learn Skills into the Skill scene?
 * NO - false     YES - true
 * @default false
 *
 * @param ---确认学习---
 * @default
 *
 * @param Confirm Window
 * @text 确认窗口
 * @desc For non-integrated menu, show a learn confirmation?
 * NO - false     YES - true
 * @default true
 *
 * @param Confirm Text
 * @text 确认文本
 * @desc If using the confirm window, this is the text used.
 * %1 - Actor     %2 - Skill Name
 * @default %1 学习 %2吗？
 *
 * @param Confirm Yes
 * @text 确认是
 * @desc Text used to display yes.
 * @default 学习
 *
 * @param Confirm No
 * @text 确认否
 * @desc Text used to display no.
 * @default 不学习
 *
 * @param ---技能学习---
 * @default
 *
 * @param Learned Text
 * @text 学习的文本
 * @desc Text showing the skill has been learned.
 * @default 学习
 *
 * @param Learned Size
 * @text 学习的大小
 * @desc Font size for the text showing the skill has been learned.
 * Default: 28
 * @default 20
 *
 * @param Learn Cost
 * @text 学习费用
 * @desc Text used to list what are the learn costs for the skill.
 * @default 学习技能费用
 *
 * @param Cost Size
 * @text 费用大小
 * @desc Font size used for the cost of learning a skill.
 * Default: 28
 * @default 20
 *
 * @param Show Gold Window
 * @text 显示金币窗口
 * @desc Shows the gold window when learning a new skill.
 * NO - false     YES - true
 * @default true
 *
 * @param ---默认---
 * @default
 *
 * @param Default Gold Cost
 * @text 默认金币费用
 * @desc Default gold cost of learning new skills.
 * @default 1000
 *
 * @param Default JP Cost
 * @text 默认JP费用
 * @desc Default JP cost of learning new skills.
 * Requires YEP_JobPoints.js
 * @default 100
 *
 * @help
 * ============================================================================
 * Introduction
 * ============================================================================
 *
 * 此插件可以让游戏中的角色在技能菜单中学习技能。学习技能的代价可以
 * 是金钱、物品或所谓的“职业点数”（Job Point）。它能够提供除了
 * 升级以外的获得技能的可选方式。
 *
 * Fox的JP（职业点数）等级——这个插件向Yanfly的JP系统中添加了
 * 等级概念，就像《最终幻想战略版》中那样。根据你当前职业的“职业等级”
 * （Job Level），你可以在SkillLearnSystem中获取相应的技能，也可以在
 * ClassChangeCore中更换相应的业。而职业等级只是通过增加JP来提高的。
 * 
 * 此插件可以通过YEP_JobPoints.js使用。
 * 在插件管理页面中，我们建议把这个插件放在YEP_JobPoints.js的下面。
 *
 * ============================================================================
 * Notetags
 * ============================================================================
 *
 * 通过下述注释来使用技能学习系统。
 *
 * 职业的注释:
 *   <Learn Skill: x>
 *   <Learn Skill: x, x, x>
 *   <Learn Skill: x to y>
 *   让此职业能够在菜单中学习技能x。如果是第三种情形x to y，
 *   它允许职业学习从x到y的所有技能，其中x和y是技能的ID。
 *
 * 技能注释:
 *   <Learn Cost: x Gold>
 *   设置学习此技能所要花费的金钱为x。
 *
 *   <Learn Cost: x JP>
 *   设置学习此技能所要花费的JP为x。
 * 这一条需要YEP_JobPoints.js插件才能运行。
 * 
 *   <Learn Cost>        or     <Learn Cost>
 *    Item x: y                  item name: y
 *    Weapon x: y                item name: y
 *    Armor x: y                </Learn Cost>
 *   </Learn Cost>
 *   设置学习此技能所要花费的物品、武器和防具，其中x是物品的ID，
 *   y是所需物品的数量。如果你打算用物品的名称作为变量，那么把
 *   item name换为物品在数据库中的名称。但如果有多个物品的名称
 *   相同，那么将会使用ID最大的东西（按照“物品＞武器＞防具”
 *   的顺序）作为费用。
 *   *注意：如果你在使用YEP_ItemCore.js插件及“独立物品”
 *   （Independent Items），那么学习费用将不包括那些独立物品。
 *
 *   <Learn Require Level: x>
 *   角色等级到达x之后，此技能才会出现在可学习技能的列表上。
 *
 *   <Learn Require Skill: x>
 *   <Learn Require Skill: x, x, x>
 *   <Learn Require Skill: x to y>
 *   角色必须已经掌握其他技能x，此技能才会出现（在列表上）。如果是
 *   第三种情形x to y，角色必须已经掌握从x到y的所有技能，
 *   其中x和/或y是技能的ID。
 *
 *   <Learn Require Switch: x>
 *   <Learn Require Switch: x, x, x>
 *   <Learn Require Switch: x to y>
 *   开关x必须已被打开，此技能才会出现。如果是第三种情形x to y，
 *   从x到y的所有开关必须已被打开，技能才会出现，其中x和/或y是开关的ID。
 *
 * ============================================================================
 * “疯狂模式”——自定义要求和花费
 * ============================================================================
 *
 * 如果你只有很少的JavaScript使用经验，并且希望更好地定做技能学习的
 * 方法，那么你可以用下列注释：
 *
 * 技能的注释：
 *
 *   <Learn Show Eval>
 *    value = true;
 *    value = false;
 *   </Learn Show Eval>
 *   如果想用一串代码来隐藏或显示此技能，你可以使用这些注释。若
 *   返回value的值为true，那么即使其它要求不被满足，技能也会出现
 *   （在列表上）。而若返回value的值为false，那么即使其它
 *   要求被满足，技能也不会出现。
 *  
 *   <Learn Require Eval>
 *    value = true;
 *    value = false;
 *   </Learn Require Eval>
 *   给希望通过代码设置自己特定的技能学习要求的人使用。只有返回
 *   value的值为true，技能才会显示为可学的。请避免使用可以停止
 *   后续代码工作的命令。code.
 *
 *   <Learn Cost Eval>
 *    code
 *    code
 *   </Learn Cost Eval>
 *   如果你熟悉JavaScript，你可以在通过学习技能菜单
 * 学习技能之后自定义一些功能。
 * 
 *   <Learn Custom Text>
 *    text
 *    text
 *   </Learn Custom Text>
 *   在主要花费的下面显示自定义文字。可以在这里使用文本代码。
 *
 * ============================================================================
 * Lunatic Mode - Custom JP Costs
 * ============================================================================
 *
 * For those who have basic JavaScript knowledge and would like to make the JP
 * costs for skills dynamic, you can use the following notetags:
 *
 * Skill Notetags:
 *
 *   <Custom Learn JP Cost>
 *    cost = user.level * 100;
 *   </Custom Learn JP Cost>
 *   The 'cost' variable is the value that will be returned as a result of this
 *   Lunatic Mode notetag. The value returned here from this code will be added
 *   on top of the <Learn Cost: x JP> value.
 *
 * ============================================================================
 * Plugin Commands  插件命令
 * ============================================================================
 *
 * 可以从事件编辑器（Event Editor）中使用下列插件命令，来确定
 * 你是否想让“学习技能”命令出现在技能界面以使之可行。
 *
 * Plugin Command:
 *   ShowLearnSkill            显示“学习技能”命令。
 *   HideLearnSkill            隐藏“学习技能”命令。
 *   EnableLearnSkill          使“学习技能”命令可行。
 *   DisableLearnSkill         使“学习技能”命令不可行。
 *   OpenLearnSkill actor x    为角色x打开学习技能菜单。
 *   OpenLearnSkill party x    为队伍成员x打开学习技能菜单。
 *
 * ============================================================================
 * Changelog
 * ============================================================================
 *
 * Version 1.13:
 * - Lunatic Mode fail safes added.
 *
 * Version 1.12:
 * - Updated for RPG Maker MV version 1.3.2.
 *
 * Version 1.11:
 * - Removed dependency on YEP_JobPoints.js if using Integrated skill learn.
 *
 * Version 1.10:
 * - Added <Custom Learn JP Cost> Lunatic Mode notetag. Look in the plugin's
 * helpfile for more details!
 *
 * Version 1.09:
 * - Compatibility update with Class Change Core's <Use Nickname> notetag.
 *
 * Version 1.08:
 * - Updated for RPG Maker MV version 1.1.0.
 *
 * Version 1.07:
 * - Updated the <Learn Require Level: x> notetag. If you are using the Class
 * Change Core, the requirement will now depend on the level of the class.
 *
 * Version 1.06b:
 * - Added 'Confirm Window', 'Confirm Text', 'Confirm Yes', 'Confirm No' to the
 * plugin's parameters. This confirm window only appears for non-integrated
 * menus as the integrated menus have a class confirmation window already.
 * - Confirm Text now supports text codes.
 * - Fixed a visual bug when learning skills.
 *
 * Version 1.05:
 * - Fixed a bug with the 'OpenLearnSkill party x' plugin command not opening
 * the correct party member.
 *
 * Version 1.04:
 * - Fixed a bug that would duplicate non-independent items.
 * - Fixed a bug with class portraits not updating properly.
 *
 * Version 1.03a:
 * - Fixed a bug where JP values weren't updated upon learning.
 * - Fixed a bug where the help description didn't update if a skill vanished.
 *
 * Version 1.02:
 * - Reversed the display for item requirements so it is now Held/Needed.
 * - Preparations for compatibility for Class Change Core.
 *
 * Version 1.01:
 * - Added an actor refresh to learn and forget skills.
 *
 * Version 1.00:
 * - Finished Plugin!
 */
//=============================================================================

//=============================================================================
// Parameter Variables
//=============================================================================

Yanfly.Parameters = PluginManager.parameters('YEP_SkillLearnSystem');
Yanfly.Param = Yanfly.Param || {};

Yanfly.Param.SLSCommand = String(Yanfly.Parameters['Learn Command']);
Yanfly.Param.SLSShowLearn = String(Yanfly.Parameters['Show Command']);
Yanfly.Param.SLSShowLearn = eval(Yanfly.Param.SLSShowLearn);
Yanfly.Param.SLSEnableLearn = String(Yanfly.Parameters['Enable Command']);
Yanfly.Param.SLSEnableLearn = eval(Yanfly.Param.SLSEnableLearn);
Yanfly.Param.SLSIntegrate = String(Yanfly.Parameters['Integrate']);
Yanfly.Param.SLSIntegrate = eval(Yanfly.Param.SLSIntegrate);

Yanfly.Param.SLSConfirmWin = eval(String(Yanfly.Parameters['Confirm Window']));
Yanfly.Param.SLSConfirmText = String(Yanfly.Parameters['Confirm Text']);
Yanfly.Param.SLSConfirmYes = String(Yanfly.Parameters['Confirm Yes']);
Yanfly.Param.SLSConfirmNo = String(Yanfly.Parameters['Confirm No']);

Yanfly.Param.SLSLearnText = String(Yanfly.Parameters['Learned Text']);
Yanfly.Param.SLSLearnSize = Number(Yanfly.Parameters['Learned Size']);
Yanfly.Param.SLSLearnCost = String(Yanfly.Parameters['Learn Cost']);
Yanfly.Param.SLSCostSize = Number(Yanfly.Parameters['Cost Size']);
Yanfly.Param.SLSItemCostFmt = String(Yanfly.Parameters['Item Cost']);
Yanfly.Param.SLSGoldWindow = String(Yanfly.Parameters['Show Gold Window']);
Yanfly.Param.SLSGoldWindow = eval(Yanfly.Param.SLSGoldWindow);

Yanfly.Param.SLSDefaultGold = Number(Yanfly.Parameters['Default Gold Cost']);
Yanfly.Param.SLSDefaultJp = Number(Yanfly.Parameters['Default JP Cost']);

//=============================================================================
// DataManager
//=============================================================================

Yanfly.SLS.DataManager_isDatabaseLoaded = DataManager.isDatabaseLoaded;
DataManager.isDatabaseLoaded = function() {
  if (!Yanfly.SLS.DataManager_isDatabaseLoaded.call(this)) return false;
  if (!Yanfly._loaded_YEP_SkillLearnSystem) {
    this.processSLSNotetagsI($dataItems);
    this.processSLSNotetagsW($dataWeapons);
    this.processSLSNotetagsA($dataArmors);
    this.processSLSNotetags1($dataClasses);
    this.processSLSNotetags2($dataSkills);
    Yanfly._loaded_YEP_SkillLearnSystem = true;
  }
  return true;
};

DataManager.processSLSNotetagsI = function(group) {
  if (Yanfly.ItemIdRef) return;
  Yanfly.ItemIdRef = {};
  for (var n = 1; n < group.length; n++) {
    var obj = group[n];
    if (obj.name.length <= 0) continue;
    Yanfly.ItemIdRef[obj.name.toUpperCase()] = n;
  }
};

DataManager.processSLSNotetagsW = function(group) {
  if (Yanfly.WeaponIdRef) return;
  Yanfly.WeaponIdRef = {};
  for (var n = 1; n < group.length; n++) {
    var obj = group[n];
    if (obj.name.length <= 0) continue;
    Yanfly.WeaponIdRef[obj.name.toUpperCase()] = n;
  }
};

DataManager.processSLSNotetagsA = function(group) {
  if (Yanfly.ArmorIdRef) return;
  Yanfly.ArmorIdRef = {};
  for (var n = 1; n < group.length; n++) {
    var obj = group[n];
    if (obj.name.length <= 0) continue;
    Yanfly.ArmorIdRef[obj.name.toUpperCase()] = n;
  }
};

DataManager.processSLSNotetags1 = function(group) {
  var note1 = /<(?:LEARN SKILL|learn skills):[ ]*(\d+(?:\s*,\s*\d+)*)>/i;
  var note2 =
    /<(?:LEARN SKILL|learn skills):[ ](\d+)[ ](?:THROUGH|to)[ ](\d+)>/i;
  for (var n = 1; n < group.length; n++) {
    var obj = group[n];
    var notedata = obj.note.split(/[\r\n]+/);

    obj.learnSkills = [];

    for (var i = 0; i < notedata.length; i++) {
      var line = notedata[i];
      if (line.match(note1)) {
        var array = JSON.parse('[' + RegExp.$1.match(/\d+/g) + ']');
        obj.learnSkills = obj.learnSkills.concat(array);
      } else if (line.match(note2)) {
        var range = Yanfly.Util.getRange(parseInt(RegExp.$1),
          parseInt(RegExp.$2));
        obj.learnSkills = obj.learnSkills.concat(range);
      }
    }
  }
};

DataManager.processSLSNotetags2 = function(group) {
  var note1 = /<(?:LEARN COST)>/i;
  var note2 = /<\/(?:LEARN COST)>/i;
  var note3 = /<(?:LEARN COST):[ ](\d+)[ ](?:GOLD)>/i;
  var note4 = /<(?:LEARN COST):[ ](\d+)[ ](?:JP)>/i;
  var note5 = /<(?:LEARN REQUIRE LEVEL):[ ](\d+)>/i;
  var note6 = /<(?:LEARN REQUIRE SKILL):[ ]*(\d+(?:\s*,\s*\d+)*)>/i;
  var note7 = /<(?:LEARN REQUIRE SKILL):[ ](\d+)[ ](?:THROUGH|to)[ ](\d+)>/i;
  var note8 = /<(?:LEARN REQUIRE SWITCH):[ ]*(\d+(?:\s*,\s*\d+)*)>/i;
  var note9 = /<(?:LEARN REQUIRE SWITCH):[ ](\d+)[ ](?:THROUGH|to)[ ](\d+)>/i;
  var note10 = /<(?:LEARN REQUIRE EVAL)>/i;
  var note11 = /<\/(?:LEARN REQUIRE EVAL)>/i;
  var note12 = /<(?:LEARN COST EVAL)>/i;
  var note13 = /<\/(?:LEARN COST EVAL)>/i;
  var note14 = /<(?:LEARN CUSTOM TEXT)>/i;
  var note15 = /<\/(?:LEARN CUSTOM TEXT)>/i;
  var note16 = /<(?:LEARN SHOW EVAL)>/i;
  var note17 = /<\/(?:LEARN SHOW EVAL)>/i;
  for (var n = 1; n < group.length; n++) {
    var obj = group[n];
    var notedata = obj.note.split(/[\r\n]+/);

    obj.learnCost = [];
    obj.learnCostGold = Yanfly.Param.SLSDefaultGold;
    obj.learnCostJp = Yanfly.Param.SLSDefaultJp;
    obj.learnRequireLevel = 0;
    obj.learnRequireSkill = [];
    obj.learnRequireSwitch = [];
    obj.learnRequireEval = '';
    obj.learnCostEval = '';
    obj.learnShowEval = '';
    obj.learnCustomText = '';
    var mode = 'none';
    obj.customLearnJpCostEval = '';

    for (var i = 0; i < notedata.length; i++) {
      var line = notedata[i];
      if (line.match(note1)) {
        mode = 'learn';
      } else if (line.match(note2)) {
        mode = 'none';
      } else if (mode === 'learn') {
        this.addLearnSkillCost(obj, line);
      } else if (line.match(note3)) {
        obj.learnCostGold = parseInt(RegExp.$1);
      } else if (line.match(note4)) {
        obj.learnCostJp = parseInt(RegExp.$1);
      } else if (line.match(note5)) {
        obj.learnRequireLevel = parseInt(RegExp.$1);
      } else if (line.match(note6)) {
        var array = JSON.parse('[' + RegExp.$1.match(/\d+/g) + ']');
        obj.learnRequireSkill = obj.learnRequireSkill.concat(array);
      } else if (line.match(note7)) {
        var range = Yanfly.Util.getRange(parseInt(RegExp.$1),
          parseInt(RegExp.$2));
        obj.learnRequireSkill = obj.learnRequireSkill.concat(range);
      } else if (line.match(note8)) {
        var array = JSON.parse('[' + RegExp.$1.match(/\d+/g) + ']');
        obj.learnRequireSwitch = obj.learnRequireSwitch.concat(array);
      } else if (line.match(note9)) {
        var range = Yanfly.Util.getRange(parseInt(RegExp.$1),
          parseInt(RegExp.$2));
        obj.learnRequireSwitch = obj.learnRequireSwitch.concat(range);
      } else if (line.match(note10)) {
        mode = 'learnRequireEval';
      } else if (line.match(note11)) {
        mode = 'none';
      } else if (line.match(note12)) {
        mode = 'learnCostEval';
      } else if (line.match(note13)) {
        mode = 'none';
      } else if (line.match(note14)) {
        mode = 'learnCustomText';
      } else if (line.match(note15)) {
        mode = 'none';
      } else if (line.match(note16)) {
        mode = 'learnShowEval';
      } else if (line.match(note17)) {
        mode = 'none';
      } else if (mode === 'learnRequireEval') {
        obj.learnRequireEval = obj.learnRequireEval + line + '\n';
      } else if (mode === 'learnCostEval') {
        obj.learnCostEval = obj.learnCostEval + line + '\n';
      } else if (mode === 'learnCustomText') {
        obj.learnCustomText = obj.learnCustomText + line + '\n';
      } else if (mode === 'learnShowEval') {
        obj.learnShowEval = obj.learnShowEval + line + '\n';
      } else if (line.match(/<(?:CUSTOM LEARN JP COST)>/i)) {
        mode = 'customLearnJpCost';
      } else if (line.match(/<\/(?:CUSTOM LEARN JP COST)>/i)) {
        mode = 'none';
      } else if (mode === 'customLearnJpCost') {
        obj.customLearnJpCostEval = obj.customLearnJpCostEval + line + '\n';
      }
    }
  }
};

DataManager.addLearnSkillCost = function(obj, line) {
    if (!obj) return;
    if (!line) return;
    if (line.match(/ITEM[ ](\d+):[ ](\d+)/i)) {
      var item = $dataItems[parseInt(RegExp.$1)];
      if (!item) return;
      if (Imported.YEP_ItemCore && DataManager.isIndependent(item)) return;
      obj.learnCost.push(line);
    } else if (line.match(/WEAPON[ ](\d+):[ ](\d+)/i)) {
      var item = $dataWeapons[parseInt(RegExp.$1)];
      if (!item) return;
      if (Imported.YEP_ItemCore && DataManager.isIndependent(item)) return;
      obj.learnCost.push(line);
    } else if (line.match(/ARMOR[ ](\d+):[ ](\d+)/i)) {
      var item = $dataArmors[parseInt(RegExp.$1)];
      if (!item) return;
      if (Imported.YEP_ItemCore && DataManager.isIndependent(item)) return;
      obj.learnCost.push(line);
    } else if (line.match(/GOLD:[ ](\d+)/i)) {
      obj.learnCostGold = parseInt(RegExp.$1);
    } else if (line.match(/JP:[ ](\d+)/i)) {
      obj.learnCostJp = parseInt(RegExp.$1);
    } else if (line.match(/(.*):[ ](\d+)/i)) {
      var name = String(RegExp.$1).toUpperCase();
      var amount = parseInt(RegExp.$2);
      if (Yanfly.ItemIdRef[name]) {
        var id = Yanfly.ItemIdRef[name];
        var item = $dataItems[id];
        if (!item) return;
        if (Imported.YEP_ItemCore && DataManager.isIndependent(item)) return;
        obj.learnCost.push('ITEM ' + id + ': ' + amount);
      } else if (Yanfly.WeaponIdRef[name]) {
        var id = Yanfly.WeaponIdRef[name];
        var item = $dataWeapons[id];
        if (!item) return;
        if (Imported.YEP_ItemCore && DataManager.isIndependent(item)) return;
        obj.learnCost.push('WEAPON ' + id + ': ' + amount);
      } else if (Yanfly.ArmorIdRef[name]) {
        var id = Yanfly.ArmorIdRef[name];
        var item = $dataArmors[id];
        if (!item) return;
        if (Imported.YEP_ItemCore && DataManager.isIndependent(item)) return;
        obj.learnCost.push('ARMOR ' + id + ': ' + amount);
      }
    }
};

//=============================================================================
// Game_System
//=============================================================================

Yanfly.SLS.Game_System_initialize = Game_System.prototype.initialize;
Game_System.prototype.initialize = function() {
    Yanfly.SLS.Game_System_initialize.call(this);
    this.initSkillLearnSystem();
};

Game_System.prototype.initSkillLearnSystem = function() {
    this._showLearnSkill = Yanfly.Param.SLSShowLearn;
    this._enableLearnSkill = Yanfly.Param.SLSEnableLearn;
};

Game_System.prototype.isShowLearnSkill = function() {
    if (this._showLearnSkill === undefined) this.initSkillLearnSystem();
    return this._showLearnSkill;
};

Game_System.prototype.isEnableLearnSkill = function() {
    if (this._enableLearnSkill === undefined) this.initSkillLearnSystem();
    return this._enableLearnSkill;
};

//=============================================================================
// Game_Actor
//=============================================================================

Game_Actor.prototype.availableClasses = function() {
    if (!Imported.YEP_ClassChangeCore) return 1;
    return this.unlockedClasses().length;
};

Game_Actor.prototype.sufficientJpLearnSkill = function(skill, classId) {
  if (!skill) return false;
  if (!Imported.YEP_JobPoints) return true;
  var jpCost = skill.learnCostJp;
  jpCost += this.customLearnSkillJpCost(skill);
  if (this.currentClass().learnSkills.contains(skill.id)) {
    if (this.jp(classId) >= jpCost) return true;
  }
  if (Imported.YEP_ClassChangeCore && Yanfly.Param.SLSIntegrate) {
    for (var i = 0; i < this.unlockedClasses().length; ++i) {
      classId = this.unlockedClasses()[i];
      if (!$dataClasses[classId]) continue;
      if (!$dataClasses[classId].learnSkills.contains(skill.id)) continue;
      if (this.jp(classId) >= jpCost) return true;
    }
  } else if (Imported.YEP_ClassChangeCore && $dataClasses[classId]) {
    if ($dataClasses[classId].learnSkills.contains(skill.id)) {
      if (this.jp(classId) >= jpCost) return true;
    }
  }
  return false;
};

Game_Actor.prototype.isLearnedSkillRaw = function(skillId) {
  return this._skills.contains(skillId);
};

Game_Actor.prototype.canLearnSkill = function(skill, classId) {
    if (!skill) return false;
    if (skill.learnCostGold > $gameParty.gold()) return false;
    if (!this.sufficientJpLearnSkill(skill, classId)) return false;
    if (!$gameParty.sufficientItemLearnSkill(skill)) return false;
    return true;
};

Yanfly.SLS.Game_Actor_releaseUnequippableItems =
    Game_Actor.prototype.releaseUnequippableItems;
Game_Actor.prototype.releaseUnequippableItems = function(forcing) {
    if (Yanfly.SLS.PreventReleaseItem) return;
    Yanfly.SLS.Game_Actor_releaseUnequippableItems.call(this, forcing);
};

Game_Actor.prototype.customLearnSkillJpCost = function(skill) {
    if (!skill) return 0;
    if (skill.customLearnJpCostEval === '') return 0;
    var cost = 0;
    var item = skill;
    var a = this;
    var b = this;
    var user = this;
    var target = this;
    var s = $gameSwitches._data;
    var v = $gameVariables._data;
    var code = skill.customLearnJpCostEval;
    try {
      eval(code);
    } catch (e) {
      Yanfly.Util.displayError(e, code, 'CUSTOM SKILL LEARN JP COST ERROR');
    }
    return cost;
};

//=============================================================================
// Game_Party
//=============================================================================

Game_Party.prototype.sufficientItemLearnSkill = function(skill) {
    if (!skill) return false;
    for (var i = 0; i < skill.learnCost.length; ++i) {
      var line = skill.learnCost[i];
      var obj = null;
      var value = 0;
      if (line.match(/ITEM[ ](\d+):[ ](\d+)/i)) {
        obj = $dataItems[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      } else if (line.match(/WEAPON[ ](\d+):[ ](\d+)/i)) {
        obj = $dataWeapons[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      } else if (line.match(/ARMOR[ ](\d+):[ ](\d+)/i)) {
        obj = $dataArmors[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      }
      if (!obj) continue;
      if (value > $gameParty.numItems(obj)) return false;
    }
    return true;
};

Game_Party.prototype.processLearnSkillCost = function(skill) {
    if (!skill) return false;
    for (var i = 0; i < skill.learnCost.length; ++i) {
      var line = skill.learnCost[i];
      var obj = null;
      var value = 0;
      if (line.match(/ITEM[ ](\d+):[ ](\d+)/i)) {
        obj = $dataItems[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      } else if (line.match(/WEAPON[ ](\d+):[ ](\d+)/i)) {
        obj = $dataWeapons[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      } else if (line.match(/ARMOR[ ](\d+):[ ](\d+)/i)) {
        obj = $dataArmors[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      }
      if (!obj) continue;
      $gameParty.loseItem(obj, value, false);
    }
    return true;
};

Yanfly.SLS.Game_Party_setupBattleTest = Game_Party.prototype.setupBattleTest;
Game_Party.prototype.setupBattleTest = function() {
    Yanfly.SLS.Game_Party_setupBattleTest.call(this);
    this.setupLearnSkillBattleTest();
};

Game_Party.prototype.setupLearnSkillBattleTest = function() {
    for (var i = 0; i < this.members().length; ++i) {
      var actor = this.members()[i];
      if (!actor) continue;
      var classData = actor.currentClass();
      for (var j = 0; j < classData.learnSkills.length; ++j) {
        var skillId = classData.learnSkills[j];
        if (!$dataSkills[skillId]) continue;
        if ($dataSkills[skillId].name === '') continue;
        actor.learnSkill(skillId);
      }
      actor.refresh();
    }
};

//=============================================================================
// Game_Interpreter
//=============================================================================

Yanfly.SLS.Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function(command, args) {
    Yanfly.SLS.Game_Interpreter_pluginCommand.call(this, command, args)
    if (command === 'ShowLearnSkill') $gameSystem._showLearnSkill = true;
    if (command === 'HideLearnSkill') $gameSystem._showLearnSkill = false;
    if (command === 'EnableLearnSkill') $gameSystem._enableLearnSkill = true;
    if (command === 'DisableLearnSkill') $gameSystem._enableLearnSkill = false;
    if (command === 'OpenLearnSkill') this.openLearnSkill(args);
};

Game_Interpreter.prototype.openLearnSkill = function(args) {
    if ($gameParty.inBattle()) return;
    if (!args) return;
    if (!args[0]) return;
    if (args[0].toLowerCase() === 'actor') {
      var actorId = parseInt(args[1]);
      var actor = $gameActors.actor(actorId)
    } else if (args[0].toLowerCase() === 'party') {
      var index = parseInt(args[1]) - 1;
      index = index.clamp(0, $gameParty.members().length - 1);
      var actor = $gameParty.members()[index];
    } else {
      return;
    }
    ImageManager.loadFace(actor.faceName());
    this.loadPartyFaces();
    $gameParty.setMenuActor(actor);
    SceneManager.push(Scene_LearnSkill);
};

Game_Interpreter.prototype.loadPartyFaces = function() {
    for (var i = 0; i < $gameParty.members().length; ++i) {
      var actor = $gameParty.members()[i];
      if (actor) ImageManager.loadFace(actor.faceName());
    }
};

//=============================================================================
// Window_SkillType
//=============================================================================

Yanfly.SLS.Window_SkillType_makeCommandList =
    Window_SkillType.prototype.makeCommandList;
Window_SkillType.prototype.makeCommandList = function() {
    Yanfly.SLS.Window_SkillType_makeCommandList.call(this);
    if (this.findExt('learnSkills') === -1) this.addLearnSkillsCommand();
};

Window_SkillType.prototype.addLearnSkillsCommand = function() {
    if (!$gameSystem.isShowLearnSkill()) return;
    var name = Yanfly.Param.SLSCommand;
    var enabled = $gameSystem.isEnableLearnSkill();
    this.addCommand(name, 'skill', enabled, 'learnSkills');
};

Window_SkillType.prototype.setClassListWindow = function(classWindow) {
    this._classListWindow = classWindow;
};

Window_SkillType.prototype.setSkillLearnWindow = function(learnWindow) {
    this._skillLearnWindow = learnWindow;
};

Window_SkillType.prototype.setGoldWindow = function(goldWindow) {
    this._goldWindow = goldWindow;
};

Window_SkillType.prototype.setSkillLearnDataWindow = function(learnDataWindow) {
    this._skillLearnDataWindow = learnDataWindow;
    this.update();
};

Yanfly.SLS.Window_SkillType_update = Window_SkillType.prototype.update;
Window_SkillType.prototype.update = function() {
    if (this.currentExt() === 'learnSkills' && this._actor) {
      Window_Command.prototype.update.call(this);
      if (this.isSkillLearnIntegrated()) {
        this._classListWindow.show();
      } else if (this._skillLearnWindow) {
        this._skillLearnWindow.show();
      }
      this._skillWindow.hide();
      if (this._goldWindow) this._goldWindow.show();
      this._skillLearnDataWindow.show();
    } else {
      Yanfly.SLS.Window_SkillType_update.call(this);
      this._skillWindow.show();
      if (this._classListWindow) this._classListWindow.hide();
      if (this._skillLearnWindow) this._skillLearnWindow.hide();
      if (this._goldWindow) this._goldWindow.hide();
      if (this._skillLearnDataWindow) this._skillLearnDataWindow.hide();
    }
};

Window_SkillType.prototype.isSkillLearnIntegrated = function() {
    if (!this._classListWindow) return false;
    if (this._actor.availableClasses() <= 1) return false;
    return Yanfly.Param.SLSIntegrate;
};

//=============================================================================
// Window_SkillLearn
//=============================================================================

function Window_SkillLearn() {
    this.initialize.apply(this, arguments);
}

Window_SkillLearn.prototype = Object.create(Window_SkillList.prototype);
Window_SkillLearn.prototype.constructor = Window_SkillLearn;

Window_SkillLearn.prototype.maxCols = function() {
    return 1;
};

Window_SkillLearn.prototype.setActor = function(actor) {
    if (this._actor === actor) return;
    this.contents.clear();
    this.setClass(null);
    this._actor = actor;
    this.refresh();
    this.resetScroll();
    this.setClass(this._actor.currentClass().id);
};

Window_SkillLearn.prototype.setClass = function(classId) {
    if (this._classId === classId) return;
    this._classId = classId;
    this.makeItemList();
    this.refresh();
};

Window_SkillLearn.prototype.getClass = function() {
    return $dataClasses[this._classId];
};

Window_SkillLearn.prototype.makeItemList = function() {
    if (this._actor && this.getClass()) {
      this.createSkillLearnData();
    } else {
      this._data = [];
    }
};

Window_SkillLearn.prototype.createSkillLearnData = function() {
    this._data = [];
    for (var i = 0; i < this.getClass().learnSkills.length; ++i) {
      var skillId = this.getClass().learnSkills[i];
      var skill = $dataSkills[skillId];
      if (skill && this.includes(skill)) this._data.push(skill);
    }
    this._data = this._data.sort(function(a, b) { return a.id - b.id; });
    this._data = this._data.filter(Yanfly.Util.onlyUnique);
};

Window_SkillLearn.prototype.includes = function(skill) {
    if (skill.name === '') return false;
    if (!this.meetsRequirements(skill)) return false;
    return true;
};

Window_SkillLearn.prototype.meetsRequirements = function(skill) {
    var evalValue = this.getEvalLine(skill.learnShowEval);
    if (evalValue !== undefined) return evalValue;
    if (Imported.YEP_ClassChangeCore) {
      var classLevel = this._actor.classLevel(this._classId);
      if (skill.learnRequireLevel > classLevel) return false;
    } else {
      if (skill.learnRequireLevel > this._actor.level) return false;
    }
    for (var i = 0; i < skill.learnRequireSkill.length; ++i) {
      var skillId = skill.learnRequireSkill[i];
      if (!$dataSkills[skillId]) continue;
      if (!this._actor.isLearnedSkillRaw(skillId)) return false;
    }
    for (var i = 0; i < skill.learnRequireSwitch.length; ++i) {
      var switchId = skill.learnRequireSwitch[i];
      if (!$gameSwitches.value(switchId)) return false;
    }
    return true;
};

Window_SkillLearn.prototype.isEnabled = function(item) {
    if (!this._actor) return false;
    if (!item) return false;
    if (this._actor.isLearnedSkillRaw(item.id)) return false;
    if ($gamePlayer.isDebugThrough()) return true;
    if (!this._actor.canLearnSkill(item, this._classId)) return false;
    if (!this.meetsRequirements(item)) return false;
    var evalValue = this.getEvalLine(item.learnRequireEval);
    if (evalValue !== undefined) return evalValue;
    return true;
};

Window_SkillLearn.prototype.getEvalLine = function(evalLine) {
    if (evalLine.length <= 0) return undefined;
    var value = undefined;
    var a = this._actor;
    var user = this._actor;
    var subject = this._actor;
    var s = $gameSwitches._data;
    var v = $gameVariables._data;
    var code = evalLine;
    try {
      eval(code);
    } catch (e) {
      Yanfly.Util.displayError(e, code, 'SKILL LEARN EVAL LINE ERROR');
    }
    return value;
};

Window_SkillLearn.prototype.drawItem = function(index) {
    var skill = this._data[index];
    if (!skill) return;
    var rect = this.itemRect(index);
    rect.width -= this.textPadding();
    this.changePaintOpacity(this.isEnabled(skill));
    this.drawItemName(skill, rect.x, rect.y, rect.width);
    this.drawItemLearned(skill, rect.x, rect.y, rect.width);
    this.changePaintOpacity(true);
};

Window_SkillLearn.prototype.drawItemLearned = function(skill, wx, wy, ww) {
    if (!this._actor.isLearnedSkillRaw(skill.id)) {
      this.drawSkillCost(skill, wx, wy, ww);
      return;
    }
    var text = Yanfly.Param.SLSLearnText;
    this.contents.fontSize = Yanfly.Param.SLSLearnSize;
    this.drawText(text, wx, wy, ww, 'right');
    this.resetFontSettings();
};

Window_SkillLearn.prototype.setDataWindow = function(learnDataWindow) {
    this._skillLearnDataWindow = learnDataWindow;
    this.update();
};

Window_SkillLearn.prototype.update = function() {
    Window_SkillList.prototype.update.call(this);
    if (this._skillLearnDataWindow && this.item()) {
      this._skillLearnDataWindow.setSkill(this.item());
      if (this._classId) this._skillLearnDataWindow.setClass(this._classId);
    }
};

//=============================================================================
// Window_SkillLearnClass
//=============================================================================

if (Imported.YEP_ClassChangeCore) {

function Window_SkillLearnClass() {
    this.initialize.apply(this, arguments);
}

Window_SkillLearnClass.prototype = Object.create(Window_ClassList.prototype);
Window_SkillLearnClass.prototype.constructor = Window_SkillLearnClass;

Window_SkillLearnClass.prototype.initialize = function(x, y, width, height) {
    Window_ClassList.prototype.initialize.call(this, x, y, width, height);
    this._skill = null;
};

Window_SkillLearnClass.prototype.setSkill = function(skill) {
    if (this._skill === skill) return;
    this._skill = skill;
    this.refresh();
    this.resetScroll();
};

Window_SkillLearnClass.prototype.makeItemList = function() {
    if (this._actor && this._skill) {
      this._data = [];
      for (var i = 0; i < this._actor.unlockedClasses().length; ++i) {
        var classId = this._actor.unlockedClasses()[i];
        var item = $dataClasses[classId];
        if (!item) continue;
        if (item.learnSkills.contains(this._skill.id)) {
          this._data.push(classId);
        }
      }
    } else {
      this._data = [];
    }
    this._data.sort(function(a, b) { return a - b });
};

Window_SkillLearnClass.prototype.isEnabled = function(classId) {
    if (!this._skill) return false;
    var item = $dataClasses[classId];
    if (!item) return false;
    if (Imported.YEP_JobPoints) {
      var jpCost = this._skill.learnCostJp;
      jpCost += this._actor.customLearnSkillJpCost(this._skill);
      if (jpCost > this._actor.jp(item.id)) return false;
    }
    return Window_ClassList.prototype.isEnabled.call(this, classId);
};

Window_SkillLearnClass.prototype.drawClassLevel = function(item, wx, wy, ww) {
    if (!Imported.YEP_JobPoints) return;
    var value = Yanfly.Util.toGroup(this._actor.jp(item.id));
    var icon = '\\i[' + Yanfly.Icon.Jp + ']';
    var fmt = Yanfly.Param.JpMenuFormat;
    var text = fmt.format(value, Yanfly.Param.Jp, icon);
    this.resetFontSettings();
    this.changeTextColor(this.normalColor());
    this.contents.fontSize = Yanfly.Param.CCCLvFontSize;
    wx += ww - this.textWidthEx(text);
    this.drawTextEx(text, wx, wy);
};

Window_SkillLearnClass.prototype.selectLast = function() {
    this._index = this._data.indexOf(this._actor._classId);
    if (this._index < 0) this._index = 0;
    this.select(this._index);
};

} // Imported.YEP_ClassChangeCore

//=============================================================================
// Window_SkillLearnData
//=============================================================================

function Window_SkillLearnData() {
    this.initialize.apply(this, arguments);
}

Window_SkillLearnData.prototype = Object.create(Window_Base.prototype);
Window_SkillLearnData.prototype.constructor = Window_SkillLearnData;

Window_SkillLearnData.prototype.initialize = function(wx, wy, ww, wh) {
    Window_Base.prototype.initialize.call(this, wx, wy, ww, wh);
    this._actor = null;
    this._classId = null;
    this._skill = null;
    this.refresh();
};

Window_SkillLearnData.prototype.setActor = function(actor) {
    if (this._actor === actor) return;
    this.setClass(null);
    this.setSkill(null);
    this.contents.clear();
    this._actor = actor;
    this.refresh();
};

Window_SkillLearnData.prototype.setClass = function(classId) {
    if (this._classId === classId) return;
    this._classId = classId;
    this.refresh();
};

Window_SkillLearnData.prototype.setSkill = function(skill) {
    if (this._skill === skill) return;
    this._skill = skill;
    this.refresh();
};

Window_SkillLearnData.prototype.refresh = function() {
    this.contents.clear();
    this.resetFontSettings();
    this.resetTextColor();
    this.drawDarkRectangles();
    if (!this._skill) return;
    this.drawSkillData();
};

Window_SkillLearnData.prototype.drawDarkRectangles = function(dx, dy, dw, dh) {
    var wx = 0;
    var wy = 0;
    var ww = this.contents.width;
    var wh = this.lineHeight();
    for (;;) {
      if (wy + wh > this.contents.height) break;
      this.drawDarkRect(wx, wy, ww, wh);
      wy += this.lineHeight();
    }
};

Window_SkillLearnData.prototype.drawDarkRect = function(dx, dy, dw, dh) {
    var color = this.gaugeBackColor();
    this.changePaintOpacity(false);
    this.contents.fillRect(dx + 1, dy + 1, dw - 2, dh - 2, color);
    this.changePaintOpacity(true);
};

Window_SkillLearnData.prototype.drawSkillData = function() {
    this.drawItemName(this._skill, 0, 0, this.contents.width);
    var wy = this.lineHeight();
    wy = this.drawRequirements(wy);
    wy = this.drawCostText(wy);
    wy = this.drawGoldCosts(wy);
    wy = this.drawJpCosts(wy);
    wy = this.drawOtherCosts(wy);
    wy = this.drawCustomText(wy);
    return wy;
};

Window_SkillLearnData.prototype.drawRequirements = function(wy) {
    return wy;
};

Window_SkillLearnData.prototype.drawCostText = function(wy) {
    if (!this.hasLearnCost()) return wy;
    var text = Yanfly.Param.SLSLearnCost;
    this.changeTextColor(this.systemColor());
    this.drawText(text, 0, wy, this.contents.width, 'center');
    wy += this.lineHeight();
    return wy;
};

Window_SkillLearnData.prototype.hasLearnCost = function() {
    if (this._skill.learnCostGold > 0) return true;
    if (Imported.YEP_JobPoints) {
      var cost = this._skill.learnCostJp;
      cost += this._actor.customLearnSkillJpCost(this._skill);
      return cost > 0;
    } 
    if (this._skill.learnCost.length > 0) return true;
    return false;
};

Window_SkillLearnData.prototype.drawGoldCosts = function(wy) {
    if (this._skill.learnCostGold <= 0) return wy;
    var text = '';
    if (Imported.YEP_CoreEngine && Yanfly.Icon.Gold > 0) {
      text = '\\i[' + Yanfly.Icon.Gold + ']';
    }
    text += TextManager.currencyUnit;
    var wx = this.drawTextEx(text, 0, wy);
    var ww = this.contents.width - wx - 4;
    var costText = Yanfly.Util.toGroup(this._skill.learnCostGold);
    this.contents.fontSize = Yanfly.Param.SLSCostSize;
    if (this._skill.learnCostGold > $gameParty.gold()) {
      this.changeTextColor(this.powerDownColor());
    } else {
      this.changeTextColor(this.powerUpColor());
    }
    this.drawText(costText, wx, wy, ww, 'right');
    this.resetFontSettings();
    this.resetTextColor();
    wy += this.lineHeight();
    return wy;
};

Window_SkillLearnData.prototype.drawJpCosts = function(wy) {
    if (!Imported.YEP_JobPoints) return wy;
    var cost = this._skill.learnCostJp;
    cost += this._actor.customLearnSkillJpCost(this._skill);
    if (cost <= 0) return wy;
    var text = '';
    if (Yanfly.Icon.Jp > 0) text = '\\i[' + Yanfly.Icon.Jp + ']';
    text += Yanfly.Param.Jp;
    var wx = this.drawTextEx(text, 0, wy);
    var ww = this.contents.width - wx - 4;
    var costText = Yanfly.Util.toGroup(cost);
    this.contents.fontSize = Yanfly.Param.SLSCostSize;
    if (this._actor.sufficientJpLearnSkill(this._skill, this._classId)) {
      this.changeTextColor(this.powerUpColor());
    } else {
      this.changeTextColor(this.powerDownColor());
    }
    this.drawText(costText, wx, wy, ww, 'right');
    this.resetFontSettings();
    this.resetTextColor();
    wy += this.lineHeight();
    return wy;
};

Window_SkillLearnData.prototype.drawOtherCosts = function(wy) {
    if (this._skill.learnCost.length <= 0) return wy;
    for (var i = 0; i < this._skill.learnCost.length; ++i) {
      if (wy + this.lineHeight() > this.contents.height) break;
      this.resetFontSettings();
      this.resetTextColor();
      var ww = this.contents.width;
      var line = this._skill.learnCost[i];
      var obj = null;
      var value = 0;
      if (line.match(/ITEM[ ](\d+):[ ](\d+)/i)) {
        obj = $dataItems[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      } else if (line.match(/WEAPON[ ](\d+):[ ](\d+)/i)) {
        obj = $dataWeapons[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      } else if (line.match(/ARMOR[ ](\d+):[ ](\d+)/i)) {
        obj = $dataArmors[parseInt(RegExp.$1)];
        value = parseInt(RegExp.$2);
      }
      if (!obj) continue;
      this.drawItemName(obj, 0, wy, ww);
      this.contents.fontSize = Yanfly.Param.SLSCostSize;
      var text = '/' + Yanfly.Util.toGroup(value);
      this.drawText(text, 0, wy, ww - 4, 'right');
      if ($gameParty.numItems(obj) >= value) {
        this.changeTextColor(this.powerUpColor());
      } else {
        this.changeTextColor(this.powerDownColor());
      }
      ww -= this.textWidth(text);
      var held = Yanfly.Util.toGroup($gameParty.numItems(obj))
      this.drawText(held, 0, wy, ww - 4, 'right');
      this.resetFontSettings();
      this.resetTextColor();
      wy += this.lineHeight();
    }
    return wy;
};

Window_SkillLearnData.prototype.drawCustomText = function(wy) {
    if (this._skill.learnCustomText === '') return wy;
    this.drawTextEx(this._skill.learnCustomText, 4, wy);
    return wy;
};

//=============================================================================
// Window_SkillLearnCommand
//=============================================================================

function Window_SkillLearnCommand() {
    this.initialize.apply(this, arguments);
}

Window_SkillLearnCommand.prototype = Object.create(Window_Command.prototype);
Window_SkillLearnCommand.prototype.constructor = Window_SkillType;

Window_SkillLearnCommand.prototype.initialize = function(x, y) {
    Window_Command.prototype.initialize.call(this, x, y);
    this._actor = null;
};

Window_SkillLearnCommand.prototype.windowWidth = function() {
    return 240;
};

Window_SkillLearnCommand.prototype.numVisibleRows = function() {
    return 4;
};

Window_SkillLearnCommand.prototype.itemTextAlign = function() {
    if (Imported.YEP_SkillCore) return Yanfly.Param.SCCTextAlign;
    return Window_Command.prototype.itemTextAlign.call(this);
};

Window_SkillLearnCommand.prototype.setActor = function(actor) {
    if (this._actor === actor) return;
    this.contents.clear();
    this._actor = actor;
    this.refresh();
};

Window_SkillLearnCommand.prototype.setStatusWindow = function(w) {
    this._statusWindow = w;
};

Window_SkillLearnCommand.prototype.setSkillLearnWindow = function(w) {
    this._skillLearnWindow = w;
};

Window_SkillLearnCommand.prototype.setSkillLearnDataWindow = function(w) {
    this._skillLearnDataWindow = w;
    this.update();
};

Window_SkillLearnCommand.prototype.makeCommandList = function() {
    if (!this._actor) return;
    this.addClassCommand(this._actor.currentClass().id);
    this._currentClass = this._actor.currentClass().id;
    if (!Imported.YEP_ClassChangeCore) return;
    for (var i = 0; i < this._actor.unlockedClasses().length; ++i) {
      classId = this._actor.unlockedClasses()[i];
      if (classId === this._actor.currentClass().id) continue;
      if ($dataClasses[classId]) this.addClassCommand(classId);
    }
};

Window_SkillLearnCommand.prototype.addClassCommand = function(classId) {
    var actorClass = $dataClasses[classId];
    if (!actorClass) return;
    var name = actorClass.name;
    if (actorClass.useNickname) {
      name = this._actor.nickname();
    }
    this.addCommand(name, 'class', true, classId);
};

Window_SkillLearnCommand.prototype.update = function() {
    Window_Command.prototype.update.call(this);
    if (this._helpWindow && this.active) {
      var classId = this.currentExt();
      this._helpWindow.setItem($dataClasses[classId]);
    }
    if (this._skillLearnWindow) {
      var classId = this.currentExt();
      this._skillLearnWindow.setClass(classId);
    }
    if (this._statusWindow && this._currentClassIndex !== this.index()) {
      this._currentClassIndex = this.index();
      var actor = JsonEx.makeDeepCopy(this._actor);
      if (!actor) return;
      var classId = this.currentExt();
      this._currentClass = this.currentExt();
      var hpRate = actor.hp / actor.mhp;
      var mpRate = actor.mp / Math.max(1, actor.mmp);
      Yanfly.SLS.PreventReleaseItem = true;
      if (Imported.YEP_ClassChangeCore) {
        actor.changeClass(classId, Yanfly.Param.CCCMaintainLv);
      } else {
        actor.changeClass(classId, false);
      }
      var max = actor.isDead() ? 0 : 1;
      var hpAmount = Math.max(max, parseInt(actor.mhp * hpRate));
      actor.setHp(hpAmount);
      actor.setMp(parseInt(actor.mmp * mpRate));
      this._statusWindow.setActor(actor);
      Yanfly.SLS.PreventReleaseItem = false;
    }
};

Yanfly.SLS.Window_Command_drawItem = Window_Command.prototype.drawItem;
Window_SkillLearnCommand.prototype.drawItem = function(index) {
    if (Imported.YEP_ClassChangeCore) {
      this.drawItemEx(index);
    } else {
      Yanfly.SLS.Window_Command_drawItem.call(this, index);
    }
};

Window_SkillLearnCommand.prototype.drawItemEx = function(index) {
    var rect = this.itemRectForText(index);
    var align = this.itemTextAlign();
    this.resetTextColor();
    this.changePaintOpacity(this.isCommandEnabled(index));
    var classId = this._list[index].ext;
    this.drawIcon($dataClasses[classId].iconIndex, rect.x, rect.y);
    rect.x += Window_Base._iconWidth + 4;
    rect.width -= Window_Base._iconWidth + 4;
    this.drawText(this.commandName(index), rect.x, rect.y, rect.width);
};

//=============================================================================
// Window_SkillLearnConfirm
//=============================================================================

function Window_SkillLearnConfirm() {
    this.initialize.apply(this, arguments);
}

Window_SkillLearnConfirm.prototype = Object.create(Window_Command.prototype);
Window_SkillLearnConfirm.prototype.constructor = Window_SkillLearnConfirm;

Window_SkillLearnConfirm.prototype.initialize = function() {
    Window_Command.prototype.initialize.call(this, 0, 0);
    this.openness = 0;
};

Window_SkillLearnConfirm.prototype.makeCommandList = function() {
    this.addCommand(Yanfly.Param.SLSConfirmYes, 'confirm');
    this.addCommand(Yanfly.Param.SLSConfirmNo, 'cancel');
};

Window_SkillLearnConfirm.prototype.setData = function(actor, skill) {
    var fmt = Yanfly.Param.SLSConfirmText;
    this._text = fmt.format(actor.name(), skill.name);
    var ww = this.textWidthEx(this._text) + this.standardPadding() * 4;
    this.width = ww;
    this.refresh();
    this.x = (Graphics.boxWidth - this.width) / 2;
    this.y = (Graphics.boxHeight - this.height) / 2;
    this.drawTextEx(this._text, this.textPadding(), 0);
};

Window_SkillLearnConfirm.prototype.textWidthEx = function(text) {
    return this.drawTextEx(text, 0, this.contents.height);
};

Window_SkillLearnConfirm.prototype.itemTextAlign = function() {
    return 'center';
};

Window_SkillLearnConfirm.prototype.windowHeight = function() {
    return this.fittingHeight(3);
};

Window_SkillLearnConfirm.prototype.itemRect = function(index) {
    var rect = Window_Selectable.prototype.itemRect.call(this, index);
    rect.y += this.lineHeight();
    return rect;
};

//=============================================================================
// Scene_Skill
//=============================================================================

Yanfly.SLS.Scene_Skill_create = Scene_Skill.prototype.create;
Scene_Skill.prototype.create = function() {
    Yanfly.SLS.Scene_Skill_create.call(this);
    this.createClassListWindow();
    this.createSkillLearnWindow();
    this.createGoldWindow();
    this.createSkillLearnClassWindow();
    this.createSkillLearnDataWindow();
};

Yanfly.SLS.Scene_Skill_refreshActor = Scene_Skill.prototype.refreshActor;
Scene_Skill.prototype.refreshActor = function() {
  Yanfly.SLS.Scene_Skill_refreshActor.call(this);
  var actor = this.actor();
  if (this._classListWindow) this._classListWindow.setActor(actor);
  if (this._skillLearnWindow) this._skillLearnWindow.setActor(actor);
  if (this._skillLearnClassWindow) this._skillLearnClassWindow.setActor(actor);
  if (this._skillLearnDataWindow) this._skillLearnDataWindow.setActor(actor);
};

Scene_Skill.prototype.createClassListWindow = function() {
    if (!Imported.YEP_ClassChangeCore) return;
    if (this._classListWindow) return;
    var wx = 0;
    var wy = this._statusWindow.y + this._statusWindow.height;
    var ww = Graphics.boxWidth / 2;
    var wh = Graphics.boxHeight - wy;
    this._classListWindow = new Window_ClassList(wx, wy, ww, wh);
    this._classListWindow.setHelpWindow(this._helpWindow);
    this._classListWindow.setHandler('ok', this.onClassOk.bind(this));
    this._classListWindow.setHandler('cancel', this.onClassCancel.bind(this));
    this._skillTypeWindow.setClassListWindow(this._classListWindow);
    this._classListWindow.hide();
    this._classListWindow.setActor(this.actor());
    this.addWindow(this._classListWindow);
};

Scene_Skill.prototype.createSkillLearnWindow = function() {
    var wx = 0;
    var wy = this._statusWindow.y + this._statusWindow.height;
    var ww = Graphics.boxWidth / 2;
    var wh = Graphics.boxHeight - wy;
    this._skillLearnWindow = new Window_SkillLearn(wx, wy, ww, wh);
    this._skillLearnWindow.setHelpWindow(this._helpWindow);
    this._skillLearnWindow.setHandler('ok', this.onLearnOk.bind(this));
    this._skillLearnWindow.setHandler('cancel', this.onLearnCancel.bind(this));
    this._skillTypeWindow.setSkillLearnWindow(this._skillLearnWindow);
    this._skillLearnWindow.hide();
    this._skillLearnWindow.setActor(this.actor());
    this._skillLearnWindow.setClass(this.actor().currentClass().id);
    this.addWindow(this._skillLearnWindow);
};

Scene_Skill.prototype.createGoldWindow = function() {
    if (!Yanfly.Param.SLSGoldWindow) return;
    var wx = Graphics.boxWidth / 2;
    this._goldWindow = new Window_Gold(wx, 0);
    this._goldWindow.width = Graphics.boxWidth / 2;
    this._goldWindow.y = Graphics.boxHeight - this._goldWindow.height;
    this._skillTypeWindow.setGoldWindow(this._goldWindow);
    this._goldWindow.hide();
    this._goldWindow.createContents();
    this._goldWindow.refresh();
    this.addWindow(this._goldWindow);
};

Scene_Skill.prototype.createSkillLearnClassWindow = function() {
    if (!Imported.YEP_ClassChangeCore) return;
    if (this._skillLearnClassWindow) return;
    var wx = 0;
    var wy = this._statusWindow.y + this._statusWindow.height;
    var ww = Graphics.boxWidth / 2;
    var wh = Graphics.boxHeight - wy;
    this._skillLearnClassWindow = new Window_SkillLearnClass(wx, wy, ww, wh);
    this._skillLearnClassWindow.setHelpWindow(this._helpWindow);
    this._skillLearnClassWindow.setHandler('ok',
      this.onSLCOk.bind(this));
    this._skillLearnClassWindow.setHandler('cancel',
      this.onSLCCancel.bind(this));
    this._skillLearnClassWindow.hide();
    this._skillLearnClassWindow.setActor(this.actor());
    this.addWindow(this._skillLearnClassWindow);
};

Scene_Skill.prototype.createSkillLearnDataWindow = function() {
    var wx = Graphics.boxWidth / 2;
    var wy = this._statusWindow.y + this._statusWindow.height;
    var ww = Graphics.boxWidth / 2;
    var wh = Graphics.boxHeight - wy;
    if (this._goldWindow) wh -= this._goldWindow.height;
    this._skillLearnDataWindow = new Window_SkillLearnData(wx, wy, ww, wh);
    this._skillTypeWindow.setSkillLearnDataWindow(this._skillLearnDataWindow);
    this._skillLearnWindow.setDataWindow(this._skillLearnDataWindow);
    this._skillLearnDataWindow.setActor(this.actor());
    this._skillLearnDataWindow.hide();
    this.addWindow(this._skillLearnDataWindow);
};

Yanfly.SLS.Scene_Skill_commandSkill = Scene_Skill.prototype.commandSkill;
Scene_Skill.prototype.commandSkill = function() {
    if (this._skillTypeWindow.currentExt() === 'learnSkills') {
      this.commandLearnSkill();
    } else {
      Yanfly.SLS.Scene_Skill_commandSkill.call(this);
    }
};

Scene_Skill.prototype.commandLearnSkill = function() {
    if (!eval(Yanfly.Param.SLSIntegrate)) {
      SceneManager.push(Scene_LearnSkill);
    } else if (this._classListWindow && this.actor().availableClasses() > 1) {
      this._classListWindow.activate();
      this._classListWindow.selectLast();
    } else if (this._skillLearnWindow) {
      this._skillLearnWindow.activate();
      this._skillLearnWindow.selectLast();
    }
};

Scene_Skill.prototype.onClassOk = function() {
    var item = this._classListWindow.item();
    this._skillLearnWindow.setClass(item);
    this._classListWindow.hide();
    this._skillLearnWindow.show();
    this._skillLearnWindow.activate();
    this._skillLearnWindow.selectLast();
};

Scene_Skill.prototype.onClassCancel = function() {
    this._classListWindow.deselect();
    this._skillTypeWindow.activate();
    this._helpWindow.setItem(null);
};

Scene_Skill.prototype.onLearnOk = function() {
    var skill = this._skillLearnWindow.item();
    if (this.actor().availableClasses() === 1) {
      var classId = this.actor().currentClass().id;
      this.processLearnSkill(skill, classId);
    } else if (this._skillLearnClassWindow) {
      this._skillLearnWindow.hide();
      this._skillLearnClassWindow.show();
      this._skillLearnClassWindow.setSkill(skill);
      this._skillLearnClassWindow.activate();
      this._skillLearnClassWindow.selectLast();
    }
};

Scene_Skill.prototype.processLearnSkill = function(skill, classId) {
  this._skillLearnWindow.activate();
  this.actor().learnSkill(skill.id);
  SoundManager.playUseSkill();
  $gameParty.loseGold(skill.learnCostGold);
  $gameParty.processLearnSkillCost(skill);
  if (Imported.YEP_JobPoints) {
    var cost = skill.learnCostJp;
    cost += this.actor().customLearnSkillJpCost(skill);
    this.actor().loseJp(cost, classId);
  }
  this.processLearnCostEval(skill, classId);
  this.actor().refresh();
  this._skillLearnWindow.refresh();
  this._skillLearnWindow.updateHelp();
  this._statusWindow.refresh();
  if (this._goldWindow) this._goldWindow.refresh();
  if (this._classListWindow) this._classListWindow.refresh();
  this._skillLearnDataWindow.refresh();
  this._skillTypeWindow.refresh();
};

Scene_Skill.prototype.processLearnCostEval = function(skill, classId) {
  if (skill.learnCostEval === '') return;
  var a = this.actor();
  var user = this.actor();
  var subject = this.actor();
  var s = $gameSwitches._data;
  var v = $gameVariables._data;
  var code = skill.learnCostEval;
  try {
    eval(code);
  } catch (e) {
    Yanfly.Util.displayError(e, code, 'SKILL LEARN CUSTOM COST ERROR');
  }
};

Scene_Skill.prototype.onLearnCancel = function() {
    this._skillLearnWindow.deselect();
    this._skillLearnDataWindow.setSkill(null);
    if (this._classListWindow && this._actor.availableClasses() > 1) {
      this._skillLearnWindow.hide();
      this._classListWindow.show();
      this._classListWindow.activate();
      this._classListWindow.selectLast();
    } else {
      this._skillTypeWindow.activate();
      this._helpWindow.setItem(null);
    }
};

Scene_Skill.prototype.onSLCOk = function() {
    var skill = this._skillLearnWindow.item();
    var classId = this._skillLearnClassWindow.item();
    this.processLearnSkill(skill, classId);
    this.onSLCCancel();
};

Scene_Skill.prototype.onSLCCancel = function() {
    this._skillLearnClassWindow.hide();
    this._skillLearnWindow.activate();
    this._skillLearnWindow.show();
};

//=============================================================================
// Scene_LearnSkill
//=============================================================================

function Scene_LearnSkill() {
    this.initialize.apply(this, arguments);
}

Scene_LearnSkill.prototype = Object.create(Scene_ItemBase.prototype);
Scene_LearnSkill.prototype.constructor = Scene_LearnSkill;

Scene_LearnSkill.prototype.initialize = function() {
    Scene_ItemBase.prototype.initialize.call(this);
};

Scene_LearnSkill.prototype.onActorChange = function() {
    this.refreshActor();
    this.adjustSelection();
};

Scene_LearnSkill.prototype.adjustSelection = function() {
    if (Imported.YEP_ClassChangeCore) {
      this._commandWindow.activate();
    } else {
      this.commandClass();
      this._commandWindow.deactivate();
    }
};

Scene_LearnSkill.prototype.start = function() {
    Scene_ItemBase.prototype.start.call(this);

};

Scene_LearnSkill.prototype.create = function() {
    Scene_ItemBase.prototype.create.call(this);
    this.createHelpWindow();
    this.createCommandWindow();
    this.createStatusWindow();
    this.createSkillLearnWindow();
    this.createGoldWindow();
    this.createSkillLearnDataWindow();
    this.createConfirmWindow();
    this.refreshActor();
    this.adjustSelection();
};

Scene_LearnSkill.prototype.refreshActor = function() {
    var actor = this.actor();
    this._commandWindow.setActor(actor);
    this._statusWindow.setActor(actor);
    this._skillLearnWindow.setActor(actor);
    this._skillLearnDataWindow.setActor(actor);
};

Scene_LearnSkill.prototype.createCommandWindow = function() {
    var wy = this._helpWindow.height;
    this._commandWindow = new Window_SkillLearnCommand(0, wy);
    this._commandWindow.setHelpWindow(this._helpWindow);
    this._commandWindow.setHandler('class',    this.commandClass.bind(this));
    this._commandWindow.setHandler('cancel',   this.popScene.bind(this));
    this._commandWindow.setHandler('pagedown', this.nextActor.bind(this));
    this._commandWindow.setHandler('pageup',   this.previousActor.bind(this));
    this._commandWindow.setHelpWindow(this._helpWindow);
    this.addWindow(this._commandWindow);
};

Scene_LearnSkill.prototype.createStatusWindow = function() {
    var wx = this._commandWindow.width;
    var wy = this._helpWindow.height;
    var ww = Graphics.boxWidth - wx;
    var wh = this._commandWindow.height;
    this._statusWindow = new Window_SkillStatus(wx, wy, ww, wh);
    this._commandWindow.setStatusWindow(this._statusWindow);
    this.addWindow(this._statusWindow);
};

Scene_LearnSkill.prototype.createSkillLearnWindow = function() {
  var wx = 0;
  var wy = this._statusWindow.y + this._statusWindow.height;
  var ww = Graphics.boxWidth / 2;
  var wh = Graphics.boxHeight - wy;
  this._skillLearnWindow = new Window_SkillLearn(wx, wy, ww, wh);
  this._skillLearnWindow.setHelpWindow(this._helpWindow);
  this._skillLearnWindow.setHandler('ok', this.onLearnOk.bind(this));
  this._skillLearnWindow.setHandler('cancel', this.onLearnCancel.bind(this));
  if (!Imported.YEP_ClassChangeCore) {
    var win = this._skillLearnWindow
    win.setHandler('pagedown', this.onLearnPageDn.bind(this));
    win.setHandler('pageup',   this.onLearnPageUp.bind(this));
  }
  this._commandWindow.setSkillLearnWindow(this._skillLearnWindow);
  this._skillLearnWindow.setActor(this.actor());
  this._skillLearnWindow.setClass(this.actor().currentClass().id);
  this.addWindow(this._skillLearnWindow);
};

Scene_LearnSkill.prototype.createGoldWindow = function() {
    if (!eval(Yanfly.Param.SLSGoldWindow)) return;
    var wx = Graphics.boxWidth / 2;
    this._goldWindow = new Window_Gold(wx, 0);
    this._goldWindow.width = Graphics.boxWidth / 2;
    this._goldWindow.y = Graphics.boxHeight - this._goldWindow.height;
    this._goldWindow.createContents();
    this._goldWindow.refresh();
    this.addWindow(this._goldWindow);
};

Scene_LearnSkill.prototype.createSkillLearnDataWindow = function() {
    var wx = Graphics.boxWidth / 2;
    var wy = this._statusWindow.y + this._statusWindow.height;
    var ww = Graphics.boxWidth / 2;
    var wh = Graphics.boxHeight - wy;
    if (this._goldWindow) wh -= this._goldWindow.height;
    this._skillLearnDataWindow = new Window_SkillLearnData(wx, wy, ww, wh);
    this._commandWindow.setSkillLearnDataWindow(this._skillLearnDataWindow);
    this._skillLearnWindow.setDataWindow(this._skillLearnDataWindow);
    this._skillLearnDataWindow.setActor(this.actor());
    this.addWindow(this._skillLearnDataWindow);
};

Scene_LearnSkill.prototype.createConfirmWindow = function() {
    this._confirmWindow = new Window_SkillLearnConfirm();
    var win = this._confirmWindow;
    win.setHandler('confirm', this.onConfirmOk.bind(this));
    win.setHandler('cancel',  this.onConfirmCancel.bind(this));
    this.addWindow(this._confirmWindow);
};

Scene_LearnSkill.prototype.commandClass = function() {
    var item = this._commandWindow.currentExt();
    this._skillLearnWindow.setClass(item);
    this._skillLearnWindow.show();
    this._skillLearnWindow.activate();
    this._skillLearnWindow.selectLast();
};

Scene_LearnSkill.prototype.onLearnOk = function() {
    var skill = this._skillLearnWindow.item();
    var classId = this._commandWindow.currentExt();
    this.confirmLearnSkill(skill, classId);
};

Scene_LearnSkill.prototype.refreshStatus = function() {
    var actor = JsonEx.makeDeepCopy(this.actor());
    if (!actor) return;
    var classId = this._commandWindow.currentExt();
    this._commandWindow._currentClass = this._commandWindow.currentExt();
    var hpRate = actor.hp / actor.mhp;
    var mpRate = actor.mp / Math.max(1, actor.mmp);
    Yanfly.SLS.PreventReleaseItem = true;
    if (Imported.YEP_ClassChangeCore) {
      actor.changeClass(classId, Yanfly.Param.CCCMaintainLv);
    } else {
      actor.changeClass(classId, false);
    }
    var max = actor.isDead() ? 0 : 1;
    var hpAmount = Math.max(max, parseInt(actor.mhp * hpRate));
    actor.setHp(hpAmount);
    actor.setMp(parseInt(actor.mmp * mpRate));
    this._statusWindow.setActor(actor);
    Yanfly.SLS.PreventReleaseItem = false;
};

Scene_LearnSkill.prototype.processLearnSkill = function(skill, classId) {
  this._skillLearnWindow.activate();
  this.actor().learnSkill(skill.id);
  SoundManager.playUseSkill();
  $gameParty.loseGold(skill.learnCostGold);
  $gameParty.processLearnSkillCost(skill);
  if (Imported.YEP_JobPoints) {
    var cost = skill.learnCostJp;
    cost += this.actor().customLearnSkillJpCost(skill);
    this.actor().loseJp(cost, classId);
  }
  this.processLearnCostEval(skill, classId);
  this.actor().refresh();
  this._skillLearnWindow.refresh();
  this._skillLearnWindow.updateHelp();
  this.refreshStatus();
  if (this._goldWindow) this._goldWindow.refresh();
  if (this._classListWindow) this._classListWindow.refresh();
  this._skillLearnDataWindow.refresh();
  this._commandWindow.refresh();
};

Scene_LearnSkill.prototype.confirmLearnSkill = function(skill, classId) {
    if (Yanfly.Param.SLSConfirmWin) {
      this.startConfirmWindow(skill)
    } else {
      this.processLearnSkill(skill, classId);
    }
};

Scene_LearnSkill.prototype.processLearnCostEval = function(skill, classId) {
    if (skill.learnCostEval === '') return;
    var a = this.actor();
    var user = this.actor();
    var subject = this.actor();
    var s = $gameSwitches._data;
    var v = $gameVariables._data;
    var code = skill.learnCostEval;
    try {
      eval(code);
    } catch (e) {
      Yanfly.Util.displayError(e, code, 'SKILL LEARN COST ERROR');
    }
};

Scene_LearnSkill.prototype.onLearnCancel = function() {
    if (Imported.YEP_ClassChangeCore) {
      this._skillLearnWindow.deselect();
      this._skillLearnDataWindow.setSkill(null);
      this._commandWindow.activate();
      this._helpWindow.setItem(null);
    } else {
      this.popScene();
    }
};

Scene_LearnSkill.prototype.onLearnPageDn = function() {
    this.nextActor();
};

Scene_LearnSkill.prototype.onLearnPageUp = function() {
    this.previousActor();
};

Scene_LearnSkill.prototype.startConfirmWindow = function(skill) {
    this._confirmWindow.setData(this._actor, skill);
    this._confirmWindow.open();
    this._confirmWindow.activate();
    this._confirmWindow.select(0);
};

Scene_LearnSkill.prototype.onConfirmOk = function() {
    var skill = this._skillLearnWindow.item();
    var classId = this._commandWindow.currentExt();
    this.processLearnSkill(skill, classId);
    this._confirmWindow.close();
};

Scene_LearnSkill.prototype.onConfirmCancel = function() {
    this._confirmWindow.deactivate();
    this._confirmWindow.close();
    this._skillLearnWindow.activate();
};

//=============================================================================
// Utilities
//=============================================================================

Yanfly.Util = Yanfly.Util || {};

if (!Yanfly.Util.toGroup) {
    Yanfly.Util.toGroup = function(inVal) {
        return inVal;
    }
};

Yanfly.Util.getRange = function(n, m) {
    var result = [];
    for (var i = n; i <= m; ++i) result.push(i);
    return result;
};

Yanfly.Util.onlyUnique = function(value, index, self) {
    return self.indexOf(value) === index;
};

Yanfly.Util.displayError = function(e, code, message) {
  console.log(message);
  console.log(code || 'NON-EXISTENT');
  console.error(e);
  if (Utils.isNwjs() && Utils.isOptionValid('test')) {
    if (!require('nw.gui').Window.get().isDevToolsOpen()) {
      require('nw.gui').Window.get().showDevTools();
    }
  }
};

//=============================================================================
// End of File
//=============================================================================