Project1

标题: 求问大佬们有没有这个插件? [打印本页]

作者: 多卡多卡    时间: 2019-3-3 16:42
标题: 求问大佬们有没有这个插件?
本帖最后由 多卡多卡 于 2019-3-3 16:43 编辑

那是一个可以通过战斗获得熟练度,从而自动习得技能的插件,和FF9差不多。名字是dsEquipmentSkillLearning.js,网站是http://gametkool.com/?p=1881,但里面的下载链接已经不能用了(可能需要科技?),所以请问大佬们能不能找到这个插件?
作者: soulsaga    时间: 2019-3-3 16:54
JAVASCRIPT 代码复制
  1. //==============================================================================
  2. // dsEquipmentSkillLearning.js
  3. // Copyright (c) 2015 - 2018 DOURAKU
  4. // Released under the MIT License.
  5. // [url]http://opensource.org/licenses/mit-license.php[/url]
  6. //==============================================================================
  7.  
  8. /*:
  9.  * @plugindesc 装備に設定されたスキルを習得するプラグイン ver1.12.2
  10.  * @author 道楽
  11.  *
  12.  * @param Lp
  13.  * @desc 装備からスキルを習得する蓄積値の略称(Learning Point)
  14.  * @default LP
  15.  *
  16.  * @param Basic Reward Lp
  17.  * @type number
  18.  * @desc タグ未設定時の敵キャラから獲得できる基本LP
  19.  * @default 1
  20.  *
  21.  * @param Reward Lp Text
  22.  * @desc 戦闘後にLPを獲得した時に表示されるテキスト
  23.  * @default %1 の%2を獲得!
  24.  *
  25.  * @param Show Reward Lp Text
  26.  * @type boolean
  27.  * @desc 戦闘後にLPを獲得したテキストを表示するか
  28.  * (true なら表示する / false なら表示しない)
  29.  * @default true
  30.  *
  31.  * @param Learning Skill Text
  32.  * @desc 戦闘で得たLPによってスキルを習得した時に表示されるテキスト
  33.  * @default %1は%2を覚えた!
  34.  *
  35.  * @param Usable Equipment Skill
  36.  * @type boolean
  37.  * @desc 装備品が持つ未修得のスキルを使用できるか
  38.  * (true なら使用できる / false なら使用できない)
  39.  * @default true
  40.  *
  41.  * @param Show Lp Gauge
  42.  * @type boolean
  43.  * @desc LPをゲージで表示するか?
  44.  * (true なら表示する / false なら表示しない)
  45.  * @default true
  46.  *
  47.  * @param Show Lp Value
  48.  * @type boolean
  49.  * @desc LPを数値で表示するか?
  50.  * (true なら表示する / false なら表示しない)
  51.  * @default false
  52.  *
  53.  * @param Show Control Guide
  54.  * @type boolean
  55.  * @desc 表示切替ガイドを表示するか?
  56.  * (true なら表示する / false なら表示しない)
  57.  * @default true
  58.  *
  59.  * @param Guide Text
  60.  * @type string
  61.  * @desc 表示切替ガイドのテキスト
  62.  * @default Shift:切り替え
  63.  *
  64.  * @param Lp Value Font Size
  65.  * @type number
  66.  * @desc LP表示で使用するフォントのサイズ
  67.  * @default 18
  68.  *
  69.  * @param Lp Aftermath Enable
  70.  * @type boolean
  71.  * @desc YEP_VictoryAftermathにLP獲得ウィンドウを追加するか?
  72.  * (true なら追加する / false なら追加しない)
  73.  * @default true
  74.  *
  75.  * @param Lp Aftermath Caption
  76.  * @desc LP獲得ウィンドウに表示される題字テキスト
  77.  * @default LP獲得
  78.  *
  79.  * @param Lp Aftermath Format
  80.  * @desc 獲得したLP値を表示する書式テキスト
  81.  * %1 - Value     %2 - Amount
  82.  * @default +%1\c[4]%2\c[0]
  83.  *
  84.  * @param Lp Aftermath Earned
  85.  * @desc LP獲得ウィンドウの題字
  86.  * @default 獲得LP
  87.  *
  88.  * @param Lp Multiple Gain Enable
  89.  * @type boolean
  90.  * @desc 獲得したLP値を同一スキルが設定された装備の数分加算するか?
  91.  * (true なら加算する / false なら加算しない)
  92.  * @default false
  93.  *
  94.  * @help
  95.  * このプラグインは以下のメモタグの設定ができます。
  96.  *
  97.  * -----------------------------------------------------------------------------
  98.  * スキルに設定するメモタグ
  99.  *
  100.  * <lp:[必要LP]>
  101.  *  スキルを習得するために必要なLPを設定します。
  102.  *  [必要LP] - スキルの習得に必要なLP(数字)
  103.  *
  104.  * <lpActor[アクター番号]:[必要LP]>
  105.  *  特定のアクターがスキルを習得するために必要なLPを設定します。
  106.  *  <lp>と同時に設定されている場合は指定のアクターのみこちらが優先されます。
  107.  *  [アクター番号] - 0001~9999までの4桁の数値が設定できます。(数字)
  108.  *                   データベースのアクタータブで表示されている番号になります。
  109.  *  [必要LP]       - スキルの習得に必要なLP(数字)
  110.  *
  111.  * -----------------------------------------------------------------------------
  112.  * 武器・防具に設定するメモタグ
  113.  *
  114.  * <learningSkill[習得番号]:[スキルID]>
  115.  *  装備から習得できるスキルを設定します。
  116.  *  [習得番号] - 00~04までの2桁の数値が設定できます。(数字)
  117.  *               なお、ひとつの装備に同じ習得番号を複数設定出来ません。
  118.  *  [スキルID] - スキルのID(数字)
  119.  *
  120.  * -----------------------------------------------------------------------------
  121.  * 敵キャラに設定するメモタグ
  122.  *
  123.  * <rewardLp:[獲得LP]>
  124.  *  敵キャラ撃破時に獲得できるLPの値を設定します。
  125.  *  [獲得LP] - 撃破時に獲得できるLP(数字)
  126.  *
  127.  * -----------------------------------------------------------------------------
  128.  * ステートに設定するメモタグ
  129.  *
  130.  * <lpRate:[獲得LP倍率]>
  131.  *  ステートを持つアクターが獲得できるLPの倍率を設定します。
  132.  *  [獲得LP倍率] - 獲得できるLPの倍率(数字-小数可)
  133.  *                 複数のステートで設定されている場合は乗算して反映されます。
  134.  *
  135.  * ----------------------------------------------------------------------------
  136.  * プラグインコマンド
  137.  *
  138.  * LPを獲得するコマンド
  139.  *   GainLp iteType param opeType value show
  140.  *
  141.  *     iteType
  142.  *       0   paramをアクター番号として使用する
  143.  *       1~ paramをアクター番号が格納された変数の番号として使用する
  144.  *     param
  145.  *       0   iteTypeが0の場合、パーティメンバー全体を対象とする
  146.  *       1~ iteTypeに基づきアクター番号となる
  147.  *     opeType
  148.  *       0   operandを変更する値として使用する
  149.  *       1~ operandを変更する値が格納された変数の番号として使用する
  150.  *     operand
  151.  *       opeTypeに基づき変更する値となる(負数にすると減る)
  152.  *     show
  153.  *       true  スキル習得メッセージを表示する
  154.  *       false スキル習得メッセージを表示しない
  155.  *
  156.  * e.g.)
  157.  *  パーティ全員が10LPを獲得する
  158.  *   GainLp 0 0 0 10 true
  159.  */
  160.  
  161. var Imported = Imported || {};
  162. Imported.dsEquipmentSkillLearning = true;
  163.  
  164. (function (exports) {
  165.         'use strict';
  166.  
  167.         exports.Param = (function() {
  168.                 var ret = {};
  169.                 var parameters = PluginManager.parameters('dsEquipmentSkillLearning');
  170.                 ret.Lp = String(parameters['Lp']);
  171.                 ret.BasicRewardLp = Number(parameters['Basic Reward Lp']);
  172.                 ret.RewardLpText = String(parameters['Reward Lp Text']);
  173.                 ret.ShowRewardLpText = Boolean(parameters['Show Reward Lp Text'] === 'true' || false);
  174.                 ret.LearningSkillText = String(parameters['Learning Skill Text']);
  175.                 ret.UsableEquipmentSkill = Boolean(parameters['Usable Equipment Skill'] === 'true' || false);
  176.                 ret.ShowLpGauge = Boolean(parameters['Show Lp Gauge'] === 'true' || false);
  177.                 ret.ShowLpValue = Boolean(parameters['Show Lp Value'] === 'true' || false);
  178.                 ret.ShowControlGuide = Boolean(parameters['Show Control Guide'] === 'true' || false);
  179.                 ret.GuideText = String(parameters['Guide Text']);
  180.                 ret.LpValueFontSize = Number(parameters['Lp Value Font Size']);
  181.                 ret.EquipmentSkillMax = 5;
  182.                 ret.LpAftermathEnable = Boolean(parameters['Lp Aftermath Enable'] === 'true' || false);
  183.                 ret.LpAftermathCaption = String(parameters['Lp Aftermath Caption']);
  184.                 ret.LpAftermathFormat = String(parameters['Lp Aftermath Format']);
  185.                 ret.LpAftermathEarned = String(parameters['Lp Aftermath Earned']);
  186.                 ret.LpMultipleGainEnable = Boolean(parameters['Lp Multiple Gain Enable'] === 'true' || false);
  187.                 return ret;
  188.         })();
  189.  
  190.         //--------------------------------------------------------------------------
  191.         /** Utility */
  192.         function Utility() {}
  193.  
  194.         Utility.leaningSkills = function(item)
  195.         {
  196.                 var list = [];
  197.                 for ( var jj = 0; jj < exports.Param.EquipmentSkillMax; jj++ )
  198.                 {
  199.                         var learningSkill = 'learningSkill' + ('0'+jj).slice(-2);
  200.                         if ( item.meta[learningSkill] )
  201.                         {
  202.                                 var id = Number(item.meta[learningSkill]);
  203.                                 if ( !list.contains($dataSkills[id]) )
  204.                                 {
  205.                                         list.push($dataSkills[id]);
  206.                                 }
  207.                         }
  208.                 }
  209.                 return list;
  210.         };
  211.  
  212.         //--------------------------------------------------------------------------
  213.         /** Game_Interpreter */
  214.         var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  215.         Game_Interpreter.prototype.pluginCommand = function(command, args)
  216.         {
  217.                 _Game_Interpreter_pluginCommand.call(this, command, args);
  218.                 if ( command === 'GainLp' )
  219.                 {
  220.                         var iteType = Number(args[0]);
  221.                         var param   = Number(args[1]);
  222.                         var opeType = Number(args[2]);
  223.                         var operand = Number(args[3]);
  224.                         var show    = Boolean(args[4]);
  225.                         this.gainLp(iteType, param, opeType, operand, show);
  226.                 }
  227.         };
  228.  
  229.         Game_Interpreter.prototype.gainLp = function(iteType, param, opeType, operand, show)
  230.         {
  231.                 var value = this.operateValue(0, opeType, operand);
  232.                 this.iterateActorEx(iteType, param, function(actor) {
  233.                         actor.gainLp(value, show);
  234.                 }.bind(this));
  235.         };
  236.  
  237.         //--------------------------------------------------------------------------
  238.         /** Game_Battler */
  239.         var _Game_Battler_onBattleStart = Game_Battler.prototype.onBattleStart;
  240.         Game_Battler.prototype.onBattleStart = function()
  241.         {
  242.                 _Game_Battler_onBattleStart.call(this);
  243.                 this._battleLp = 0;
  244.         };
  245.  
  246.         var _Game_Battler_onBattleEnd = Game_Battler.prototype.onBattleEnd;
  247.         Game_Battler.prototype.onBattleEnd = function()
  248.         {
  249.                 _Game_Battler_onBattleEnd.call(this);
  250.                 this._battleLp = 0;
  251.         };
  252.  
  253.         //--------------------------------------------------------------------------
  254.         /** Game_Actor */
  255.         var _Game_Actor_initMembers = Game_Actor.prototype.initMembers;
  256.         Game_Actor.prototype.initMembers = function()
  257.         {
  258.                 _Game_Actor_initMembers.call(this);
  259.                 this.initSkillLp();
  260.         };
  261.  
  262.         Game_Actor.prototype.initSkillLp = function()
  263.         {
  264.                 if ( !this._skillLp )
  265.                 {
  266.                         this._skillLp = {};
  267.                 }
  268.         };
  269.  
  270.         var _Game_Actor_skills = Game_Actor.prototype.skills;
  271.         Game_Actor.prototype.skillsOrigin = function()
  272.         {
  273.                 return _Game_Actor_skills.call(this);
  274.         };
  275.  
  276.         Game_Actor.prototype.skills = function()
  277.         {
  278.                 var list = this.skillsOrigin();
  279.                 if ( exports.Param.UsableEquipmentSkill )
  280.                 {
  281.                         this.equipmentSkills().forEach(function(skill) {
  282.                                 if ( !list.contains(skill) )
  283.                                 {
  284.                                         list.push(skill);
  285.                                 }
  286.                         });
  287.                 }
  288.                 return list;
  289.         };
  290.  
  291.         Game_Actor.prototype.equipmentSkills = function()
  292.         {
  293.                 var list = [];
  294.                 var equips = this.equips();
  295.                 for ( var ii = 0; ii < equips.length; ii++ )
  296.                 {
  297.                         var item = equips[ii];
  298.                         if ( item )
  299.                         {
  300.                                 Utility.leaningSkills(item).forEach(function(skill) {
  301.                                         if ( this.isLearnableSkill(skill) )
  302.                                         {
  303.                                                 if ( !list.contains(skill) )
  304.                                                 {
  305.                                                         list.push(skill);
  306.                                                 }
  307.                                         }
  308.                                 }, this);
  309.                         }
  310.                 }
  311.                 return list;
  312.         };
  313.  
  314.         Game_Actor.prototype.equipmentSameSkillCount = function(skillId)
  315.         {
  316.                 var count = 0;
  317.                 this.equips().forEach(function(item) {
  318.                         if ( item )
  319.                         {
  320.                                 Utility.leaningSkills(item).forEach(function(skill) {
  321.                                         if ( skill.id === skillId )
  322.                                         {
  323.                                                 count++;
  324.                                         }
  325.                                 });
  326.                         }
  327.                 });
  328.                 return count;
  329.         };
  330.  
  331.         Game_Actor.prototype.equipmentLearnSkills = function()
  332.         {
  333.                 this.initSkillLp();
  334.                 var list = [];
  335.                 for ( var id in this._skillLp )
  336.                 {
  337.                         if ( this.isLearnableSkill($dataSkills[id]) )
  338.                         {
  339.                                 if ( this._skillLp[id] < this.skillLpMax($dataSkills[id]) )
  340.                                 {
  341.                                         if ( !list.contains($dataSkills[id]) )
  342.                                         {
  343.                                                 list.push($dataSkills[id]);
  344.                                         }
  345.                                 }
  346.                         }
  347.                 }
  348.                 return list;
  349.         };
  350.  
  351.         Game_Actor.prototype.findNewSkills = function(lastSkills)
  352.         {
  353.                 var newSkills = this.skillsOrigin();
  354.                 for ( var ii = 0; ii < lastSkills.length; ii++ )
  355.                 {
  356.                         var index = newSkills.indexOf(lastSkills[ii]);
  357.                         if ( index >= 0 )
  358.                         {
  359.                                 newSkills.splice(index, 1);
  360.                         }
  361.                 }
  362.                 return newSkills;
  363.         };
  364.  
  365.         Game_Actor.prototype.gainLp = function(lp, show)
  366.         {
  367.                 lp = Math.round(lp * this.finalLpRate());
  368.                 var lastSkills = this.skillsOrigin();
  369.                 this.equipmentSkills().forEach(function(skill) {
  370.                         this.addSkillLp(skill, lp);
  371.                 }, this);
  372.                 if ( $gameParty.inBattle() )
  373.                 {
  374.                         this._battleLp = this._battleLp || 0;
  375.                         this._battleLp += lp;
  376.                 }
  377.                 if ( show )
  378.                 {
  379.                         var newSkills = this.findNewSkills(lastSkills);
  380.                         if ( newSkills.length > 0 )
  381.                         {
  382.                                 $gameMessage.newPage();
  383.                                 newSkills.forEach(function(skill) {
  384.                                         var text = exports.Param.LearningSkillText.format(this.name(), skill.name);
  385.                                         $gameMessage.add(text);
  386.                                 }, this);
  387.                         }
  388.                 }
  389.         };
  390.  
  391.         Game_Actor.prototype.finalLpRate = function()
  392.         {
  393.                 var rate = 1.0;
  394.                 this.traitObjects().forEach(function(trait) {
  395.                         if ( trait.meta.lpRate )
  396.                         {
  397.                                 rate *= Number(trait.meta.lpRate);
  398.                         }
  399.                 }, this);
  400.                 return rate;
  401.         };
  402.  
  403.         Game_Actor.prototype.addSkillLp = function(skill, lp)
  404.         {
  405.                 if ( this.isLearnableSkill(skill) )
  406.                 {
  407.                         if ( exports.Param.LpMultipleGainEnable )
  408.                         {
  409.                                 lp *= this.equipmentSameSkillCount(skill.id);
  410.                         }
  411.                         this.initSkillLp();
  412.                         if ( this._skillLp[skill.id] )
  413.                         {
  414.                                 this._skillLp[skill.id] += lp;
  415.                         }
  416.                         else
  417.                         {
  418.                                 this._skillLp[skill.id] = lp;
  419.                         }
  420.                         var lpMax = this.skillLpMax(skill);
  421.                         if ( this._skillLp[skill.id] >= lpMax )
  422.                         {
  423.                                 this.learnLpSkill(skill.id);
  424.                                 this._skillLp[skill.id] = lpMax;
  425.                         }
  426.                 }
  427.         };
  428.  
  429.         Game_Actor.prototype.learnLpSkill = function(skillId)
  430.         {
  431.                 this.learnSkill(skillId);
  432.         };
  433.  
  434.         Game_Actor.prototype.skillLp = function(skill)
  435.         {
  436.                 this.initSkillLp();
  437.                 if ( this._skillLp[skill.id] )
  438.                 {
  439.                         return this._skillLp[skill.id];
  440.                 }
  441.                 return 0;
  442.         };
  443.  
  444.         Game_Actor.prototype.isLearnableSkill = function(skill)
  445.         {
  446.                 var tag = 'lpActor' + ('0000'+this.actorId()).slice(-4);
  447.                 if ( skill.meta[tag] )
  448.                 {
  449.                         return true;
  450.                 }
  451.                 if ( skill.meta.lp )
  452.                 {
  453.                         return true;
  454.                 }
  455.                 return false;
  456.         };
  457.  
  458.         Game_Actor.prototype.skillLpMax = function(skill)
  459.         {
  460.                 var tag = 'lpActor' + ('0000'+this.actorId()).slice(-4);
  461.                 if ( skill.meta[tag] )
  462.                 {
  463.                         return Number(skill.meta[tag]);
  464.                 }
  465.                 if ( skill.meta.lp )
  466.                 {
  467.                         return Number(skill.meta.lp);
  468.                 }
  469.                 return 1;
  470.         };
  471.  
  472.         Game_Actor.prototype.lpRate = function(skill)
  473.         {
  474.                 var needLp = this.skillLpMax(skill);
  475.                 return (needLp > 0) ? this.skillLp(skill) / needLp : 0;
  476.         };
  477.  
  478.         Game_Actor.prototype.battleLp = function(skillId)
  479.         {
  480.                 this._battleLp = this._battleLp || 0;
  481.                 return this._battleLp;
  482.         };
  483.  
  484.         Game_Actor.prototype.isEquipmentSkill = function(skill)
  485.         {
  486.                 var skills = this.equipmentSkills();
  487.                 return skills.contains(skill) ? true : false;
  488.         };
  489.  
  490.         Game_Actor.prototype.isLearningSkill = function(skill)
  491.         {
  492.                 var skills = this.equipmentLearnSkills();
  493.                 return skills.contains(skill) ? true : false;
  494.         };
  495.  
  496.         //--------------------------------------------------------------------------
  497.         /** Game_Enemy */
  498.         Game_Enemy.prototype.lp = function()
  499.         {
  500.                 var enemy = this.enemy();
  501.                 if ( enemy.meta.rewardLp )
  502.                 {
  503.                         return Number(enemy.meta.rewardLp);
  504.                 }
  505.                 return exports.Param.BasicRewardLp;
  506.         };
  507.  
  508.         //--------------------------------------------------------------------------
  509.         /** Game_Troop */
  510.         Game_Troop.prototype.lpTotal = function()
  511.         {
  512.                 return this.deadMembers().reduce(function(r, enemy) {
  513.                         return r + enemy.lp();
  514.                 }, 0);
  515.         };
  516.  
  517.         //--------------------------------------------------------------------------
  518.         /** Window_Base */
  519.         Window_Base.prototype.lpColor = function()
  520.         {
  521.                 return this.systemColor();
  522.         };
  523.  
  524.         Window_Base.prototype.learningGaugeColor1 = function()
  525.         {
  526.                 return this.textColor(28);
  527.         };
  528.  
  529.         Window_Base.prototype.learningGaugeColor2 = function()
  530.         {
  531.                 return this.textColor(29);
  532.         };
  533.  
  534.         Window_Base.prototype.lpValueWidth = function()
  535.         {
  536.                 this.contents.fontSize = exports.Param.LpValueFontSize;
  537.                 var valueWidth = this.textWidth('000');
  538.                 var slashWidth = this.textWidth('/');
  539.                 this.contents.fontSize = this.standardFontSize();
  540.                 return valueWidth * 2 + slashWidth;
  541.         };
  542.  
  543.         Window_Base.prototype.drawChangeTab = function(x, y)
  544.         {
  545.                 var text = exports.Param.GuideText;
  546.                 var lastFontSize = this.contents.fontSize;
  547.                 this.contents.fontSize = 14;
  548.                 var textWidth = this.textWidth(text);
  549.                 this.changeTextColor(this.systemColor());
  550.                 this.drawText(text, x - textWidth, y, textWidth);
  551.                 this.contents.fontSize = lastFontSize;
  552.         };
  553.  
  554.         Window_Base.prototype.drawLpGauge = function(actor, skill, x, y, width)
  555.         {
  556.                 if ( exports.Param.ShowLpGauge )
  557.                 {
  558.                         var iconBoxWidth = Window_Base._iconWidth + 4;
  559.                         var x1 = x + iconBoxWidth;
  560.                         var gaugeWidth = width - iconBoxWidth;
  561.                         var rate = actor.lpRate(skill);
  562.                         var color1 = this.learningGaugeColor1();
  563.                         var color2 = this.learningGaugeColor2();
  564.                         this.drawGauge(x1, y, gaugeWidth, rate, color1, color2);
  565.                 }
  566.         };
  567.  
  568.         Window_Base.prototype.drawLpValue = function(actor, skill, x, y, width)
  569.         {
  570.                 if ( exports.Param.ShowLpValue )
  571.                 {
  572.                         var lp = actor.skillLp(skill);
  573.                         var lpMax = actor.skillLpMax(skill);
  574.                         this.contents.fontSize = exports.Param.LpValueFontSize;
  575.                         var labelWidth = this.textWidth(exports.Param.Lp);
  576.                         var valueWidth = this.textWidth('000');
  577.                         var slashWidth = this.textWidth('/');
  578.                         var valueHeight = (this.lineHeight() - this.contents.fontSize) / 2;
  579.                         var x1 = x + width - valueWidth;
  580.                         var x2 = x1 - slashWidth;
  581.                         var x3 = x2 - valueWidth;
  582.                         var y1 = y - valueHeight;
  583.                         var y2 = y + valueHeight;
  584.                         if ( y2 - y1 >= this.contents.fontSize )
  585.                         {
  586.                                 this.changeTextColor(this.lpColor());
  587.                                 this.drawText(exports.Param.Lp, x3, y1, labelWidth);
  588.                         }
  589.                         if ( x3 >= x + labelWidth )
  590.                         {
  591.                                 this.resetTextColor();
  592.                                 this.drawText(lp, x3, y2, valueWidth, 'right');
  593.                                 this.drawText('/', x2, y2, slashWidth, 'right');
  594.                                 this.drawText(lpMax, x1, y2, valueWidth, 'right');
  595.                         }
  596.                         else
  597.                         {
  598.                                 this.resetTextColor();
  599.                                 this.drawText(lp, x1, y2, valueWidth, 'right');
  600.                         }
  601.                         this.contents.fontSize = this.standardFontSize();
  602.                 }
  603.         };
  604.  
  605.         //--------------------------------------------------------------------------
  606.         /** Window_Selectable */
  607.         var _Window_Selectable_processHandling = Window_Selectable.prototype.processHandling;
  608.         Window_Selectable.prototype.processHandling = function()
  609.         {
  610.                 _Window_Selectable_processHandling.call(this);
  611.                 if ( this.isOpenAndActive() )
  612.                 {
  613.                         if ( this.isHandled('shift') && Input.isTriggered('shift') )
  614.                         {
  615.                                 this.processShift();
  616.                         }
  617.                 }
  618.         };
  619.  
  620.         Window_Selectable.prototype.processShift = function()
  621.         {
  622.                 SoundManager.playCursor();
  623.                 this.callHandler('shift');
  624.         };
  625.  
  626.         //--------------------------------------------------------------------------
  627.         /** Window_MenuSkill */
  628.         exports.Window_MenuSkill = (function() {
  629.  
  630.                 function Window_MenuSkill()
  631.                 {
  632.                         this.initialize.apply(this, arguments);
  633.                 }
  634.  
  635.                 Window_MenuSkill.prototype = Object.create(Window_SkillList.prototype);
  636.                 Window_MenuSkill.prototype.constructor = Window_MenuSkill;
  637.  
  638.                 Window_MenuSkill.prototype.isEnabled = function(item)
  639.                 {
  640.                         if ( this._actor )
  641.                         {
  642.                                 if ( exports.Param.UsableEquipmentSkill )
  643.                                 {
  644.                                         if ( this.isLearningSkill(item) )
  645.                                         {
  646.                                                 if ( !this.isEquipmentSkill(item) )
  647.                                                 {
  648.                                                         return false; // 装備していなければ使えない
  649.                                                 }
  650.                                         }
  651.                                 }
  652.                                 else
  653.                                 {
  654.                                         if ( this._actor.skills().indexOf(item) < 0 )
  655.                                         {
  656.                                                 return false;
  657.                                         }
  658.                                 }
  659.                                 return this._actor.canUse(item);
  660.                         }
  661.                         return false;
  662.                 };
  663.  
  664.                 Window_MenuSkill.prototype.makeItemList = function()
  665.                 {
  666.                         if ( this._actor )
  667.                         {
  668.                                 var skills = this._actor.skills();
  669.                                 this._actor.equipmentSkills().forEach(function(skill) {
  670.                                         if ( !skills.contains(skill) )
  671.                                         {
  672.                                                 skills.push(skill);
  673.                                         }
  674.                                 }, this);
  675.                                 this._actor.equipmentLearnSkills().forEach(function(skill) {
  676.                                         if ( !skills.contains(skill) )
  677.                                         {
  678.                                                 skills.push(skill);
  679.                                         }
  680.                                 }, this);
  681.                                 this._data = skills.filter(function(skill) {
  682.                                         return this.includes(skill);
  683.                                 }, this);
  684.                                 this._data.sort(function(a, b) {
  685.                                         return a.id - b.id;
  686.                                 });
  687.                         }
  688.                         else
  689.                         {
  690.                                 this._data = [];
  691.                         }
  692.                 };
  693.  
  694.                 Window_MenuSkill.prototype.drawItem = function(index)
  695.                 {
  696.                         var skill = this._data[index];
  697.                         if ( skill )
  698.                         {
  699.                                 var costWidth = this.costWidth();
  700.                                 var rect = this.itemRect(index);
  701.                                 rect.width -= this.textPadding();
  702.                                 if ( this.isLearningSkill(skill) )
  703.                                 {
  704.                                         this.drawLearning(skill, rect.x, rect.y, rect.width - costWidth);
  705.                                 }
  706.                                 if ( exports.Param.ShowLpValue )
  707.                                 {
  708.                                         costWidth += this.lpValueWidth();
  709.                                 }
  710.                                 this.changePaintOpacity(this.isEnabled(skill));
  711.                                 this.drawItemName(skill, rect.x, rect.y, rect.width - costWidth);
  712.                                 this.drawSkillCost(skill, rect.x, rect.y, rect.width);
  713.                                 this.changePaintOpacity(true);
  714.                                 if ( this.isEquipmentSkill(skill) )
  715.                                 {
  716.                                         this.drawEquipment(skill, rect.x, rect.y, rect.width);
  717.                                 }
  718.                         }
  719.                 };
  720.  
  721.                 Window_MenuSkill.prototype.drawEquipment = function(skill, x, y, width)
  722.                 {
  723.                         this.contents.fontSize = Window_Base._iconWidth / 2;
  724.                         this.changeTextColor(this.systemColor());
  725.                         this.drawText('E', x + 4, y + 8, Window_Base._iconWidth, 'right');
  726.                         this.contents.fontSize = this.standardFontSize();
  727.                         this.resetTextColor();
  728.                 };
  729.  
  730.                 Window_MenuSkill.prototype.drawLearning = function(skill, x, y, width)
  731.                 {
  732.                         this.drawLpGauge(this._actor, skill, x, y, width);
  733.                         this.drawLpValue(this._actor, skill, x, y, width);
  734.                 };
  735.  
  736.                 Window_MenuSkill.prototype.isEquipmentSkill = function(item)
  737.                 {
  738.                         return this._actor && this._actor.isEquipmentSkill(item);
  739.                 };
  740.  
  741.                 Window_MenuSkill.prototype.isLearningSkill = function(item)
  742.                 {
  743.                         if ( this._actor )
  744.                         {
  745.                                 if ( !this._actor.isLearnedSkill(item.id) )
  746.                                 {
  747.                                         return this._actor.isLearningSkill(item) || this._actor.isEquipmentSkill(item);
  748.                                 }
  749.                         }
  750.                         return false;
  751.                 };
  752.  
  753.                 return Window_MenuSkill;
  754.         })();
  755.  
  756.         //--------------------------------------------------------------------------
  757.         /** Window_EquipStatus */
  758.         var _Window_EquipStatus_initialize = Window_EquipStatus.prototype.initialize;
  759.         Window_EquipStatus.prototype.initialize = function(x, y)
  760.         {
  761.                 this._handlers = {};
  762.                 _Window_EquipStatus_initialize.call(this, x, y);
  763.         };
  764.  
  765.         Window_EquipStatus.prototype.setHandler = function(symbol, method)
  766.         {
  767.                 this._handlers[symbol] = method;
  768.         };
  769.  
  770.         Window_EquipStatus.prototype.isHandled = function(symbol)
  771.         {
  772.                 return !!this._handlers[symbol];
  773.         };
  774.  
  775.         Window_EquipStatus.prototype.callHandler = function(symbol)
  776.         {
  777.                 if ( this.isHandled(symbol) )
  778.                 {
  779.                         this._handlers[symbol]();
  780.                 }
  781.         };
  782.  
  783.         Window_EquipStatus.prototype.update = function()
  784.         {
  785.                 Window_Base.prototype.update.call(this);
  786.                 this.processTouch();
  787.         };
  788.  
  789.         Window_EquipStatus.prototype.processTouch = function()
  790.         {
  791.                 if ( this.visible )
  792.                 {
  793.                         if ( TouchInput.isTriggered() && this.isTouchedInsideFrame() )
  794.                         {
  795.                                 SoundManager.playCursor();
  796.                                 this.callHandler('touch');
  797.                         }
  798.                 }
  799.         };
  800.  
  801.         Window_EquipStatus.prototype.isTouchedInsideFrame = function()
  802.         {
  803.                 var x = this.canvasToLocalX(TouchInput.x);
  804.                 var y = this.canvasToLocalY(TouchInput.y);
  805.                 return x >= 0 && y >= 0 && x < this.width && y < this.height;
  806.         };
  807.  
  808.         var _Window_EquipStatus_refresh = Window_EquipStatus.prototype.refresh;
  809.         Window_EquipStatus.prototype.refresh = function()
  810.         {
  811.                 _Window_EquipStatus_refresh.call(this);
  812.                 if ( exports.Param.ShowControlGuide )
  813.                 {
  814.                         this.drawChangeTab(this.contentsWidth(), 0);
  815.                 }
  816.         };
  817.  
  818.         //--------------------------------------------------------------------------
  819.         /** Window_EquipLearning */
  820.         exports.Window_EquipLearning = (function() {
  821.  
  822.                 function Window_EquipLearning()
  823.                 {
  824.                         this.initialize.apply(this, arguments);
  825.                 }
  826.  
  827.                 Window_EquipLearning.prototype = Object.create(Window_Base.prototype);
  828.                 Window_EquipLearning.prototype.constructor = Window_EquipLearning;
  829.  
  830.                 Window_EquipLearning.prototype.initialize = function(x, y, width, height)
  831.                 {
  832.                         Window_Base.prototype.initialize.call(this, x, y, width, height);
  833.                         this._actor = null;
  834.                         this._item = null;
  835.                         this._handlers = {};
  836.                         this.refresh();
  837.                 };
  838.  
  839.                 Window_EquipLearning.prototype.numVisibleRows = function()
  840.                 {
  841.                         return 7;
  842.                 };
  843.  
  844.                 Window_EquipLearning.prototype.setActor = function(actor)
  845.                 {
  846.                         if ( this._actor !== actor )
  847.                         {
  848.                                 this._actor = actor;
  849.                                 this.refresh();
  850.                         }
  851.                 };
  852.  
  853.                 Window_EquipLearning.prototype.setItem = function(item)
  854.                 {
  855.                         if ( this._item !== item )
  856.                         {
  857.                                 this._item = item;
  858.                                 this.refresh();
  859.                         }
  860.                 };
  861.  
  862.                 Window_EquipLearning.prototype.setHandler = function(symbol, method)
  863.                 {
  864.                         this._handlers[symbol] = method;
  865.                 };
  866.  
  867.                 Window_EquipLearning.prototype.isHandled = function(symbol)
  868.                 {
  869.                         return !!this._handlers[symbol];
  870.                 };
  871.  
  872.                 Window_EquipLearning.prototype.callHandler = function(symbol)
  873.                 {
  874.                         if ( this.isHandled(symbol) )
  875.                         {
  876.                                 this._handlers[symbol]();
  877.                         }
  878.                 };
  879.  
  880.                 Window_EquipLearning.prototype.update = function()
  881.                 {
  882.                         Window_Base.prototype.update.call(this);
  883.                         this.processTouch();
  884.                 };
  885.  
  886.                 Window_EquipLearning.prototype.processTouch = function()
  887.                 {
  888.                         if ( this.visible )
  889.                         {
  890.                                 if ( TouchInput.isTriggered() && this.isTouchedInsideFrame() )
  891.                                 {
  892.                                         SoundManager.playCursor();
  893.                                         this.callHandler('touch');
  894.                                 }
  895.                         }
  896.                 };
  897.  
  898.                 Window_EquipLearning.prototype.isTouchedInsideFrame = function()
  899.                 {
  900.                         var x = this.canvasToLocalX(TouchInput.x);
  901.                         var y = this.canvasToLocalY(TouchInput.y);
  902.                         return x >= 0 && y >= 0 && x < this.width && y < this.height;
  903.                 };
  904.  
  905.                 Window_EquipLearning.prototype.refresh = function()
  906.                 {
  907.                         this.contents.clear();
  908.                         if ( this._actor )
  909.                         {
  910.                                 var lineHeight = this.lineHeight();
  911.                                 this.drawActorName(this._actor, this.textPadding(), 0);
  912.                                 if ( this._item )
  913.                                 {
  914.                                         var x1 = this.textPadding();
  915.                                         var y1 = lineHeight;
  916.                                         var width = this.contentsWidth() - this.textPadding();
  917.                                         this.drawItemName(this._item, x1, y1, width);
  918.                                         var lineY = y1 + lineHeight + lineHeight / 4 - 1;
  919.                                         this.contents.paintOpacity = 48;
  920.                                         this.contents.fillRect(0, lineY, this.contentsWidth(), 2, this.lineColor());
  921.                                         this.contents.paintOpacity = 255;
  922.                                         var lineCount = 0;
  923.                                         Utility.leaningSkills(this._item).forEach(function(skill) {
  924.                                                 if ( this._actor.isLearnableSkill(skill) )
  925.                                                 {
  926.                                                         this.drawLearningSkill(skill, x1, y1 + lineHeight * (1.5 + lineCount++), width);
  927.                                                 }
  928.                                         }, this);
  929.                                 }
  930.                         }
  931.                         if ( exports.Param.ShowControlGuide )
  932.                         {
  933.                                 this.drawChangeTab(this.contentsWidth(), 0);
  934.                         }
  935.                 };
  936.  
  937.                 Window_EquipLearning.prototype.drawLearningSkill = function(skill, x, y, width)
  938.                 {
  939.                         this.drawLpGauge(this._actor, skill, x, y, width);
  940.                         this.drawLpValue(this._actor, skill, x, y, width);
  941.                         if ( exports.Param.ShowLpValue )
  942.                         {
  943.                                 width -= this.lpValueWidth();
  944.                         }
  945.                         this.drawItemName(skill, x, y, width);
  946.                 };
  947.  
  948.                 Window_EquipLearning.prototype.lineColor = function()
  949.                 {
  950.                         return this.normalColor();
  951.                 };
  952.  
  953.                 return Window_EquipLearning;
  954.         })();
  955.  
  956.         //--------------------------------------------------------------------------
  957.         /** Scene_Skill */
  958.         Scene_Skill.prototype.createItemWindow = function()
  959.         {
  960.                 var wx = 0;
  961.                 var wy = this._statusWindow.y + this._statusWindow.height;
  962.                 var ww = Graphics.boxWidth;
  963.                 var wh = Graphics.boxHeight - wy;
  964.                 this._itemWindow = new exports.Window_MenuSkill(wx, wy, ww, wh);
  965.                 this._itemWindow.setHelpWindow(this._helpWindow);
  966.                 this._itemWindow.setHandler('ok',     this.onItemOk.bind(this));
  967.                 this._itemWindow.setHandler('cancel', this.onItemCancel.bind(this));
  968.                 this._skillTypeWindow.setSkillWindow(this._itemWindow);
  969.                 this.addWindow(this._itemWindow);
  970.         };
  971.  
  972.         //--------------------------------------------------------------------------
  973.         /** Scene_Equip */
  974.         var _Scene_Equip_initialize = Scene_Equip.prototype.initialize;
  975.         Scene_Equip.prototype.initialize = function()
  976.         {
  977.                 this._changeWindow = false;
  978.                 _Scene_Equip_initialize.call(this);
  979.         };
  980.  
  981.         Scene_Equip.prototype.create = function()
  982.         {
  983.                 Scene_MenuBase.prototype.create.call(this);
  984.                 this.createHelpWindow();
  985.                 this.createStatusWindow();
  986.                 this.createCommandWindow();
  987.                 this.createSlotWindow();
  988.                 this.createItemWindow();
  989.                 this.createLearningWindow();
  990.                 this.refreshActor();
  991.         };
  992.  
  993.         var _Scene_Equip_createStatusWindow = Scene_Equip.prototype.createStatusWindow;
  994.         Scene_Equip.prototype.createStatusWindow = function()
  995.         {
  996.                 _Scene_Equip_createStatusWindow.call(this);
  997.                 this._statusWindow.setHandler('touch', this.onWindowTouch.bind(this));
  998.         };
  999.  
  1000.         var _Scene_Equip_createCommandWindow = Scene_Equip.prototype.createCommandWindow;
  1001.         Scene_Equip.prototype.createCommandWindow = function()
  1002.         {
  1003.                 _Scene_Equip_createCommandWindow.call(this);
  1004.                 this._commandWindow.setHandler('shift', this.onWindowChange.bind(this));
  1005.         };
  1006.  
  1007.         var _Scene_Equip_createSlotWindow = Scene_Equip.prototype.createSlotWindow;
  1008.         Scene_Equip.prototype.createSlotWindow = function()
  1009.         {
  1010.                 _Scene_Equip_createSlotWindow.call(this);
  1011.                 this._slotWindow.setHandler('shift', this.onWindowChange.bind(this));
  1012.         };
  1013.  
  1014.         var _Scene_Equip_createItemWindow = Scene_Equip.prototype.createItemWindow;
  1015.         Scene_Equip.prototype.createItemWindow = function()
  1016.         {
  1017.                 _Scene_Equip_createItemWindow.call(this);
  1018.                 this._itemWindow.setHandler('shift', this.onWindowChange.bind(this));
  1019.         };
  1020.  
  1021.         Scene_Equip.prototype.createLearningWindow = function()
  1022.         {
  1023.                 var wx = this._statusWindow.x;
  1024.                 var wy = this._statusWindow.y;
  1025.                 var ww = this._statusWindow.width;
  1026.                 var wh = this._statusWindow.height;
  1027.                 this._learningWindow = new exports.Window_EquipLearning(wx, wy, ww, wh);
  1028.                 this._learningWindow.setHandler('touch', this.onWindowTouch.bind(this));
  1029.                 this._learningWindow.hide();
  1030.                 this.addWindow(this._learningWindow);
  1031.         };
  1032.  
  1033.         var _Scene_Equip_refreshActor = Scene_Equip.prototype.refreshActor;
  1034.         Scene_Equip.prototype.refreshActor = function()
  1035.         {
  1036.                 _Scene_Equip_refreshActor.call(this);
  1037.                 this._learningWindow.setActor(this.actor());
  1038.         };
  1039.  
  1040.         var _Scene_Equip_update = Scene_Equip.prototype.update;
  1041.         Scene_Equip.prototype.update = function()
  1042.         {
  1043.                 _Scene_Equip_update.call(this);
  1044.                 this.updateLearningSkill();
  1045.                 this.updateChangeWindow();
  1046.         };
  1047.  
  1048.         Scene_Equip.prototype.updateLearningSkill = function()
  1049.         {
  1050.                 if ( this._commandWindow.active )
  1051.                 {
  1052.                         this._learningWindow.setItem(null);
  1053.                 }
  1054.                 else if ( this._slotWindow.active )
  1055.                 {
  1056.                         var item = this._slotWindow.item();
  1057.                         this._learningWindow.setItem(item);
  1058.                 }
  1059.                 else if ( this._itemWindow.active )
  1060.                 {
  1061.                         var item = this._itemWindow.item();
  1062.                         this._learningWindow.setItem(item);
  1063.                 }
  1064.         };
  1065.  
  1066.         Scene_Equip.prototype.updateChangeWindow = function()
  1067.         {
  1068.                 if ( this._changeWindow )
  1069.                 {
  1070.                         this.onWindowChange();
  1071.                         this._changeWindow = false;
  1072.                 }
  1073.         };
  1074.  
  1075.         Scene_Equip.prototype.onWindowChange = function()
  1076.         {
  1077.                 if ( this._statusWindow.visible )
  1078.                 {
  1079.                         this._statusWindow.hide();
  1080.                         this._learningWindow.show();
  1081.                 }
  1082.                 else
  1083.                 {
  1084.                         this._statusWindow.show();
  1085.                         this._learningWindow.hide();
  1086.                 }
  1087.         };
  1088.  
  1089.         Scene_Equip.prototype.onWindowTouch = function()
  1090.         {
  1091.                 this._changeWindow = true;
  1092.         };
  1093.  
  1094.         //--------------------------------------------------------------------------
  1095.         /** BattleManager */
  1096.         var _BattleManager_makeRewards = BattleManager.makeRewards;
  1097.         BattleManager.makeRewards = function()
  1098.         {
  1099.                 _BattleManager_makeRewards.call(this);
  1100.                 this._rewards.lp = $gameTroop.lpTotal();
  1101.         };
  1102.  
  1103.         var _BattleManager_displayRewards = BattleManager.displayRewards;
  1104.         BattleManager.displayRewards = function()
  1105.         {
  1106.                 _BattleManager_displayRewards.call(this);
  1107.                 this.displayLp();
  1108.         };
  1109.  
  1110.         BattleManager.displayLp = function()
  1111.         {
  1112.                 if ( exports.Param.ShowRewardLpText )
  1113.                 {
  1114.                         var lp = this._rewards.lp;
  1115.                         if ( lp > 0 )
  1116.                         {
  1117.                                 var text = exports.Param.RewardLpText.format(lp, exports.Param.Lp);
  1118.                                 $gameMessage.add('\\.' + text);
  1119.                         }
  1120.                 }
  1121.         };
  1122.  
  1123.         var _BattleManager_gainRewards = BattleManager.gainRewards;
  1124.         BattleManager.gainRewards = function()
  1125.         {
  1126.                 _BattleManager_gainRewards.call(this);
  1127.                 this.gainLp();
  1128.         };
  1129.  
  1130.         BattleManager.gainLp = function()
  1131.         {
  1132.                 var lp = this._rewards.lp;
  1133.                 $gameParty.allMembers().forEach(function(actor) {
  1134.                         actor.gainLp(lp, true);
  1135.                 });
  1136.         };
  1137.  
  1138.         //--------------------------------------------------------------------------
  1139.         //--------------------------------------------------------------------------
  1140.         //--------------------------------------------------------------------------
  1141.  
  1142.         if ( Imported.YEP_EquipCore )
  1143.         {
  1144.                 //----------------------------------------------------------------------
  1145.                 /** Window_EquipStatusYEP */
  1146.                 exports.Window_EquipStatusYEP = (function() {
  1147.  
  1148.                         function Window_EquipStatusYEP()
  1149.                         {
  1150.                                 this.initialize.apply(this, arguments);
  1151.                         }
  1152.  
  1153.                         Window_EquipStatusYEP.prototype = Object.create(Window_SkillStatus.prototype);
  1154.                         Window_EquipStatusYEP.prototype.constructor = Window_EquipStatusYEP;
  1155.  
  1156.                         Window_EquipStatusYEP.prototype.refresh = function()
  1157.                         {
  1158.                                 Window_SkillStatus.prototype.refresh.call(this);
  1159.                                 if ( exports.Param.ShowControlGuide )
  1160.                                 {
  1161.                                         if ( this._actor )
  1162.                                         {
  1163.                                                 this.drawChangeTab(this.contentsWidth(), -8);
  1164.                                         }
  1165.                                 }
  1166.                         };
  1167.  
  1168.                         return Window_EquipStatusYEP;
  1169.                 })();
  1170.  
  1171.                 //----------------------------------------------------------------------
  1172.                 /** Window_EquipLearning */
  1173.                 exports.Window_EquipLearning.prototype.refresh = function()
  1174.                 {
  1175.                         this.contents.clear();
  1176.                         if ( this._actor )
  1177.                         {
  1178.                                 var lineHeight = this.lineHeight();
  1179.                                 if ( this._item )
  1180.                                 {
  1181.                                         var x1 = this.textPadding();
  1182.                                         var y1 = 0;
  1183.                                         var width = this.contentsWidth() - this.textPadding();
  1184.                                         this.drawItemName(this._item, x1, y1, width);
  1185.                                         var lineY = y1 + lineHeight + lineHeight / 4 - 1;
  1186.                                         this.contents.paintOpacity = 48;
  1187.                                         this.contents.fillRect(0, lineY, this.contentsWidth(), 2, this.lineColor());
  1188.                                         this.contents.paintOpacity = 255;
  1189.                                         var lineCount = 0;
  1190.                                         Utility.leaningSkills(this._item).forEach(function(skill) {
  1191.                                                 if ( this._actor.isLearnableSkill(skill) )
  1192.                                                 {
  1193.                                                         this.drawLearningSkill(skill, x1, y1 + lineHeight * (1.5 + lineCount++), width);
  1194.                                                 }
  1195.                                         }, this);
  1196.                                 }
  1197.                         }
  1198.                 };
  1199.  
  1200.                 //----------------------------------------------------------------------
  1201.                 /** Scene_Equip */
  1202.                 Scene_Equip.prototype.create = function()
  1203.                 {
  1204.                         Scene_MenuBase.prototype.create.call(this);
  1205.                         this.createHelpWindow();
  1206.                         this.createCommandWindow();
  1207.                         this.createStatusWindow();
  1208.                         this.createSlotWindow();
  1209.                         this.createItemWindow();
  1210.                         this.createCompareWindow();
  1211.                         this._lowerRightVisibility = true;
  1212.                         this.updateLowerRightWindows();
  1213.                         this.createLearningWindow();
  1214.                         this.refreshActor();
  1215.                 };
  1216.  
  1217.                 Scene_Equip.prototype.createStatusWindow = function()
  1218.                 {
  1219.                         var wx = this._commandWindow.width;
  1220.                         var wy = this._helpWindow.height;
  1221.                         var ww = Graphics.boxWidth - wx;
  1222.                         var wh = this._commandWindow.height;
  1223.                         this._statusWindow = new exports.Window_EquipStatusYEP(wx, wy, ww, wh);
  1224.                         this.addWindow(this._statusWindow);
  1225.                 };
  1226.  
  1227.                 Scene_Equip.prototype.createLearningWindow = function()
  1228.                 {
  1229.                         var wx = this._compareWindow.x;
  1230.                         var wy = this._compareWindow.y;
  1231.                         var ww = this._compareWindow.width;
  1232.                         var wh = this._compareWindow.height;
  1233.                         this._learningWindow = new exports.Window_EquipLearning(wx, wy, ww, wh);
  1234.                         this._learningWindow.hide();
  1235.                         this.addWindow(this._learningWindow);
  1236.                 };
  1237.  
  1238.                 Scene_Equip.prototype.onWindowChange = function()
  1239.                 {
  1240.                         if ( this._compareWindow.visible )
  1241.                         {
  1242.                                 this._compareWindow.hide();
  1243.                                 this._learningWindow.show();
  1244.                         }
  1245.                         else
  1246.                         {
  1247.                                 this._compareWindow.show();
  1248.                                 this._learningWindow.hide();
  1249.                         }
  1250.                 };
  1251.  
  1252.         } // Imported.YEP_EquipCore
  1253.  
  1254.         //--------------------------------------------------------------------------
  1255.         //--------------------------------------------------------------------------
  1256.         //--------------------------------------------------------------------------
  1257.  
  1258.         if ( Imported.YEP_VictoryAftermath && exports.Param.LpAftermathEnable )
  1259.         {
  1260.                 //----------------------------------------------------------------------
  1261.                 /** BattleManager */
  1262.                 var _BattleManager_prepareVictoryInfo = BattleManager.prepareVictoryInfo;
  1263.                 BattleManager.prepareVictoryInfo = function()
  1264.                 {
  1265.                         $gameParty.allMembers().forEach(function(actor) {
  1266.                                 actor._victoryLpSkills = [];
  1267.                                 actor._victoryLpGauges = [];
  1268.                         }, this);
  1269.                         _BattleManager_prepareVictoryInfo.call(this);
  1270.                 };
  1271.  
  1272.                 BattleManager.gainLp = function()
  1273.                 {
  1274.                         var lp = this._rewards.lp;
  1275.                         $gameParty.allMembers().forEach(function(actor) {
  1276.                                 actor.gainLp(lp, false);
  1277.                         });
  1278.                 };
  1279.  
  1280.                 //----------------------------------------------------------------------
  1281.                 /** Game_Actor */
  1282.                 var _Game_Actor_clearVictoryData = Game_Actor.prototype.clearVictoryData;
  1283.                 Game_Actor.prototype.clearVictoryData = function()
  1284.                 {
  1285.                         _Game_Actor_clearVictoryData.call(this);
  1286.                         this._victoryLpSkills = undefined;
  1287.                         this._victoryLpGauges = undefined;
  1288.                 };
  1289.  
  1290.                 var _Game_Actor_gainLp = Game_Actor.prototype.gainLp;
  1291.                 Game_Actor.prototype.gainLp = function(lp, show)
  1292.                 {
  1293.                         _Game_Actor_gainLp.call(this, lp, show);
  1294.                 };
  1295.  
  1296.                 var _Game_Actor_addSkillLp = Game_Actor.prototype.addSkillLp;
  1297.                 Game_Actor.prototype.addSkillLp = function(skill, lp)
  1298.                 {
  1299.                         var victoryLpEnable = false;
  1300.                         var beforeLp = 0;
  1301.                         if ( this.isLearnableSkill(skill) )
  1302.                         {
  1303.                                 if ( !this.isLearnedSkill(skill.id) )
  1304.                                 {
  1305.                                         victoryLpEnable = true;
  1306.                                         if ( this._skillLp && this._skillLp[skill.id] )
  1307.                                         {
  1308.                                                 beforeLp = this._skillLp[skill.id];
  1309.                                         }
  1310.                                 }
  1311.                         }
  1312.                         _Game_Actor_addSkillLp.call(this, skill, lp);
  1313.                         if ( victoryLpEnable && this._victoryLpGauges )
  1314.                         {
  1315.                                 var data = {
  1316.                                         skillId: skill.id,
  1317.                                         before: beforeLp
  1318.                                 };
  1319.                                 this._victoryLpGauges.push(data);
  1320.                         }
  1321.                 };
  1322.  
  1323.                 var _Game_Actor_learnLpSkill = Game_Actor.prototype.learnLpSkill;
  1324.                 Game_Actor.prototype.learnLpSkill = function(skillId)
  1325.                 {
  1326.                         var addVictorySkills = false;
  1327.                         if ( !this.isLearnedSkill(skillId) && this._victoryPhase )
  1328.                         {
  1329.                                 addVictorySkills = true;
  1330.                         }
  1331.                         _Game_Actor_learnLpSkill.call(this, skillId);
  1332.                         if ( addVictorySkills )
  1333.                         {
  1334.                                 var idx = this._victorySkills.indexOf(skillId);
  1335.                                 if ( idx >= 0 )
  1336.                                 {
  1337.                                         this._victorySkills.splice(idx, 1);
  1338.                                 }
  1339.                                 this._victoryLpSkills.push(skillId);
  1340.                         }
  1341.                 };
  1342.  
  1343.                 Game_Actor.prototype.gainedLp = function()
  1344.                 {
  1345.                         return this.battleLp();
  1346.                 };
  1347.  
  1348.                 Game_Actor.prototype.gainedLpBySkill = function(skillId)
  1349.                 {
  1350.                         var lp = this.battleLp();
  1351.                         if ( exports.Param.LpMultipleGainEnable )
  1352.                         {
  1353.                                 lp *= this.equipmentSameSkillCount(skillId);
  1354.                         }
  1355.                         return lp;
  1356.                 };
  1357.  
  1358.                 Game_Actor.prototype.victoryLpSkills = function()
  1359.                 {
  1360.                         return this._victoryLpSkills;
  1361.                 };
  1362.  
  1363.                 Game_Actor.prototype.victoryLpGauges = function()
  1364.                 {
  1365.                         return this._victoryLpGauges;
  1366.                 };
  1367.  
  1368.                 //----------------------------------------------------------------------
  1369.                 /** Window_VictoryLp */
  1370.                 exports.Window_VictoryLp = (function() {
  1371.  
  1372.                         function Window_VictoryLp()
  1373.                         {
  1374.                                 this.initialize.apply(this, arguments);
  1375.                         }
  1376.  
  1377.                         Window_VictoryLp.prototype = Object.create(Window_VictoryExp.prototype);
  1378.                         Window_VictoryLp.prototype.constructor = Window_VictoryLp;
  1379.  
  1380.                         Window_VictoryLp.prototype.drawActorGauge = function(actor, index)
  1381.                         {
  1382.                                 var rect = this.gaugeRect(index);
  1383.                                 this.clearGaugeRect(index);
  1384.                                 this.resetTextColor();
  1385.                                 this.drawActorName(actor, rect.x + 2, rect.y);
  1386.                                 this.drawLevel(actor, rect);
  1387.                                 this.drawLpGained(actor, rect);
  1388.                                 this.drawGainedSkills(actor, rect);
  1389.                         };
  1390.  
  1391.                         Window_VictoryLp.prototype.drawLpGained = function(actor, rect)
  1392.                         {
  1393.                                 var value = actor.battleLp();
  1394.                                 var text = exports.Param.LpAftermathFormat.format(value, exports.Param.Lp);
  1395.                                 var wx = rect.x + rect.width - this.textWidthEx(text);
  1396.                                 var wy = rect.y + this.lineHeight() * 1;
  1397.                                 this.changeTextColor(this.systemColor());
  1398.                                 this.drawText(exports.Param.LpAftermathEarned, rect.x + 2, wy, rect.width - 4, 'left');
  1399.                                 this.resetTextColor();
  1400.                                 this.drawTextEx(text, wx, wy);
  1401.                         };
  1402.  
  1403.                         Window_VictoryLp.prototype.drawGainedSkills = function(actor, rect)
  1404.                         {
  1405.                                 if ( !this.meetDrawGainedSkillsCondition(actor) )
  1406.                                 {
  1407.                                         return;
  1408.                                 }
  1409.                                 var victorySkills = actor.victoryLpSkills();
  1410.                                 if ( victorySkills )
  1411.                                 {
  1412.                                         var wy = rect.y;
  1413.                                         victorySkills.forEach(function(skillId) {
  1414.                                                 if ( wy + this.lineHeight() <= rect.y + rect.height )
  1415.                                                 {
  1416.                                                         var skill = $dataSkills[skillId];
  1417.                                                         if ( skill )
  1418.                                                         {
  1419.                                                                 var text = '\\i[' + skill.iconIndex + ']' + skill.name;
  1420.                                                                 text = TextManager.obtainSkill.format(text);
  1421.                                                                 var ww = this.textWidthEx(text);
  1422.                                                                 var wx = rect.x + (rect.width - ww) / 2;
  1423.                                                                 this.drawTextEx(text, wx, wy);
  1424.                                                                 wy += this.lineHeight();
  1425.                                                         }
  1426.                                                 }
  1427.                                         }, this);
  1428.                                 }
  1429.                         };
  1430.  
  1431.                         Window_VictoryLp.prototype.meetDrawGainedSkillsCondition = function(actor)
  1432.                         {
  1433.                                 if ( this._showGainedSkills )
  1434.                                 {
  1435.                                         if ( this._tick + 10 >= Yanfly.Param.VAGaugeTicks )
  1436.                                         {
  1437.                                                 return true;
  1438.                                         }
  1439.                                 }
  1440.                                 return false;
  1441.                         };
  1442.  
  1443.                         Window_VictoryLp.prototype.actorExpRate = function(actor)
  1444.                         {
  1445.                                 return 1.0;
  1446.                         };
  1447.  
  1448.                         return Window_VictoryLp;
  1449.                 })();
  1450.  
  1451.                 //----------------------------------------------------------------------
  1452.                 /** Scene_Battle */
  1453.                 var _Scene_Battle_addCustomVictorySteps = Scene_Battle.prototype.addCustomVictorySteps;
  1454.                 Scene_Battle.prototype.addCustomVictorySteps = function(array)
  1455.                 {
  1456.                         array = _Scene_Battle_addCustomVictorySteps.call(this, array);
  1457.                         if ( !array.contains('LP') )
  1458.                         {
  1459.                                 array.push('LP');
  1460.                         }
  1461.                         return array;
  1462.                 };
  1463.  
  1464.                 var _Scene_Battle_updateVictorySteps = Scene_Battle.prototype.updateVictorySteps;
  1465.                 Scene_Battle.prototype.updateVictorySteps = function()
  1466.                 {
  1467.                         _Scene_Battle_updateVictorySteps.call(this);
  1468.                         if ( this.isVictoryStep('LP') )
  1469.                         {
  1470.                                 this.updateVictoryLp();
  1471.                         }
  1472.                 };
  1473.  
  1474.                 Scene_Battle.prototype.updateVictoryLp = function()
  1475.                 {
  1476.                         if ( !this._victoryLpWindow )
  1477.                         {
  1478.                                 this.createVictoryLp();
  1479.                         }
  1480.                         else if ( this._victoryLpWindow.isReady() )
  1481.                         {
  1482.                                 if ( this.victoryTriggerContinue() )
  1483.                                 {
  1484.                                         this.finishVictoryLp();
  1485.                                 }
  1486.                         }
  1487.                 };
  1488.  
  1489.                 Scene_Battle.prototype.createVictoryLp = function()
  1490.                 {
  1491.                         this._victoryTitleWindow.refresh(exports.Param.LpAftermathCaption);
  1492.                         this._victoryLpWindow = new exports.Window_VictoryLp();
  1493.                         this._victoryLpWindow.open();
  1494.                         this.addWindow(this._victoryLpWindow);
  1495.                 };
  1496.  
  1497.                 Scene_Battle.prototype.finishVictoryLp = function()
  1498.                 {
  1499.                         SoundManager.playOk();
  1500.                         this._victoryLpWindow.close();
  1501.                         this.processNextVictoryStep();
  1502.                 };
  1503.  
  1504.         } // Imported.YEP_VictoryAftermath
  1505.  
  1506.         //--------------------------------------------------------------------------
  1507.         //--------------------------------------------------------------------------
  1508.         //--------------------------------------------------------------------------
  1509.  
  1510.         if ( Imported.ySkillCPSystem )
  1511.         {
  1512.                 //----------------------------------------------------------------------
  1513.                 /** Game_Actor */
  1514.                 Game_Actor.prototype.setPoint = function()
  1515.                 {
  1516.                         return Math.floor(this.skillsOrigin().reduce(function(r, skill) {
  1517.                                 if ( !skill.setPoint )
  1518.                                 {
  1519.                                         DataManager.initSetPoint(skill);
  1520.                                 }
  1521.                                 return this.isIncludeLearningSkills(skill.id) ? r : r + skill.setPoint;
  1522.                         }.bind(this), 0));
  1523.                 };
  1524.  
  1525.                 Game_Actor.prototype.capPoint = function()
  1526.                 {
  1527.                         return Math.floor(this.skillsOrigin().reduce(function(r, skill) {
  1528.                                 if ( !skill.capPoint )
  1529.                                 {
  1530.                                         DataManager.initCapPoint(skill);
  1531.                                 }
  1532.                                 return this.isIncludeLearningSkills(skill.id) ? r : r + skill.capPoint;
  1533.                         }.bind(this), 0));
  1534.                 };
  1535.  
  1536.                 //----------------------------------------------------------------------
  1537.                 /** Window_SkillEquipStatus */
  1538.                 exports.Window_SkillEquipStatus = (function() {
  1539.  
  1540.                         function Window_SkillEquipStatus()
  1541.                         {
  1542.                                 this.initialize.apply(this, arguments);
  1543.                         }
  1544.  
  1545.                         Window_SkillEquipStatus.prototype = Object.create(Window_EquipStatus.prototype);
  1546.                         Window_SkillEquipStatus.prototype.constructor = Window_SkillEquipStatus;
  1547.  
  1548.                         Window_SkillEquipStatus.prototype.drawChangeTab = function(x, y)
  1549.                         {
  1550.                         };
  1551.  
  1552.                         return Window_SkillEquipStatus;
  1553.                 })();
  1554.  
  1555.                 //----------------------------------------------------------------------
  1556.                 /** Scene_SkillEquip */
  1557.                 Scene_SkillEquip.prototype.createStatusWindow = function()
  1558.                 {
  1559.                         this._statusWindow = new exports.Window_SkillEquipStatus(0, this._helpWindow.height);
  1560.                         this.addWindow(this._statusWindow);
  1561.                 };
  1562.  
  1563.         } // Imported.ySkillCPSystem
  1564.  
  1565. }((this.dsEquipmentSkillLearning = this.dsEquipmentSkillLearning || {})));

作者: 多卡多卡    时间: 2019-3-3 16:56
soulsaga 发表于 2019-3-3 16:54
//==============================================================================
// dsEquipmentSkill ...

谢谢啦
作者: tseyik    时间: 2019-3-3 21:04
http://dourakusoftweb.blog.fc2.com/blog-entry-10.html
作成したプラグインの一覧になります。
プラグインの利用規約をご覧の上でご利用下さい。

----
○ 基礎システム系
・画面サイズとレイアウトサイズを別に設定するプラグイン ver1.01 記事へ
プラグインをダウンロード

----
○ 戦闘系
・バトラー選択変更プラグイン ver1.00 記事へ
プラグインをダウンロード

・戦闘開始時のメッセージ表示を変更するプラグイン ver1.00 記事へ
プラグインをダウンロード

・戦闘中のコマンド表示制御プラグイン ver1.00 記事へ
プラグインをダウンロード

----
○ メニュー系
・メニューのフェイスを戦闘キャラに変更するプラグイン ver1.02 記事へ
プラグインをダウンロード

・メニューコマンドを並べ替えるプラグイン ver1.01 記事へ
プラグインをダウンロード

----
○ ゲームシステム系
・武器熟練度プラグイン ver1.06 記事へ
プラグインをダウンロード

・ジョブチェンジプラグイン ver1.11.0 記事へ
プラグインをダウンロード
※拡張メニュー画面01 ver1.1.0 記事へ
プラグインをダウンロード

・職業間でスキルを共有しないプラグイン ver1.3.0 記事へ
プラグインをダウンロード

・コマンド割り当てプラグイン ver1.00 記事へ
プラグインをダウンロード

・装備からスキル習得プラグイン ver1.7.0 記事へ
プラグインをダウンロード
※リザルト画面拡張01 ver1.00 記事へ
プラグインをダウンロード
※リザルト画面拡張02 ver1.00 記事へ
プラグインをダウンロード
※リザルト画面拡張03 ver1.0.0 記事へ
プラグインをダウンロード

・パッシブスキルプラグイン ver1.5.1 記事へ
プラグインをダウンロード

・戦闘中の行動による能力成長プラグイン ver1.01 記事へ
プラグインをダウンロード




欢迎光临 Project1 (https://rpg.blue/) Powered by Discuz! X3.1