code:
//=============================================================================
// BattleEffectPopup.js
// ----------------------------------------------------------------------------
// (C)2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.9.2 2020/04/15 MOG_BattleHud.jsと併用したとき、フロントビューで味方にポップアップメッセージが表示されるよう変更
// 1.9.1 2020/03/15 YEP_X_ActSeqPack1.jsでステート付与に成功してもステート付与メッセージがでない不具合を代わりに修正
// 1.9.0 2020/02/11 ポップアップメッセージが重なったときに次のポップアップまでのウェイトが指定できる機能を追加
// 1.8.1 2019/02/26 KMS_SomStyleDamage.jsとの競合を解消。こちらのポップアップもKMS_SomStyleDamage.jsと同じ動きをします。
// 1.8.0 2018/10/13 パラメータの型指定機能に対応
//                  コモンイベントが呼び出された場合は無効ポップアップを出さないよう仕様変更
// 1.7.2 2018/10/07 プラグインコマンド「対象者ポップアップ」にて競合等の理由で対象が見付からない場合にエラーを回避するよう修正
// 1.7.1 2017/08/03 YEP_BattleEngineCore.jsと併用したときに、メッセージの種類によってポップアップ位置が変化する問題を修正
// 1.7.0 2017/06/13 行動がガード（耐性によって完全に防がれた）された場合のポップアップを追加
// 1.6.0 2017/06/10 行動が無効だった場合のポップアップを追加
// 1.5.1 2017/06/10 自動戦闘が有効なアクターがいる場合に一部機能が正常に動作しない問題を修正
// 1.5.0 2017/05/30 弱点と耐性のポップアップで弱点や耐性と見なすための閾値を設定できる機能を追加
// 1.4.0 2017/05/20 CounterExtend.jsとの併用でスキルによる反撃が表示されない問題を修正。
//                  ポップアップのイタリック体および縁取り表示を行う機能を追加。
// 1.3.1 2016/12/18 VE_BasicModule.jsとの競合を解消
// 1.3.0 2016/07/14 アクターと敵キャラの通常ダメージにも専用のフラッシュ色を指定できるようになりました。
// 1.2.3 2016/07/13 1.2.2の修正が不完全だったのを対応
// 1.2.2 2016/07/13 YEP_BattleEngineCore.jsと併用したときに、Missが重複して表示される現象を修正
// 1.2.1 2016/07/12 Z座標を指定しているプラグインとの競合を解消するかもしれない
// 1.2.0 2016/07/10 行動失敗時(Miss!)も任意の文字または画像に置き換えられるようになりました。
// 1.1.0 2016/07/09 ポップアップに任意の画像を指定できるようになりました。
//                  フラッシュするフレーム数を指定できるようになりました。
// 1.0.0 2016/07/06 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc 戦闘行動結果ポップアッププラグイン
 * @author トリアコンタン
 *
 * @param メッセージウェイト
 * @desc ポップアップメッセージが重なったときに次のメッセージが表示されるまでのウェイトフレーム数です。
 * @default 16
 * @type number
 *
 * @param クリティカル
 * @desc クリティカル発生時のポップアップメッセージまたはファイル名です。(img/pictures/)拡張子不要
 * @default CRITICAL!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param クリティカルカラー
 * @desc クリティカル発生時の文字のフラッシュ色です。R(赤),G(緑),B(青),A(強さ)の順番でカンマ(,)区切りで指定。
 * @default 255,0,0,255
 *
 * @param 回避
 * @desc 回避発生時のポップアップメッセージまたはファイル名です。
 * @default Avoid!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 回避カラー
 * @desc 回避発生時の文字のフラッシュ色です。
 * @default 0,128,255,255
 *
 * @param ミス
 * @desc ミス発生時のポップアップメッセージまたはファイル名です。通常のMissは表示されなくなります。
 * @default Miss!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param ミスカラー
 * @desc ミス発生時の文字のフラッシュ色です。
 * @default 0,0,0,0
 *
 * @param 無効
 * @desc 行動が無効（行動は成功したが有効な効果がなかった）だった時のポップアップメッセージまたはファイル名です。
 * @default Invalid!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 無効カラー
 * @desc 無効発生時の文字のフラッシュ色です。
 * @default 0,0,0,0
 *
 * @param ガード
 * @desc 行動がガード（行動は成功したが相手の耐性によって完全に防がれた）された時のポップアップメッセージまたはファイル名です。
 * @default Guard!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param ガードカラー
 * @desc ガード発生時の文字のフラッシュ色です。
 * @default 0,128,255,255
 *
 * @param 魔法反射
 * @desc 魔法反射時のポップアップメッセージまたはファイル名です。
 * @default Reflection!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 魔法反射カラー
 * @desc 魔法反射発生時の文字のフラッシュ色です。
 * @default 0,128,255,255
 *
 * @param 反撃
 * @desc 反撃時のポップアップメッセージまたはファイル名です。
 * @default Counter!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 反撃カラー
 * @desc 反撃発生時の文字のフラッシュ色です。
 * @default 0,128,255,255
 *
 * @param 弱点
 * @desc 弱点時のポップアップメッセージまたはファイル名です。
 * @default Weakness!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 弱点カラー
 * @desc 弱点発生時の文字のフラッシュ色です。
 * @default 0,255,128,255
 *
 * @param 弱点閾値
 * @desc この値以上なら弱点と見なします。百分率で指定します。
 * @default 200
 *
 * @param 耐性
 * @desc 弱点時のポップアップメッセージまたはファイル名です。
 * @default Resistance!
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 耐性カラー
 * @desc 耐性発生時の文字のフラッシュ色です。
 * @default 0,0,128,255
 *
 * @param 耐性閾値
 * @desc この値以下なら耐性と見なします。百分率で指定します。
 * @default 50
 *
 * @param 味方ダメージカラー
 * @desc アクターダメージのフラッシュ色です。
 * @default 0,0,0,0
 *
 * @param 敵ダメージカラー
 * @desc 敵キャラダメージのフラッシュ色です。
 * @default 0,0,0,0
 *
 * @param フォントサイズ
 * @desc ポップアップのフォントサイズです。
 * @default 42
 *
 * @param メッセージ最大幅
 * @desc ポップアップメッセージの最大幅です。
 * @default 240
 *
 * @param フラッシュ時間
 * @desc フラッシュカラーがフェードアウトするまでのフレーム数です。
 * @default 60
 *
 * @param X座標補正
 * @desc X座標の補正値です。
 * @default 0
 *
 * @param Y座標補正
 * @desc Y座標の補正値です。
 * @default -40
 *
 * @param イタリック表示
 * @desc ポップアップがイタリック体で表示されます。
 * @default false
 * @type boolean
 *
 * @param 縁取り表示
 * @desc ポップアップが縁取り表示されます。
 * @default false
 * @type boolean
 *
 * @param 画像使用
 * @desc 各種ポップアップに任意のピクチャ(img/pictures)を使用します。メッセージの代わりにファイル名を入力してください。
 * @default false
 * @type boolean
 *
 * @noteParam BEPメッセージ
 * @noteRequire 1
 * @noteDir img/pictures/
 * @noteType file
 * @noteData items
 *
 * @help 戦闘中に行動の結果のメッセージをポップアップします。
 * ポップアップするのは動的に作成した文字列もしくは用意したピクチャです。
 * 表示条件は以下の通りです。
 *
 * ・失敗（通常のMissは表示されなくなります）
 * ・回避（通常のMissは表示されなくなります）
 * ・無効（行動は成功したが有効な効果がなかった）
 * ・ガード（行動は成功したが相手の耐性によって完全に防がれた）
 * ・クリティカル
 * ・反撃
 * ・魔法反射
 * ・弱点（ダメージ倍率が1.0を上回った場合）
 * ・耐性（ダメージ倍率が1.0を下回った場合）
 * ・ステート付与（ステートごとに設定できます）
 * ・コモンイベント（プラグインコマンドから実行します）
 *
 * ※ガードが表示されるのは、ステート有効度もしくは属性有効度が0%の効果が
 * 存在し、かつ他に有効な効果がない場合です。
 * なお、「ステート無効化」で防がれた場合は表示されません。
 *
 * また、ポップアップ時にフラッシュカラーを指定することができます。
 * フラッシュカラーの指定は「赤」「緑」「青」「強さ」の順番で
 * カンマ区切りで指定してください。
 *
 * ステート付与時にメッセージをポップアップをしたい場合
 * ステートのメモ欄に以下の通り指定してください。
 * <BEPメッセージ:state>       # 付加時にメッセージ「state」が表示されます。
 *                             # 画像使用が有効な場合はファイル名を指定します。
 * <BEPカラー:255,255,255,255> # 付加時のフラッシュカラーを指定します。
 *
 * さらに、プラグインコマンドから任意の文字列を自由にポップアップできます。
 * このコマンドはバトルイベントのみ使用可能です。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * BEP対象者ポップアップ message 255,0,0,255 # 行動の対象者にmessageがポップ。
 * BEP_TARGET_POPUP message 255,0,0,255      # 上と同じ
 *
 * BEP使用者ポップアップ message 255,0,0,255 # 行動の使用者にmessageがポップ。
 * BEP_USER_POPUP message 255,0,0,255        # 上と同じ
 *
 * ※画像使用が有効な場合はファイル名を指定します。
 *
 * 競合に関する情報
 * 当プラグインは以下のプラグインより下に配置してください。
 *
 * YEP_BattleEngineCore.js
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function() {
    'use strict';
    var pluginName    = 'BattleEffectPopup';
    var metaTagPrefix = 'BEP';

    var getCommandName = function(command) {
        return (command || '').toUpperCase();
    };

    var getParamOther = function(paramNames) {
        if (!Array.isArray(paramNames)) paramNames = [paramNames];
        for (var i = 0; i < paramNames.length; i++) {
            var name = PluginManager.parameters(pluginName)[paramNames[i]];
            if (name) return name;
        }
        return null;
    };

    var getParamString = function(paramNames) {
        var value = getParamOther(paramNames);
        return value === null ? '' : value;
    };

    var getParamBoolean = function(paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON' || (value || '').toUpperCase() === 'TRUE';
    };

    var getParamNumber = function(paramNames, min, max) {
        var value = getParamOther(paramNames);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        return (parseInt(value, 10) || 0).clamp(min, max);
    };

    var getParamArrayString = function(paramNames) {
        var values = getParamString(paramNames).split(',');
        for (var i = 0; i < values.length; i++) values[i] = values[i].trim();
        return values;
    };

    var getParamArrayNumber = function(paramNames, min, max) {
        var values = getParamArrayString(paramNames);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        for (var i = 0; i < values.length; i++) {
            if (!isNaN(parseInt(values[i], 10))) {
                values[i] = (parseInt(values[i], 10) || 0).clamp(min, max);
            } else {
                values.splice(i--, 1);
            }
        }
        return values;
    };

    var getArgString = function(arg, upperFlg) {
        arg = convertEscapeCharacters(arg);
        return upperFlg ? arg.toUpperCase() : arg;
    };

    var getArgArrayNumber = function(args, min, max) {
        var values = getArgArrayString(args, false);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        for (var i = 0; i < values.length; i++) values[i] = (parseInt(values[i], 10) || 0).clamp(min, max);
        return values;
    };

    var getArgArrayString = function(args, upperFlg) {
        var values = getArgString(args, upperFlg).split(',');
        for (var i = 0; i < values.length; i++) values[i] = values[i].trim();
        return values;
    };

    var convertEscapeCharacters = function(text) {
        if (text == null) text = '';
        var windowLayer = SceneManager._scene._windowLayer;
        return windowLayer ? windowLayer.children[0].convertEscapeCharacters(text) : text;
    };

    var getMetaValue = function(object, name) {
        var metaTagName = metaTagPrefix + (name ? name : '');
        return object.meta.hasOwnProperty(metaTagName) ? object.meta[metaTagName] : undefined;
    };

    var getMetaValues = function(object, names) {
        if (!Array.isArray(names)) return getMetaValue(object, names);
        for (var i = 0, n = names.length; i < n; i++) {
            var value = getMetaValue(object, names[i]);
            if (value !== undefined) return value;
        }
        return undefined;
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramCritical         = getParamString(['Critical', 'クリティカル']);
    var paramCriticalColor    = getParamArrayNumber(['CriticalColor', 'クリティカルカラー'], 0, 256);
    var paramAvoid            = getParamString(['Avoid', '回避']);
    var paramAvoidColor       = getParamArrayNumber(['AvoidColor', '回避カラー'], 0, 256);
    var paramMiss             = getParamString(['Miss', 'ミス']);
    var paramMissColor        = getParamArrayNumber(['MissColor', 'ミスカラー'], 0, 256);
    var paramInvalid          = getParamString(['Invalid', '無効']);
    var paramInvalidColor     = getParamArrayNumber(['InvalidColor', '無効カラー'], 0, 256);
    var paramGuard            = getParamString(['Guard', 'ガード']);
    var paramGuardColor       = getParamArrayNumber(['GuardColor', 'ガードカラー'], 0, 256);
    var paramReflection       = getParamString(['Reflection', '魔法反射']);
    var paramReflectionColor  = getParamArrayNumber(['ReflectionColor', '魔法反射カラー'], 0, 256);
    var paramCounter          = getParamString(['Counter', '反撃']);
    var paramCounterColor     = getParamArrayNumber(['CounterColor', '反撃カラー'], 0, 256);
    var paramWeakness         = getParamString(['Weakness', '弱点']);
    var paramWeaknessColor    = getParamArrayNumber(['WeaknessColor', '弱点カラー'], 0, 256);
    var paramWeaknessLine     = getParamNumber(['WeaknessLine', '弱点閾値']);
    var paramResistance       = getParamString(['Resistance', '耐性']);
    var paramResistanceLine   = getParamNumber(['ResistanceLine', '耐性閾値']);
    var paramResistanceColor  = getParamArrayNumber(['ResistanceColor', '耐性カラー'], 0, 256);
    var paramActorDamageColor = getParamArrayNumber(['ActorDamageColor', '味方ダメージカラー'], 0, 256);
    var paramEnemyDamageColor = getParamArrayNumber(['EnemyDamageColor', '敵ダメージカラー'], 0, 256);
    var paramFontSize         = getParamNumber(['FontSize', 'フォントサイズ'], 16, 128);
    var paramMaxWidth         = getParamNumber(['MaxWidth', 'メッセージ最大幅'], 1);
    var paramFlashDuration    = getParamNumber(['FlashDuration', 'フラッシュ時間'], 1);
    var paramOffsetX          = getParamNumber(['OffsetX', 'X座標補正']);
    var paramOffsetY          = getParamNumber(['OffsetY', 'Y座標補正']);
    var paramUsingPicture     = getParamBoolean(['UsingPicture', '画像使用']);
    var paramUsingItalic      = getParamBoolean(['UsingItalic', 'イタリック表示']);
    var paramUsingOutline     = getParamBoolean(['UsingOutline', '縁取り表示']);
    var paramMessageWait      = getParamNumber(['MessageWait', 'メッセージウェイト']);

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand      = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        if (!command.match(new RegExp('^' + metaTagPrefix))) return;
        this.pluginCommandBattleEffectPopup(command.replace(metaTagPrefix, ''), args);
    };

    Game_Interpreter.prototype.pluginCommandBattleEffectPopup = function(command, args) {
        switch (getCommandName(command)) {
            case '使用者ポップアップ' :
            case '_USER_POPUP':
            	if(BattleManager._subject==null){BattleManager._subject = $gameTroop.members()[0]}
                BattleManager._subject.startMessagePopup(getArgString(args[0]), getArgArrayNumber(args[1], 0, 256));
                break;
            case '対象者ポップアップ' :
            case '_TARGET_POPUP':
                var action = BattleManager._action;
                var unit   = action.isForOpponent() ? action.opponentsUnit() : action.friendsUnit();
                if(BattleManager._subject._lastTargetIndex == null){
                	var index  = $gameTroop.members()[0];
                }else{
                	var index  = BattleManager._subject._lastTargetIndex;
                }
                var target = unit.members()[index];
                if (target) {
                    target.startMessagePopup(getArgString(args[0]), getArgArrayNumber(args[1], 0, 256));
                } else {
                    console.error('対象者ポップアップのターゲットが見付かりませんでした。index : ' + index);
                    console.error(unit.members());
                }
                break;
        }
    };

    //=============================================================================
    // Game_Action
    //  弱点によってポップアップを設定します。
    //=============================================================================
    var _Game_Action_calcElementRate      = Game_Action.prototype.calcElementRate;
    Game_Action.prototype.calcElementRate = function(target) {
        var result = _Game_Action_calcElementRate.apply(this, arguments);
        if (BattleManager.isInputting()) return result;
        if (result === 0) {
            target.appointMessagePopup(paramGuard, paramGuardColor);
        } else if (result >= paramWeaknessLine / 100) {
            //target.appointMessagePopup(paramWeakness, paramWeaknessColor);
        } else if (result <= paramResistanceLine / 100) {
            //target.appointMessagePopup(paramResistance, paramResistanceColor);
        }
        return result;
    };

    //=============================================================================
    // Game_Battler
    //  ポップアップメッセージのリクエストに応答します。
    //=============================================================================
    Game_Battler.prototype.clearMessagePopup = function() {
        this._messagePopup = false;
    };

    Game_Battler.prototype.isMessagePopupRequested = function() {
        return this._messagePopup;
    };

    Game_Battler.prototype.startMessagePopup = function(message, flashColor) {
        if (message) {
            this._messagePopup = true;
            this._message      = message;
            this._flashColor   = flashColor;
        }
    };

    Game_Battler.prototype.startAppointMessagePopup = function() {
        this.startMessagePopup(this._appointMessage, this._appointFlashColor);
        this._appointMessage    = '';
        this._appointFlashColor = null;
    };

    Game_Battler.prototype.appointMessagePopup = function(message, flashColor) {
        this._appointMessage    = message;
        this._appointFlashColor = flashColor;
    };

    Game_Battler.prototype.getMessagePopupText = function() {
        return this._message;
    };

    Game_Battler.prototype.hasAppointMessage = function() {
        return !!this._appointMessage;
    };

    Game_Battler.prototype.getMessagePopupFlashColor = function() {
        return this._flashColor;
    };

    var _Game_Battler_stateRate = Game_Battler.prototype.stateRate;
    Game_Battler.prototype.stateRate = function(stateId) {
        var rate = _Game_Battler_stateRate.apply(this, arguments);
        if (rate === 0) {
            this.result().guarded = true;
        }
        return rate;
    };

    //=============================================================================
    // Game_ActionResult
    //  行動が無効だったかどうかを返します。
    //=============================================================================
    var _Game_ActionResult_clear = Game_ActionResult.prototype.clear;
    Game_ActionResult.prototype.clear = function() {
        _Game_ActionResult_clear.apply(this, arguments);
        this.guarded = false;
    };

    Game_ActionResult.prototype.isInvalid = function() {
        return !this.success && !this.missed && !this.evaded && !$gameTemp.isCommonEventReserved();
    };

    Game_ActionResult.prototype.isGuarded = function() {
        return this.guarded && this.isInvalid();
    };

    //=============================================================================
    // Window_BattleLog
    //  ポップアップメッセージをリクエストします。
    //=============================================================================
    Window_BattleLog.prototype.popupMessage = function(target, message, flashColor) {
        target.startMessagePopup(message, flashColor);
    };

    Window_BattleLog.prototype.popupAppointMessage = function(target) {
        target.startAppointMessagePopup();
    };

    var _Window_BattleLog_displayDamage      = Window_BattleLog.prototype.displayDamage;
    Window_BattleLog.prototype.displayDamage = function(target) {
        _Window_BattleLog_displayDamage.apply(this, arguments);
        if (target.result().isGuarded()) {
            this.pushPopupMessage(target, paramGuard, paramGuardColor);
        } else if (target.result().isInvalid()) {
            this.pushPopupMessage(target, paramInvalid, paramInvalidColor);
        }
        if (target.hasAppointMessage()) {
            this.pushPopupAppointMessage(target);
        }
    };

    var _Window_BattleLog_displayCritical      = Window_BattleLog.prototype.displayCritical;
    Window_BattleLog.prototype.displayCritical = function(target) {
        _Window_BattleLog_displayCritical.apply(this, arguments);
        if (target.result().critical) {
            this.pushPopupMessage(target, paramCritical, paramCriticalColor);
        }
    };

    var _Window_BattleLog_displayMiss      = Window_BattleLog.prototype.displayMiss;
    Window_BattleLog.prototype.displayMiss = function(target) {
        _Window_BattleLog_displayMiss.apply(this, arguments);
        this.popupMiss(target);
    };

    Window_BattleLog.prototype.popupMiss = function(target) {
        this.pushPopupMessage(target, paramMiss, paramMissColor);
    };

    var _Window_BattleLog_displayEvasion      = Window_BattleLog.prototype.displayEvasion;
    Window_BattleLog.prototype.displayEvasion = function(target) {
        _Window_BattleLog_displayEvasion.apply(this, arguments);
        this.popupEvasion(target);
    };

    Window_BattleLog.prototype.popupEvasion = function(target) {
        this.pushPopupMessage(target, paramAvoid, paramAvoidColor);
    };

    var _Window_BattleLog_displayCounter      = Window_BattleLog.prototype.displayCounter;
    Window_BattleLog.prototype.displayCounter = function(target) {
        _Window_BattleLog_displayCounter.apply(this, arguments);
        this.popupCounter(target);
    };

    Window_BattleLog.prototype.popupCounter = function(target) {
        this.pushPopupMessage(target, paramCounter, paramCounterColor);
    };

    var _Window_BattleLog_displayReflection      = Window_BattleLog.prototype.displayReflection;
    Window_BattleLog.prototype.displayReflection = function(target) {
        _Window_BattleLog_displayReflection.apply(this, arguments);
        this.popupReflection(target);
    };

    Window_BattleLog.prototype.popupReflection = function(target) {
        this.pushPopupMessage(target, paramReflection, paramReflectionColor);
    };

    var _Window_BattleLog_displayAddedStates      = Window_BattleLog.prototype.displayAddedStates;
    Window_BattleLog.prototype.displayAddedStates = function(target) {
        _Window_BattleLog_displayAddedStates.apply(this, arguments);
        target.result().addedStateObjects().forEach(function(state) {
            var message = getMetaValues(state, ['Message', 'メッセージ']);
            if (message) {
                var flash = getMetaValues(state, ['FlashColor', 'カラー']);
                if (flash) flash = getArgArrayNumber(flash, 0, 256);
                this.pushPopupMessage(target, getArgString(message), flash);
            }
        }, this);
    };

    Window_BattleLog.prototype.pushPopupMessage = function(target, message, flashColor) {
        if (this.hasPopupMessage()) {
            this.push('waitForPopup');
        }
        this.push('popupMessage', target, message, flashColor);
    };

    Window_BattleLog.prototype.pushPopupAppointMessage = function(target) {
        if (this.hasPopupMessage()) {
            this.push('waitForPopup');
        }
        this.push('popupAppointMessage', target);
    };

    Window_BattleLog.prototype.hasPopupMessage = function() {
        return this._methods.some(function(method) {
            return method.name === 'popupMessage' || method.name === 'popupAppointMessage';
        });
    };

    Window_BattleLog.prototype.waitForPopup = function() {
        this._waitCount = paramMessageWait || 0;
    };

    //=============================================================================
    // Sprite_Battler
    //  ポップアップメッセージを作成します。
    //=============================================================================
    var _Sprite_Battler_updateDamagePopup      = Sprite_Battler.prototype.updateDamagePopup;
    Sprite_Battler.prototype.updateDamagePopup = function() {
        this.setupMessagePopup();
        _Sprite_Battler_updateDamagePopup.apply(this, arguments);
    };

    var _Sprite_Battler_pushDamageSprite = Sprite_Battler.prototype.pushDamageSprite;
    Sprite_Battler.prototype.pushDamageSprite = function(sprite) {
        var damage = this._damages;
        this._damages = this._damages.filter(function(sprite) {
            return !sprite.isMessage();
        });
        _Sprite_Battler_pushDamageSprite.apply(this, arguments);
        damage.push(sprite);
        this._damages = damage;
    };

    Sprite_Battler.prototype.setupMessagePopup = function() {
        if (this._battler.isMessagePopupRequested()) {
            // Resolve conflict for MOG_BattleHud.js
            if (this._battler.isSpriteVisible() || this._sprite_face) {
                var sprite = new Sprite_PopupMessage();
                sprite.x   = 830+ this.messageOffsetX()+$gameVariables.value(84);
                sprite.y   = 400 + this.messageOffsetY()+$gameVariables.value(85);
                sprite.setup(this._battler);
                if (!sprite.z) {
                    this.setZPositionOfPopup(sprite);
                }
                this._damages.push(sprite);
                this.parent.addChild(sprite);
            }
            this._battler.clearMessagePopup();
        }
    };

    Sprite_Battler.prototype.setZPositionOfPopup = function(sprite) {
        if (this.z > 0) sprite.z = this.z + 10;
        if (this._mainSprite && this._mainSprite.z > 0) sprite.z = this._mainSprite.z + 10;
    };

    Sprite_Battler.prototype.messageOffsetX = function() {
        return paramOffsetX;
    };

    Sprite_Battler.prototype.messageOffsetY = function() {
        return paramOffsetY;
    };

    //=============================================================================
    // Sprite_Damage
    //  回避メッセージが有効な場合のミス表示を抑制します。
    //=============================================================================
    var _Sprite_Damage_setup      = Sprite_Damage.prototype.setup;
    Sprite_Damage.prototype.setup = function(target) {
        // for YEP_BattleEngineCore.js
        var result = target.shiftDamagePopup ? target.shiftDamagePopup() : target.result();
        if ((!result.evaded || !paramAvoid) && (!result.missed || !paramMiss)) {
            if (target.shiftDamagePopup) {
                target._damagePopup.unshift(result);
            }
            _Sprite_Damage_setup.apply(this, arguments);
        }
        this.setupFlash(result, target);
    };

    Sprite_Damage.prototype.setupFlash = function(result, target) {
        if (!result.missed && !result.evaded && result.hpAffected) {
            var color = target instanceof Game_Actor ? paramActorDamageColor : paramEnemyDamageColor;
            if (color && color.length > 0) this.setupFlashEffect(color);
        }
    };

    Sprite_Damage.prototype.setupFlashEffect = function(flashColor, duration) {
        this._flashColor    = flashColor.clone();
        this._flashDuration = duration || paramFlashDuration;
    };

    Sprite_Damage.prototype.isMessage = function() {
        return false;
    };

    //=============================================================================
    // Sprite_PopupMessage
    //  ポップアップメッセージを表示するスプライトです。
    //=============================================================================
    function Sprite_PopupMessage() {
        this.initialize.apply(this, arguments);
    }

    Sprite_PopupMessage.prototype             = Object.create(Sprite_Damage.prototype);
    Sprite_PopupMessage.prototype.constructor = Sprite_PopupMessage;

    Sprite_PopupMessage.prototype.setup = function(target) {
        var text       = target.getMessagePopupText();
        var bitmap     = target._message.includes("[Battle]") ? this.setupStaticText(text) : this.setupDynamicText(text);
        var sprite     = this.createChildSprite();
        sprite.bitmap  = bitmap;
        sprite.dy      = 0;
        //var flashColor = target.getMessagePopupFlashColor();
        // if (flashColor) {
            //this.setupFlashEffect(flashColor);
        // }
        // Resolve conflict for KMS_SomStyleDamage.js
        if (this.setupSomStyleDamageParameter) {
            this.setupSomStyleDamageParameter();
        }
    };

    Sprite_PopupMessage.prototype.setupDynamicText = function(text) {
        var bitmap      = new Bitmap(paramMaxWidth, paramFontSize + 8);
        bitmap.fontSize = paramFontSize;
        //if (paramUsingItalic) {
        //    bitmap.fontItalic = true;
        //}
        //if (paramUsingOutline) {
            bitmap.outlineWidth = Math.floor(bitmap.fontSize / 6);
            bitmap.outlineColor = '#ff788c';
        //}
        bitmap.drawText(text, 0, 0, bitmap.width, bitmap.height, 'center');
        return bitmap;
    };

    Sprite_PopupMessage.prototype.setupStaticText = function(textPicture) {
        return ImageManager.loadPicture(textPicture, 0);
    };

    Sprite_PopupMessage.prototype.isMessage = function() {
        return true;
    };

    // for YEP_X_ActSeqPack1.js
    var _BattleManager_actionAddState = BattleManager.actionAddState;
    BattleManager.actionAddState = function(actionName, actionArgs) {
        var targets = this.makeActionTargets(actionArgs[0]);
        if (targets) {
            targets.forEach(function(target) {
                target.result().used = true;
                target.result().success = true;
            });
        }
        return _BattleManager_actionAddState.apply(this, arguments);
    };
})();


code:
//
//  ○○の知識 ver1.02
//
// author yana
//

var Imported = Imported || {};
Imported['BattleKnowledge'] = 1.02;

/*:
 * @plugindesc ver1.02/ダメージに補正を与える色々な機能を追加します。
 * @author Yana
 *
 * @help------------------------------------------------------
 *  プラグインコマンドはありません。
 * ------------------------------------------------------
 * ------------------------------------------------------
 * 設定方法
 * ------------------------------------------------------
 * 特徴を持ったオブジェクト(アクター、クラス、武器、防具、エネミー、ステート等)のメモ欄に以下の記述をすることで、
 * 特定の行動の効果量を補正する効果を得ることができるようになります。
 * これらの補正値はダメージ計算式に掛かります。
 *
 * ・命中タイプが物理の行動の威力をx%増加する。
 * <武道の知識:+x%>
 *
 * ・命中タイプが魔法の行動の威力をx%増加する。
 * <魔道の知識:+x%>
 *
 * ・ダメージタイプがHP回復、MP回復の行動の効果をx%増加する。
 * <治癒の知識:+x%>
 *
 * ・アイテムによるダメージ計算式の効果をx%増加する。
 * <道具の知識:+x%>
 *
 * ・クリティカル発生時に効果をx%増加する。
 * <クリティカルの知識:+x%>
 * <会心の知識:+x%>
 * <痛撃の知識:+x%>
 *
 * ・装備している武器タイプが○○の時に効果をx%増加する。
 * <○○の知識:+x%>
 *
 * ・行動の属性が○○の時に効果をx%増加する。
 * <○○の知識:+x%>
 *
 * ・メモにxxxを含むアイテムやスキルを使用した時の効果をy%増加する。
 * <xxxの知識:+y%>
 *
 * また、これらは同じものが複数ある場合、数値は合算されて計算されます。
 * 武道の知識20%と武道の知識30%を持っている場合、、+50%となります。
 *
 * ConditionallyCoreと同時に導入されている場合、発動条件と発動確率を設定することができます。
 * <xxxの知識:+y%,z%>
 * 発動条件
 * </xxxの知識>
 * と記述すると、xxxの知識の効果がz%の確率で+y%増加します。
 * xxxは上記で記述のある武道、魔道、治癒、道具、クリティカルなどになります。
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.02:
 * 武器タイプで効果を発揮する知識が物理攻撃以外にも発生していたバグを修正
 * ver1.01:
 * 武器タイプで効果を発揮する知識の設定を追加
 * 行動の属性で効果を発揮する知識の設定を追加
 * ver1.00:
 * 公開
 */

(function() {

	var parameters = PluginManager.parameters('BattleKnowledge');

	function BattleKnowledgeManager() {
    	throw new Error('This is a static class');
	};

	BattleKnowledgeManager.initCond = function(note){
		var texts = note.split('\n');
		var flag = false;
		var knowledge = {}
		var type = null;
		for(var i=0;i<texts.length;i++){
			if (Imported['ConditionallyCore']){
				if (flag){
					if (texts[i].match(/^<\/(.+)の知識>/)){
						if (type !== RegExp.$1){ type = null }
						type = this.setType(type);
						if (type) {
							if (!knowledge[type]) { knowledge[type] = [] }
							knowledge[type].push(effect);
						}
						flag = false;
					}else{
						effect['conditions'].push(ConditionallyManager.makeCondition(texts[i]));
					}
					continue;
				}else if (texts[i].match(/^<(.+)の知識:([+-]?\d+)[%％],(\d+)[%％]>/)){
					type = RegExp.$1;
					var effect = {
						'value':Number(RegExp.$2)/100,
						'rate':Number(RegExp.$3)/100,
						'conditions':[]
						};
					flag = true;
					continue;
				}
			}
			if (texts[i].match(/^<(.+)の知識:([+-]?\d+)[%％]>/)){
				type = RegExp.$1;
				var num = Number(RegExp.$2)/100;
				var effect = {'value':num,'rate':1,'conditions':[]}
				type = this.setType(type);
				if (type) {
					if (!knowledge[type]) { knowledge[type] = [] }
					knowledge[type].push(effect);
				}
			}
		}
		return knowledge;
	};

	BattleKnowledgeManager.setType = function(type) {
		switch (type){
		case '武道':
			type = 'physical';
			break;
		case '魔道':
			type = 'magical';
			break;
		case '治癒':
			type = 'heal';
			break;
		case '道具':
			type = 'item';
			break;
		case '痛撃':
		case 'クリティカル':
		case '会心':
			type = 'critical';
			break;
		}
		return type;
	};

	BattleKnowledgeManager.initialize = function(obj) {
		if (!obj._knowledge) {
			obj._knowledge = this.initCond(obj.note);
		}
	};

	BattleKnowledgeManager.multipleValue = function(obj,item,target,subject,critical) {
		this.initialize(obj);
		var value = 1.0;
		for(key in obj._knowledge){
			value += this.checkEnableValue(key,obj,item,target,subject,critical);
		}
		return value;
	};

	BattleKnowledgeManager.checkEnableValue = function(type, obj, item, target, subject, critical) {
		var result = 0;
		var flag = false;
		for (var i=0;i<obj._knowledge[type].length;i++){
			var k = obj._knowledge[type][i];
			if (k){
				var value = k['value'];
				switch(type){
				case 'physical':
					flag = item.hitType === Game_Action.HITTYPE_PHYSICAL;
					break;
				case 'magical':
					flag = item.hitType === Game_Action.HITTYPE_MAGICAL;
					break
				case 'heal':
					flag = [3,4].contains(item.damage.type);
					break;
				case 'item':
					flag = DataManager.isItem(item);
					break;
				case 'critical':
					flag = critical;
					break;
				default:
					if ($dataSystem.weaponTypes.contains(type)){
						var id = $dataSystem.weaponTypes.indexOf(type);
						flag = subject.isWtypeEquipped(id) && item.hitType === Game_Action.HITTYPE_PHYSICAL;
					} else if ($dataSystem.elements.contains(type)){
						var id = $dataSystem.elements.indexOf(type);
						if (item.damage.elementId < 0){
							flag = subject.attackElements().contains(id);
						}else{
							flag = item.damage.elementId === id;
						}
					} else {
						flag = this.isCheckIncludeKey(item,type);
					}
				}
				if (flag) {
					if (Imported['ConditionallyCore']){
						if (Math.random() < k['rate']){
							var dieStatus = {
								'turn':BattleManager.ccTurnCount(),
								'finisher':subject,
								'item':item,
								'damage':0,
								'state':target._states,
								'fState':subject._states
							}
							if (ConditionallyManager.checkConditions(subject,target,k['conditions'],dieStatus)){
								result += value;
							}
						}
					}else{
						result += value;
					}
				}
			}
		}
		return result;
	};

	BattleKnowledgeManager.isCheckIncludeKey = function(item,type) {
		if (!item._knType){ item._knType = {} }
		if (item._knType[type]) { return true }
		var texts = item.note.split('/n');
		for(var i=0;i<texts.length;i++) {
			if (!!texts[i].match(RegExp(type))){
				item._knType[type] = true;
				return true;
			}
		}
		return false;
	};

	var _GAction_makeDamageValue = Game_Action.prototype.makeDamageValue;
	Game_Action.prototype.makeDamageValue = function(target, critical) {
		var result = _GAction_makeDamageValue.call(this,target,critical);
		var subject = this.subject();
		var addValue = 0;
		var multipleValue = 1.0;
		var item = this.item();
		subject.traitObjects().forEach(function(obj){
			if (obj) {
				multipleValue *= BattleKnowledgeManager.multipleValue(obj,item,target,subject,critical);
			}
		});
		result *= multipleValue;
		return Math.floor(result);
    };
}());

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// - BattleParallelEvent
// BattleParallelEvent.js
//=============================================================================

//=============================================================================
 /*:
 * @plugindesc 戦闘中でも「並列処理」のコモンイベントを実行する為のプラグインです。
 * @author 名無し蛙
 *
 *
 * Version 1.0:
 * 2016/06/29 - リリース
 */
//=============================================================================

(function() {
    //
    var _Game_Switches_onChange = Game_Switches.prototype.onChange;
    Game_Switches.prototype.onChange = function() {
        _Game_Switches_onChange.call(this);
        if ($gameParty.inBattle()) {
            $gameTroop.refreshCommonEvents();
        }
    };

    //
    var _Game_Troop_setup = Game_Troop.prototype.setup;
    Game_Troop.prototype.setup = function(troopId) {
        _Game_Troop_setup.call(this, troopId);
        this._commonEvents = this.parallelCommonEvents().map(function(commonEvent) {
            return new Game_CommonEvent(commonEvent.id);
        });
    };

    //
    Game_Troop.prototype.parallelCommonEvents = function() {
        return $dataCommonEvents.filter(function(commonEvent) {
            return commonEvent && commonEvent.trigger === 2;
        });
    };

    //
    Game_Troop.prototype.refreshCommonEvents = function() {
        this._commonEvents.forEach(function(event) {
            event.refresh();
        });
    };

    //
    Game_Troop.prototype.updateCommonEvents = function() {
        this._commonEvents.forEach(function(event) {
            event.update();
        });
    };

    //
    var _Scene_Battle_update = Scene_Battle.prototype.update;
    Scene_Battle.prototype.update = function() {
        $gameTroop.updateCommonEvents();
        _Scene_Battle_update.call(this);
    };
}());

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


code:
//=============================================================================
// BattleRecord.js
// ----------------------------------------------------------------------------
// (C)2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.3.1 2021/03/26 ヘルプの誤記を修正
// 1.3.0 2021/03/03 1行動ごとの最大与ダメージを記録する変数を追加
// 1.2.2 2018/04/30 ゴールドの増減について所持ゴールドを以上の額を減算したときの消費量が誤っていた問題を修正
// 1.2.1 2017/05/20 プラグイン未適用のデータをロードしたときに一部のスクリプトが実行エラーになる問題を修正
// 1.2.0 2016/12/25 アイテムの売買履歴を保持して取得できる機能を追加
// 1.1.3 2016/12/05 装備変更時に装備品の入手数がカウントアップされていた不具合を修正
// 1.1.2 2016/09/04 1.1.1の修正に一部不足があったものを追加修正
// 1.1.1 2016/09/02 プラグイン未適用のデータをロード後に攻撃かアイテム入手すると強制終了する問題を修正
// 1.1.0 2016/08/27 取得可能な項目を大幅に増やしました。
//                  アクター全員の合計値を容易に取得できるようにしました。
// 1.0.0 2016/08/25 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc Battle Record Plugin
 * @author triacontane
 *
 * @help Recording resource in battle.
 *
 * アクターごとに以下の要素を記録できます。
 *
 * ・スキルごとの使用回数(戦闘中のみカウント。他項目も同様)
 * ・全スキルの使用回数合計
 * ・アイテムごとの使用回数
 * ・全アイテムの使用回数合計
 * ・敵キャラごとの撃破回数
 * ・全敵キャラの撃破回数合計
 * ・与えたダメージの合計
 * ・与えたダメージの最大
 * ・受けたダメージの合計
 * ・受けたダメージの最大
 * ・回復したダメージの合計
 * ・消費したMP合計
 * ・消費したTP合計
 * ・戦闘不能回数
 *
 * 値はイベントコマンド「変数の操作」から「スクリプト」で
 * 対応するスクリプトを呼び出して取得してください。
 *
 * ・データベースのアクターIDから取得する場合
 * $gameActors.actor(1).getSkillUseCounter(2);   # アクター[1]のスキル[2]使用回数
 * $gameActors.actor(1).getAllSkillUseCounter(); # アクター[1]の全スキル使用回数
 * $gameActors.actor(1).getItemUseCounter(3);    # アクター[1]のアイテム[3]使用回数
 * $gameActors.actor(1).getAllItemUseCounter();  # アクター[1]の全アイテム使用回数
 * $gameActors.actor(1).getKillEnemyCounter(4);  # アクター[1]の敵キャラ[4]撃破数
 * $gameActors.actor(1).getAllKillEnemyCounter();# アクター[1]の全敵キャラ撃破数
 * $gameActors.actor(1).attackDamageMax;         # アクター[1]の最大与ダメージ
 * $gameActors.actor(1).attackDamageSum;         # アクター[1]の合計与ダメージ
 * $gameActors.actor(1).acceptDamageMax;         # アクター[1]の最大被ダメージ
 * $gameActors.actor(1).acceptDamageSum;         # アクター[1]の合計被ダメージ
 * $gameActors.actor(1).recoverDamageSum;        # アクター[1]の合計回復ダメージ
 * $gameActors.actor(1).payCostMpSum;            # アクター[1]の消費MP合計
 * $gameActors.actor(1).payCostTpSum;            # アクター[1]の消費TP合計
 * $gameActors.actor(1).deadCounter;             # アクター[1]の戦闘不能回数
 *
 * ・パーティの並び順(先頭は0)から取得する場合
 * $gameActors.actor(n)を$gameParty.members()[n]に置き換えて実行する。
 * (例)
 * $gameParty.members()[0].attackDamageMax;      # 先頭メンバーの最大与ダメージ
 *
 * ・スキルのダメージ計算式で使用する場合
 * $gameActors.actor(n)をa(実行者)もしくはb(対象者)に置き換えて実行する。
 * (例)
 * a.getSkillUseCounter(5);  # 実行者のスキル[5]使用回数
 * b.getKillEnemyCounter(6); # 対象者の敵キャラ[6]撃破数
 *
 * ・すべてのアクターの合計値を取得する場合
 * $gameActors.actor(n)を$gameActorsに置き換えて実行する。
 * (例)
 * $gameActors.getKillEnemyCounter(4); # 全アクターの敵キャラ[4]撃破数合計
 * $gameActors.getAllItemUseCounter(); # 全アクターの全アイテム使用回数
 *
 * ・パーティごとに管理される戦績を取得する場合
 * $gameParty.gainGoldSum;         # 入手ゴールド合計
 * $gameParty.loseGoldSum;         # 消費ゴールド合計
 * $gameParty.getGainItemSum(1);   # アイテム[1]の入手合計
 * $gameParty.getGainWeaponSum(1); # 武器[1]の入手合計(初期装備以外)
 * $gameParty.getGainArmorSum(1);  # 防具[1]の入手合計(初期装備以外)
 *
 * ・売買履歴情報を取得する場合
 * アイテムごとの売買履歴を取得できます。
 * 開始IDと終了IDを指定することで、その範囲内の売買履歴を取得可能です。
 * 開始IDと終了IDを指定しなかった場合、全ての売買履歴の合計を取得します。
 *
 * 1.購入
 * # ID[1]からID[3]までのアイテムの累計購入金額の合計
 * $gameParty.getItemBuyingRecord().getUseGoldSum(1, 3);
 *
 * # ID[2]からID[4]のアイテムの累計購入個数の合計
 * $gameParty.getItemBuyingRecord().getAmountSum(2, 4);
 *
 * # アイテムの累計購入回数(まとめ買いは1回でカウント)
 * $gameParty.getItemBuyingRecord().getTradeCount();
 *
 * # ID[1]の武器の累計購入金額
 * $gameParty.getWeaponBuyingRecord().getUseGoldSum(1);
 *
 * # ID[2]の武器の累計購入個数
 * $gameParty.getWeaponBuyingRecord().getAmountSum(2);
 *
 * # 武器の累計購入回数(まとめ買いは1回でカウント)
 * $gameParty.getWeaponBuyingRecord().getTradeCount();
 *
 * # 全防具の累計購入金額の合計
 * $gameParty.getArmorBuyingRecord().getUseGoldSum();
 *
 * # 全防具の累計購入個数
 * $gameParty.getArmorBuyingRecord().getAmountSum();
 *
 * # 防具の累計購入回数(まとめ買いは1回でカウント)
 * $gameParty.getArmorBuyingRecord().getTradeCount();
 *
 * 2.売却
 * # ID[1]からID[3]までのアイテムの累計売却金額の合計
 * $gameParty.getItemSellingRecord().getUseGoldSum(1, 3);
 *
 * # ID[2]からID[4]のアイテムの累計売却個数の合計
 * $gameParty.getItemSellingRecord().getAmountSum(2, 4);
 *
 * # アイテムの累計売却回数(まとめ買いは1回でカウント)
 * $gameParty.getItemSellingRecord().getTradeCount();
 *
 * # ID[1]の武器の累計売却金額
 * $gameParty.getWeaponSellingRecord().getUseGoldSum(1);
 *
 * # ID[2]の武器の累計売却個数
 * $gameParty.getWeaponSellingRecord().getAmountSum(2);
 *
 * # 武器の累計売却回数(まとめ買いは1回でカウント)
 * $gameParty.getWeaponSellingRecord().getTradeCount();
 *
 * # 全防具の累計売却金額の合計
 * $gameParty.getArmorSellingRecord().getUseGoldSum();
 *
 * # 全防具の累計売却個数
 * $gameParty.getArmorSellingRecord().getAmountSum();
 *
 * # 防具の累計売却回数(まとめ買いは1回でカウント)
 * $gameParty.getArmorSellingRecord().getTradeCount();
 *
 * 応用的な使い方として「動的データベース構築プラグイン」と組み合わせれば
 * 戦績をデータベースの値に組み込んでより多彩な装備品やスキルを
 * 作成することができます。
 * 「動的データベース構築プラグイン」は、本プラグインと同一の配布元で
 * 配布しています。
 *
 * No plugin command.
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 戦績プラグイン
 * @author トリアコンタン
 *
 * @help 戦闘中の様々な情報を記録していつでも取得可能にします。
 * 戦績として記録に残せるほか、特殊なスキルのダメージ計算式に
 * 組み込んだりすることもできます。
 *
 * アクターごとに以下の要素を記録できます。
 *
 * ・スキルごとの使用回数(戦闘中のみカウント。他項目も同様)
 * ・全スキルの使用回数合計
 * ・アイテムごとの使用回数
 * ・全アイテムの使用回数合計
 * ・敵キャラごとの撃破回数
 * ・全敵キャラの撃破回数合計
 * ・与えたダメージの合計
 * ・与えたダメージの最大
 * ・与えたダメージの最大(1行動ごと)
 * ・受けたダメージの合計
 * ・受けたダメージの最大
 * ・回復したダメージの合計
 * ・消費したMP合計
 * ・消費したTP合計
 * ・戦闘不能回数
 *
 * 値はイベントコマンド「変数の操作」から「スクリプト」で
 * 対応するスクリプトを呼び出して取得してください。
 *
 * ・データベースのアクターIDから取得する場合
 * $gameActors.actor(1).getSkillUseCounter(2);   # アクター[1]のスキル[2]使用回数
 * $gameActors.actor(1).getAllSkillUseCounter(); # アクター[1]の全スキル使用回数
 * $gameActors.actor(1).getItemUseCounter(3);    # アクター[1]のアイテム[3]使用回数
 * $gameActors.actor(1).getAllItemUseCounter();  # アクター[1]の全アイテム使用回数
 * $gameActors.actor(1).getKillEnemyCounter(4);  # アクター[1]の敵キャラ[4]撃破数
 * $gameActors.actor(1).getAllKillEnemyCounter();# アクター[1]の全敵キャラ撃破数
 * $gameActors.actor(1).attackDamageMax;         # アクター[1]の最大与ダメージ
 * $gameActors.actor(1).actionDamageMax;         # アクター[1]の行動あたりの最大与ダメージ
 * $gameActors.actor(1).attackDamageSum;         # アクター[1]の合計与ダメージ
 * $gameActors.actor(1).acceptDamageMax;         # アクター[1]の最大被ダメージ
 * $gameActors.actor(1).acceptDamageSum;         # アクター[1]の合計被ダメージ
 * $gameActors.actor(1).recoverDamageSum;        # アクター[1]の合計回復ダメージ
 * $gameActors.actor(1).payCostMpSum;            # アクター[1]の消費MP合計
 * $gameActors.actor(1).payCostTpSum;            # アクター[1]の消費TP合計
 * $gameActors.actor(1).deadCounter;             # アクター[1]の戦闘不能回数
 *
 * ・パーティの並び順(先頭は0)から取得する場合
 * $gameActors.actor(n)を$gameParty.members()[n]に置き換えて実行する。
 * (例)
 * $gameParty.members()[0].attackDamageMax # 先頭メンバーの最大与ダメージ
 *
 * ・スキルのダメージ計算式で使用する場合
 * $gameActors.actor(n)をa(実行者)もしくはb(対象者)に置き換えて実行する。
 * (例)
 * a.getSkillUseCounter(5)  # 実行者のスキル[5]使用回数
 * b.getKillEnemyCounter(6) # 対象者の敵キャラ[6]撃破数
 *
 * ・すべてのアクターの合計値を取得する場合
 * $gameActors.actor(n)を$gameActorsに置き換えて実行する。
 * (例)
 * $gameActors.getKillEnemyCounter(4); # 全アクターの敵キャラ[4]撃破数合計
 *
 * ・パーティごとに管理される戦績を取得する場合
 * $gameParty.gainGoldSum;         # 入手ゴールド合計
 * $gameParty.loseGoldSum;         # 消費ゴールド合計
 * $gameParty.getGainItemSum(1);   # アイテム[1]の入手合計
 * $gameParty.getGainWeaponSum(1); # 武器[1]の入手合計(初期装備以外)
 * $gameParty.getGainArmorSum(1);  # 防具[1]の入手合計(初期装備以外)
 *
 * ・売買履歴情報を取得する場合
 * アイテムごとの売買履歴を取得できます。
 * 開始IDと終了IDを指定することで、その範囲内の売買履歴を取得可能です。
 * 開始IDと終了IDを指定しなかった場合、全ての売買履歴の合計を取得します。
 *
 * 1.購入
 * # ID[1]からID[3]までのアイテムの累計購入金額の合計
 * $gameParty.getItemBuyingRecord().getUseGoldSum(1, 3);
 *
 * # ID[2]からID[4]のアイテムの累計購入個数の合計
 * $gameParty.getItemBuyingRecord().getAmountSum(2, 4);
 *
 * # アイテムの累計購入回数(まとめ買いは1回でカウント)
 * $gameParty.getItemBuyingRecord().getTradeCount();
 *
 * # ID[1]の武器の累計購入金額
 * $gameParty.getWeaponBuyingRecord().getUseGoldSum(1);
 *
 * # ID[2]の武器の累計購入個数
 * $gameParty.getWeaponBuyingRecord().getAmountSum(2);
 *
 * # 武器の累計購入回数(まとめ買いは1回でカウント)
 * $gameParty.getWeaponBuyingRecord().getTradeCount();
 *
 * # 全防具の累計購入金額の合計
 * $gameParty.getArmorBuyingRecord().getUseGoldSum();
 *
 * # 全防具の累計購入個数
 * $gameParty.getArmorBuyingRecord().getAmountSum();
 *
 * # 防具の累計購入回数(まとめ買いは1回でカウント)
 * $gameParty.getArmorBuyingRecord().getTradeCount();
 *
 * 2.売却
 * # ID[1]からID[3]までのアイテムの累計売却金額の合計
 * $gameParty.getItemSellingRecord().getUseGoldSum(1, 3);
 *
 * # ID[2]からID[4]のアイテムの累計売却個数の合計
 * $gameParty.getItemSellingRecord().getAmountSum(2, 4);
 *
 * # アイテムの累計売却回数(まとめ買いは1回でカウント)
 * $gameParty.getItemSellingRecord().getTradeCount();
 *
 * # ID[1]の武器の累計売却金額
 * $gameParty.getWeaponSellingRecord().getUseGoldSum(1);
 *
 * # ID[2]の武器の累計売却個数
 * $gameParty.getWeaponSellingRecord().getAmountSum(2);
 *
 * # 武器の累計売却回数(まとめ買いは1回でカウント)
 * $gameParty.getWeaponSellingRecord().getTradeCount();
 *
 * # 全防具の累計売却金額の合計
 * $gameParty.getArmorSellingRecord().getUseGoldSum();
 *
 * # 全防具の累計売却個数
 * $gameParty.getArmorSellingRecord().getAmountSum();
 *
 * # 防具の累計売却回数(まとめ買いは1回でカウント)
 * $gameParty.getArmorSellingRecord().getTradeCount();
 *
 * 応用的な使い方として「動的データベース構築プラグイン」と組み合わせれば
 * 戦績をデータベースの値に組み込んでより多彩な装備品やスキルを
 * 作成することができます。
 * 「動的データベース構築プラグイン」は、本プラグインと同一の配布元で
 * 配布しています。
 *
 * ・戦績をクリア（初期化）する場合
 *
 * アクター関連項目
 * $gameActors.actor(アクターID).clearBattleRecord();
 *
 * パーティ関連項目
 * $gameParty.clearRecord();
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

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

(function() {
    'use strict';

    //=============================================================================
    // Game_BattlerBase
    //  戦績を記録します。
    //=============================================================================
    var _Game_BattlerBase_initMembers      = Game_BattlerBase.prototype.initMembers;
    Game_BattlerBase.prototype.initMembers = function() {
        _Game_BattlerBase_initMembers.apply(this, arguments);
        this.clearBattleRecord();
    };

    Game_BattlerBase.prototype.clearBattleRecord = function() {
        this._useSkillCounter  = [];
        this._useItemCounter   = [];
        this._killEnemyCounter = [];
        this.attackDamageMax   = 0;
        this.actionDamageMax   = 0;
        this.actionDamage      = 0;
        this.attackDamageSum   = 0;
        this.acceptDamageMax   = 0;
        this.acceptDamageSum   = 0;
        this.recoverDamageSum  = 0;
        this.deadCounter       = 0;
        this.payCostMpSum      = 0;
        this.payCostTpSum      = 0;
        this.getAllSkillUseCounter();
        this.getAllItemUseCounter();
        this.getAllKillEnemyCounter();
    };

    Game_BattlerBase.prototype.getBattlerId = function() {
        return this.isActor() ? this.actorId() : this.isEnemy() ? this.enemyId() : 0;
    };

    Game_BattlerBase.prototype.recordAttackDamage = function(value) {
        if (value >= 0) {
            this.attackDamageMax = Math.max((this.attackDamageMax || 0), value);
            this.attackDamageSum = (this.attackDamageSum || 0) + value;
            this.actionDamage = (this.actionDamage || 0) + value;
        } else {
            this.recordRecoverDamage(-value);
        }
    };

    Game_BattlerBase.prototype.saveActionDamageMax = function() {
        this.actionDamageMax = Math.max(this.actionDamageMax, this.actionDamage);
        this.actionDamage = 0;
    };

    Game_BattlerBase.prototype.recordAcceptDamage = function(value) {
        if (value >= 0) {
            this.acceptDamageMax = Math.max((this.acceptDamageMax || 0), value);
            this.acceptDamageSum = (this.acceptDamageSum || 0) + value;
        }
    };

    Game_BattlerBase.prototype.recordRecoverDamage = function(value) {
        this.recoverDamageSum = (this.recoverDamageSum || 0) + value;
    };

    Game_BattlerBase.prototype.recordPayCostMpSum = function(value) {
        if (value >= 0) {
            this.payCostMpSum = (this.payCostMpSum || 0) + value;
        }
    };

    Game_BattlerBase.prototype.recordPayCostTpSum = function(value) {
        if (value >= 0) {
            this.payCostTpSum = (this.payCostTpSum || 0) + value;
        }
    };

    Game_BattlerBase.prototype.recordDead = function() {
        this.deadCounter = (this.deadCounter || 0) + 1;
    };

    Game_BattlerBase.prototype.recordSkillUseCounter = function(skillId) {
        var prevCount                  = this.getSkillUseCounter(skillId);
        this._useSkillCounter[skillId] = prevCount + 1;
    };

    Game_BattlerBase.prototype.recordItemUseCounter = function(itemId) {
        var prevCount                = this.getItemUseCounter(itemId);
        this._useItemCounter[itemId] = prevCount + 1;
    };

    Game_BattlerBase.prototype.recordKillEnemyCounter = function(enemyId) {
        var prevCount                   = this.getKillEnemyCounter(enemyId);
        this._killEnemyCounter[enemyId] = prevCount + 1;
    };

    Game_BattlerBase.prototype.getSkillUseCounter = function(skillId) {
        if (!this._useSkillCounter) this._useSkillCounter = [];
        return this._useSkillCounter[skillId] || 0;
    };

    Game_BattlerBase.prototype.getItemUseCounter = function(itemId) {
        if (!this._useItemCounter) this._useItemCounter = [];
        return this._useItemCounter[itemId] || 0;
    };

    Game_BattlerBase.prototype.getKillEnemyCounter = function(enemyId) {
        if (!this._killEnemyCounter) this._killEnemyCounter = [];
        return this._killEnemyCounter[enemyId] || 0;
    };

    Game_BattlerBase.prototype.getAllSkillUseCounter = function() {
        return this.getSumRecord(this._useSkillCounter);
    };

    Game_BattlerBase.prototype.getAllItemUseCounter = function() {
        return this.getSumRecord(this._useItemCounter);
    };

    Game_BattlerBase.prototype.getAllKillEnemyCounter = function() {
        return this.getSumRecord(this._killEnemyCounter);
    };

    Game_BattlerBase.prototype.getSumRecord = function(counterArray) {
        if (!counterArray) return 0;
        return counterArray.reduce(function(sumValue, value) {
            return sumValue + value;
        }, 0);
    };

    var _Game_BattlerBase_paySkillCost      = Game_BattlerBase.prototype.paySkillCost;
    Game_BattlerBase.prototype.paySkillCost = function(skill) {
        _Game_BattlerBase_paySkillCost.apply(this, arguments);
        this.recordPayCostMpSum(this.skillMpCost(skill));
        this.recordPayCostTpSum(this.skillTpCost(skill));
    };

    //=============================================================================
    // Game_Battler
    //  アイテムとスキルの使用回数を記録します。
    //=============================================================================
    var _Game_Battler_useItem      = Game_Battler.prototype.useItem;
    Game_Battler.prototype.useItem = function(item) {
        _Game_Battler_useItem.apply(this, arguments);
        if (!$gameParty.inBattle()) return;
        if (DataManager.isSkill(item)) {
            this.recordSkillUseCounter(item.id);
        } else if (DataManager.isItem(item)) {
            this.recordItemUseCounter(item.id);
        }
    };

    //=============================================================================
    // Game_Actor
    //  装備変更時はカウンタを無効にします。
    //=============================================================================
    var _Game_Actor_tradeItemWithParty      = Game_Actor.prototype.tradeItemWithParty;
    Game_Actor.prototype.tradeItemWithParty = function(newItem, oldItem) {
        $gameParty.setTradingItemWithActor(true);
        var result = _Game_Actor_tradeItemWithParty.apply(this, arguments);
        $gameParty.setTradingItemWithActor(false);
        return result;
    };

    //=============================================================================
    // Game_Action
    //  戦績を記録します。
    //=============================================================================
    var _Game_Action_executeHpDamage      = Game_Action.prototype.executeHpDamage;
    Game_Action.prototype.executeHpDamage = function(target, value) {
        _Game_Action_executeHpDamage.apply(this, arguments);
        this.subject().recordAttackDamage(value);
        target.recordAcceptDamage(value);
        if (target.hp === 0) {
            this.subject().recordKillEnemyCounter(target.getBattlerId());
            target.recordDead();
        }
    };

    //=============================================================================
    // Game_Actors
    //  全アクターの累計戦績を取得します。
    //=============================================================================
    Game_Actors.prototype.getSumRecord = function(propertyName, args) {
        return this._data.reduce(function(sumValue, actor) {
            return sumValue + this.getActorProperty(actor, propertyName, args);
        }.bind(this), 0);
    };

    Game_Actors.prototype.getActorProperty = function(actor, propertyName, args) {
        if (!actor) {
            return 0;
        } else if (args) {
            return actor[propertyName].apply(actor, args);
        } else {
            return actor[propertyName];
        }
    };

    Game_Actors.prototype.getSkillUseCounter = function(skillId) {
        return this.getSumRecord('getSkillUseCounter', [skillId]);
    };

    Game_Actors.prototype.getItemUseCounter = function(itemId) {
        return this.getSumRecord('getItemUseCounter', [itemId]);
    };

    Game_Actors.prototype.getKillEnemyCounter = function(enemyId) {
        return this.getSumRecord('getKillEnemyCounter', [enemyId]);
    };

    Game_Actors.prototype.getAllSkillUseCounter = function() {
        return this.getSumRecord('getAllSkillUseCounter', []);
    };

    Game_Actors.prototype.getAllItemUseCounter = function() {
        return this.getSumRecord('getAllItemUseCounter', []);
    };

    Game_Actors.prototype.getAllKillEnemyCounter = function() {
        return this.getSumRecord('getAllKillEnemyCounter', []);
    };

    Object.defineProperty(Game_Actors.prototype, 'attackDamageMax', {
        get: function() {
            return this.getSumRecord('attackDamageMax');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'attackDamageSum', {
        get: function() {
            return this.getSumRecord('attackDamageSum');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'acceptDamageMax', {
        get: function() {
            return this.getSumRecord('acceptDamageMax');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'acceptDamageSum', {
        get: function() {
            return this.getSumRecord('acceptDamageSum');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'recoverDamageSum', {
        get: function() {
            return this.getSumRecord('recoverDamageSum');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'payCostMpSum', {
        get: function() {
            return this.getSumRecord('payCostMpSum');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'payCostTpSum', {
        get: function() {
            return this.getSumRecord('payCostTpSum');
        }
    });

    Object.defineProperty(Game_Actors.prototype, 'deadCounter', {
        get: function() {
            return this.getSumRecord('deadCounter');
        }
    });

    //=============================================================================
    // Game_Party
    //  アイテムとお金の増減情報を記録します。
    //=============================================================================
    var _Game_Party_initialize      = Game_Party.prototype.initialize;
    Game_Party.prototype.initialize = function() {
        _Game_Party_initialize.apply(this, arguments);
        this.clearRecord();
        this._tradingItemWithActor = false;
    };

    Game_Party.prototype.setTradingItemWithActor = function(value) {
        this._tradingItemWithActor = value;
    };

    Game_Party.prototype.clearRecord = function() {
        this.gainGoldSum    = 0;
        this.loseGoldSum    = 0;
        this._gainItemSum   = [];
        this._gainWeaponSum = [];
        this._gainArmorSum  = [];
    };

    Game_Party.prototype.getItemTypeName = function(item) {
        var itemTypeName;
        if (DataManager.isItem(item)) {
            itemTypeName = 'item';
        } else if (DataManager.isWeapon(item)) {
            itemTypeName = 'weapon';
        } else if (DataManager.isArmor(item)) {
            itemTypeName = 'armor';
        }
        return itemTypeName;
    };

    Game_Party.prototype.getTradeRecord = function(itemTypeName, tradeTypeName) {
        return this.getTradeRecordInstance(itemTypeName + tradeTypeName + 'Record');
    };

    Game_Party.prototype.getTradeRecordInstance = function(fieldName) {
        this[fieldName] = this[fieldName] || new Game_TradeRecord();
        return this[fieldName];
    };

    Game_Party.prototype.recordGainGold = function(amount) {
        this.gainGoldSum = (this.gainGoldSum || 0) + amount;
    };

    Game_Party.prototype.recordLoseGold = function(amount) {
        this.loseGoldSum = (this.loseGoldSum || 0) + amount;
    };

    Game_Party.prototype.recordGainItemSum = function(itemId, amount) {
        var prevAmount            = this.getGainItemSum(itemId);
        this._gainItemSum[itemId] = prevAmount + amount;
    };

    Game_Party.prototype.getGainItemSum = function(itemId) {
        if (!this._gainItemSum) this._gainItemSum = [];
        return this._gainItemSum[itemId] || 0;
    };

    Game_Party.prototype.recordGainWeaponSum = function(weaponId, amount) {
        var prevAmount                = this.getGainWeaponSum(weaponId);
        this._gainWeaponSum[weaponId] = prevAmount + amount;
    };

    Game_Party.prototype.getGainWeaponSum = function(weaponId) {
        if (!this._gainWeaponSum) this._gainWeaponSum = [];
        return this._gainWeaponSum[weaponId] || 0;
    };

    Game_Party.prototype.recordGainArmorSum = function(armorId, amount) {
        var prevAmount              = this.getGainArmorSum(armorId);
        this._gainArmorSum[armorId] = prevAmount + amount;
    };

    Game_Party.prototype.getGainArmorSum = function(armorId) {
        if (!this._gainArmorSum) this._gainArmorSum = [];
        return this._gainArmorSum[armorId] || 0;
    };

    var _Game_Party_gainGold      = Game_Party.prototype.gainGold;
    Game_Party.prototype.gainGold = function(amount) {
        var prevGold = this._gold;
        _Game_Party_gainGold.apply(this, arguments);
        var deltaGold = this._gold - prevGold;
        if (deltaGold >= 0) {
            this.recordGainGold(deltaGold);
        } else {
            this.recordLoseGold(-deltaGold);
        }
    };

    var _Game_Party_gainItem      = Game_Party.prototype.gainItem;
    Game_Party.prototype.gainItem = function(item, amount, includeEquip) {
        _Game_Party_gainItem.apply(this, arguments);
        if (amount < 0 || this._tradingItemWithActor) return;
        if (DataManager.isItem(item)) {
            this.recordGainItemSum(item.id, amount);
        } else if (DataManager.isWeapon(item)) {
            this.recordGainWeaponSum(item.id, amount);
        } else if (DataManager.isArmor(item)) {
            this.recordGainArmorSum(item.id, amount);
        }
    };

    Game_Party.prototype.addTradeRecord = function(item, amount, gold, tradeType) {
        var record = this.getTradeRecord(this.getItemTypeName(item), tradeType);
        record.trade(item.id, amount, gold);
    };

    Game_Party.prototype.getItemBuyingRecord = function() {
        return this.getTradeRecord('item', 'Buy');
    };

    Game_Party.prototype.getItemSellingRecord = function() {
        return this.getTradeRecord('item', 'Sell');
    };

    Game_Party.prototype.getWeaponBuyingRecord = function() {
        return this.getTradeRecord('weapon', 'Buy');
    };

    Game_Party.prototype.getWeaponSellingRecord = function() {
        return this.getTradeRecord('weapon', 'Sell');
    };

    Game_Party.prototype.getArmorBuyingRecord = function() {
        return this.getTradeRecord('armor', 'Buy');
    };

    Game_Party.prototype.getArmorSellingRecord = function() {
        return this.getTradeRecord('armor', 'Sell');
    };

    //=============================================================================
    // Game_TradeRecord
    //  ショップでの売買履歴を保持するクラスです。
    //=============================================================================
    Game_TradeRecord.prototype.constructor = Game_TradeRecord;

    Game_TradeRecord.prototype.initialize = function() {
        this._itemUseGold = [];
        this._itemAmount  = [];
        this._tradeCount  = 0;
    };

    Game_TradeRecord.prototype.trade = function(itemId, amount, useGold) {
        this._itemUseGold[itemId] = (this._itemUseGold[itemId] || 0) + useGold;
        this._itemAmount[itemId]  = (this._itemAmount[itemId] || 0) + amount;
        this._tradeCount++;
    };

    Game_TradeRecord.prototype.getUseGoldSum = function(startId, endId) {
        return this.getSumRecord(this._itemUseGold, startId, endId);
    };

    Game_TradeRecord.prototype.getAmountSum = function(startId, endId) {
        return this.getSumRecord(this._itemAmount, startId, endId);
    };

    Game_TradeRecord.prototype.getTradeCount = function() {
        return this._tradeCount;
    };

    Game_TradeRecord.prototype.getSumRecord = function(counterArray, startIndex, endIndex) {
        if (startIndex && !endIndex) {
            endIndex = startIndex;
        }
        if (!startIndex && !endIndex) {
            startIndex = 1;
            endIndex = counterArray.length - 1;
        }
        return counterArray.slice(startIndex, endIndex + 1).reduce(function(sumValue, value) {
            return sumValue + value;
        }, 0);
    };

    var _BattleManager_endAction = BattleManager.endAction;
    BattleManager.endAction = function() {
        this._subject.saveActionDamageMax();
        _BattleManager_endAction.apply(this, arguments);
    };

    //=============================================================================
    // Scene_Shop
    //  ショップでの売買履歴を保持します。
    //=============================================================================
    var _Scene_Shop_doBuy = Scene_Shop.prototype.doBuy;
    Scene_Shop.prototype.doBuy = function(number) {
        _Scene_Shop_doBuy.apply(this, arguments);
        $gameParty.addTradeRecord(this._item, number, number * this.buyingPrice(), 'Buy');
    };

    var _Scene_Shop_doSell = Scene_Shop.prototype.doSell;
    Scene_Shop.prototype.doSell = function(number) {
        _Scene_Shop_doSell.apply(this, arguments);
        $gameParty.addTradeRecord(this._item, number, number * this.sellingPrice(), 'Sell');
    };
})();


code:
//=============================================================================
// BattleResultsPopup.js
//=============================================================================

/*:ja
 * @plugindesc 戦闘結果の表示をポップアップ形式に変更します。
 * @author Yoji Ojima
 *
 * @help このプラグインには、プラグインコマンドはありません。
 *
 * @param リザルトスキップスイッチ
 * @type switch
 * @desc このスイッチがONの時、バトルリザルト画面をスキップします。
 * @default 0
 *
 * @param バトルリザルトテキスト
 * @type string
 * @desc バトルリザルトのテキストを記述してください
 * @default - Battle Result -
 *
 * @param 入手経験値テキスト
 * @type string
 * @desc 入手経験値のテキストを記述してください
 * @default 入手経験値
 *
 * @param 入手金額テキスト
 * @type string
 * @desc 入手金額のテキストを記述してください
 * @default 入手金額
 *
 * @param 入手SPテキスト
 * @type string
 * @desc 入手SPのテキストを記述してください
 * @default 入手SP
 *
 * @param 次のレベルまで
 * @type string
 * @desc 次のレベルまでのテキストを記述してください
 * @default 次のレベルまで
 *
 * @param レベルアップテキスト1
 * @type string
 * @desc レベルアップ時のテキスト（数値の前）を記述してください
 * @default 彩羽のレベルが
 *
 * @param レベルアップテキスト2
 * @type string
 * @desc レベルアップ時のテキスト（数値の後）を記述してください
 * @default 上がった！
 *
 * @param アイテム獲得テキスト
 * @type string
 * @desc アイテム獲得時のテキストを記述してください
 * @default を獲得した！
*/

(function() {
    var parameters = PluginManager.parameters('BattleResultsPopup');
    var BattleResultText = String(parameters['バトルリザルトテキスト'] );
    var ExpResultText = String(parameters['入手経験値テキスト']);
    var MoneyResultText = String(parameters['入手金額テキスト'] );
    var SPResultText = String(parameters['入手SPテキスト'] );
    var NextLevelText = String(parameters['次のレベルまで'] );
    var LevelUpText1 = String(parameters['レベルアップテキスト1']);
    var LevelUpText2 = String(parameters['レベルアップテキスト2']);
    var ItemText = String(parameters['アイテム獲得テキスト'] );
    var SkipResultSwitch = Number(parameters['リザルトスキップスイッチ'] || 0);

    var resultDisplaying = 0;

    var _BattleManager_initMembers = BattleManager.initMembers;
    BattleManager.initMembers = function() {
        _BattleManager_initMembers.call(this);
        resultDisplaying = 0;
    };

    var _BattleManager_update = BattleManager.update;
    BattleManager.update = function() {
        _BattleManager_update.call(this);
        if (resultDisplaying > 0) {
            if (++resultDisplaying >= 60) {
                if (Input.isTriggered('ok') || TouchInput.isTriggered()) {
                    resultDisplaying = 0;
                }
            }
        }
    };

    var _BattleManager_isBusy = BattleManager.isBusy;
    BattleManager.isBusy = function() {
        return _BattleManager_isBusy.call(this) || resultDisplaying > 0;
    };

    BattleManager.displayVictoryMessage = function() {
    };

	BattleManager.displayRewards = function() {
	    if (SkipResultSwitch > 0 && $gameSwitches.value(SkipResultSwitch)) {
	        resultDisplaying = 0; // リザルト表示処理をキャンセル
	        return;
	    }
	    resultDisplaying = 1;
	};

    Game_Actor.prototype.shouldDisplayLevelUp = function() {
        return false;
    };

    var _Scene_Battle_update = Scene_Battle.prototype.update;
    Scene_Battle.prototype.update = function() {
        _Scene_Battle_update.call(this);
        if (resultDisplaying > 30 && !this._resultWindow) {
            this._resultWindow = new Window_BattleResults();
            this.addWindow(this._resultWindow);
        }
    };

    var _Scene_Battle_stop = Scene_Battle.prototype.stop;
    Scene_Battle.prototype.stop = function() {
        _Scene_Battle_stop.call(this);
        if (this._resultWindow) {
            this._resultWindow.close();
        }
    };

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

    Window_BattleResults.prototype = Object.create(Window_Base.prototype);
    Window_BattleResults.prototype.constructor = Window_BattleResults;
    Window_BattleResults.prototype.initialize = function() {
        var rewards = BattleManager._rewards;
        var width = 500;
        var count = 3;
        if($gameVariables.value(74)>0){
        	count ++;
        }
        var height = this.fittingHeight(Math.min(9, rewards.items.length + 1)+count);
        var statusHeight = this.fittingHeight(4);
        var x = (Graphics.boxWidth - width) / 2-190;
        var y = (Graphics.boxHeight - statusHeight - height) / 2;
        Window_Base.prototype.initialize.call(this, x, y, width, height);
        this.refresh();
        this.openness = 0;
        this.open();
    };

    Window_BattleResults.prototype.refresh = function() {

		$gameMessage._positionType = 1919;
		if($gameVariables.value(80)==3){
			$gameVariables.setValue(79,1);
			$gameVariables.setValue(80,1);
		}
		if($gameTroop._troopId!=8){
		    $gameMessage.add('\\>\\CE[133]\\^');
		}else{
		    $gameMessage.add('\\>\\CE[168]\\^');
		}
        var x = this.textPadding();
        var y = 0;
        var finalExp = 0;
        var width = this.contents.width;
        var lineHeight = this.lineHeight();
        var rewards = BattleManager._rewards;
        var items = rewards.items;
        rewards.exp = Math.round(rewards.exp)

		$gameParty.allMembers().forEach(actor => {
			var ManualExpRate = 1;
			if($gameActors.actor(1).isStateAffected(59))				ManualExpRate+=0.15;
			if($gameActors.actor(1).isStateAffected(60))				ManualExpRate+=0.2;
			if($gameActors.actor(1).isStateAffected(61))				ManualExpRate+=0.3;
			if($gameActors.actor(1).isStateAffected(106))				ManualExpRate+=1;
			if($gameActors.actor(1).isStateAffected(188))				ManualExpRate+=0.5;
			if($gameActors.actor(1).isStateAffected(205))				ManualExpRate+=0.5;
			if($gameActors.actor(1).isLearnedSkill(655))				ManualExpRate+=0.1;
			if($gameActors.actor(1).equips().includes($dataArmors[118]))ManualExpRate+=0.1;
        	finalExp = Math.round(rewards.exp * ManualExpRate);
        });
		var longUnit = Math.max(this.textWidth(TextManager.expA),this.textWidth("G"),this.textWidth(TextManager.currencyUnit),this.textWidth("pt"));
		var bonusExp = finalExp - rewards.exp;
	    $gameActors.actor(1).removeState(188); //インテリスナックの解除

        this.contents.clear();

        //バトルリザルト（文字）表示
        this.resetTextColor();
        this.drawText(BattleResultText, (width - this.textWidth(BattleResultText))/2 - this.textPadding(), y,width);
        this.drawTextEx("\\UL[　　　　　　　　　　　　　　　　　　]",x, y+6,width);
        y += lineHeight;

        //入手経験値（文字）を表示
        this.drawTextEx("\\I[1917]", x, y);
	    this.changeTextColor(this.systemColor());
	    this.drawText(ExpResultText, x + 36, y, width);

        //入手経験値（数値）を表示
	    this.resetTextColor();
        x = width - this.textWidth(rewards.exp) - longUnit;
		//（追加）ボーナスがある場合
		if(bonusExp>=1){
        	this.contents.fontSize = 16;
        	bonusTextWidth = this.textWidth("(+" + bonusExp + ")")
        	x -= bonusTextWidth;
			this.contents.fontSize = 28;
	        this.drawText(rewards.exp, x, y);
			x = width - bonusTextWidth - longUnit;
		    this.drawTextEx("\\}\\}(+" + bonusExp + ")\\{\\{", x, y-2);
		}else{
	        this.drawText(rewards.exp, x, y);
		}
        //入手経験値（単位）を表示
		    this.drawTextEx("\\}\\C[16]" + TextManager.expA + "\\{\\C[0]", width  - longUnit + 4, y-2);

        //レベルアップの処理 or 次のレベルまでの経験値を表示
		x = this.textPadding() + 32;
		y += lineHeight;
		this.resetTextColor();
        this.drawTextEx("\\I[1128]", x, y);
        if($gameVariables.value(140) < $gameActors.actor(1).level){
        	AudioManager.playSe({"name":"Up1","volume":90,"pitch":100,"pan":0})
			var lvtext = "\\}\\}" + LevelUpText1 + " " + ($gameActors.actor(1).level -$gameVariables.value(140))  + " " + LevelUpText2 + "\\{"
        	this.drawTextEx(lvtext, x + 32, y-8,width);
        }else{
			var lvtext = "\\}\\}\\C[16]" + NextLevelText + " " + "\\C[0]"
			if($gameActors.actor(1).level < 99){
				 lvtext += $gameActors._data[1].nextRequiredExp();
			}else{
				 lvtext += "   ---"
			}
        	this.drawTextEx(lvtext, x + 32, y-8,width);
        	this.contents.fontSize = 16;
        	NextLvWidth = this.textWidth(NextLevelText + " " + $gameActors._data[1].nextRequiredExp())
			this.contents.fontSize = 28;
        	lvtext = " \\C[16]\\}\\}\\}" + TextManager.expA + "\\C[0]\\{\\{\\{"
        	this.drawTextEx(lvtext, x + 32 + NextLvWidth, y-6,width);
        }
		//お金 or 魔界通貨の獲得処理
        x = this.textPadding();
        y += lineHeight-6;

        //入手金額（文字）を表示
        this.drawTextEx("\\I[2152]", x, y);
	    this.changeTextColor(this.systemColor());
	    this.drawText(MoneyResultText, x+36, y, width);

        //入手金額（数値）を表示
	    this.resetTextColor();
        if($gameSwitches.value(15)){
            x = width - this.textWidth($gameVariables.value(296)) - longUnit;
	        this.drawText($gameVariables.value(296), x, y);
	        this.changeTextColor(this.systemColor());
        	this.drawTextEx("\\}\\C[16]G\\C[0]\\{", width - longUnit + 7, y-2);
        }else{
            x = width - this.textWidth(rewards.gold) - longUnit;
	        this.drawText(rewards.gold, x, y);
	        this.changeTextColor(this.systemColor());
	        this.drawTextEx("\\}\\C[16]" + TextManager.currencyUnit + "\\C[0]\\{\\{", width - longUnit + 7, y-2);
		}

		//SPの獲得処理（獲得する値はPon_BattleGainVariable.jsで設定）
		if ($gameVariables.value(74)>0){
			$gameVariables.setValue(74,Math.ceil($gameVariables.value(74)))

        	x = this.textPadding();
        	y += lineHeight;

        	//入手SP（文字）を表示
        	this.drawTextEx("\\I[1914]", x, y);
	    	this.changeTextColor(this.systemColor());
	    	this.drawText(SPResultText, x+36, y, width);

        	//入手SP（数値）を表示
	    	this.resetTextColor();
            x = width - this.textWidth($gameVariables.value(74)) - longUnit;
	        this.drawText($gameVariables.value(74), x, y);
	        this.drawTextEx("\\}\\C[16]pt\\C[0]\\{", width  - longUnit + 5, y-2);

    		$gameVariables._data[142] += $gameVariables._data[74];
    		$gameVariables._data[230] += $gameVariables._data[74];
    		$gameVariables._data[231] += $gameVariables._data[74];
    		$gameVariables._data[74] = 0;
    	}

        y += lineHeight;
        items.forEach(function(item) {
        	x = this.textPadding();
	        this.drawTextEx("\\I[" + item.iconIndex + "]", x, y , width);
	        this.drawTextEx("\\}" +item.name + "\\{", x+36,y-2,width);
	        this.drawTextEx("\\}\\C[16]" + ItemText + "\\C[0]\\{", width - this.textWidth(ItemText)+20, y-2 , width);
            y += lineHeight;
        }, this);
    };

})();


code:
//=============================================================================
// BattleendFade.js
//=============================================================================

/*:ja
 * @plugindesc ver1.00 八百長不可避
 * @author まっつＵＰ
 *
 * @param switchId
 * @desc このIDのスイッチがオンの時
 * 戦闘終了時にマップbgm等の再開を行いません。
 * @type switch
 * @default 10
 *
 * @param switchId2
 * @desc このIDのスイッチがオンの時
 * 戦闘終了時にフェードインしません。
 * @type switch
 * @default 10
 *
 * @help
 *
 * RPGで笑顔を・・・
 *
 * このヘルプとパラメータの説明をよくお読みになってからお使いください。
 *
 * パラメータswitchIdのスイッチにより
 * 戦闘終了時も戦闘bgmが垂れ流しになります。
 * この場合でも
 * スイッチをオフにした後にスクリプトで
 * BattleManager.replayBgmAndBgs();
 * を処理すれば戦闘前のbgmやbgsを流すことができます。
 *
 * パラメータswitchId2のスイッチにより
 * バトルシーン終了時とマップシーン再開時に起こる
 * フェードインを無効にすることができます。
 * この機能によってフェードインを無効にした時は
 * イベントコマンド「画面のフェードイン」を使ってください。
 *
 * このプラグインを利用する場合は
 * readmeなどに「まっつＵＰ」の名を入れてください。
 * また、素材のみの販売はダメです。
 * 上記以外の規約等はございません。
 * もちろんツクールMVで使用する前提です。
 * 何か不具合ありましたら気軽にどうぞ。
 *
 * 免責事項：
 * このプラグインを利用したことによるいかなる損害も制作者は一切の責任を負いません。
 *
 */

(function() {

var parameters = PluginManager.parameters('BattleendFade');
var BFswitchId = Number(parameters['switchId'] || 10);
var BFswitchId2 = Number(parameters['switchId2'] || 10);

var _BattleManager_replayBgmAndBgs = BattleManager.replayBgmAndBgs;
BattleManager.replayBgmAndBgs = function() {
    if($gameSwitches.value(BFswitchId)) return;
    _BattleManager_replayBgmAndBgs.call(this);
};

var _BattleManager_updateBattleEnd = BattleManager.updateBattleEnd;
BattleManager.updateBattleEnd = function() {
    if($gameSwitches.value(BFswitchId2)) $gameScreen.startFadeOut(24,true);
    _BattleManager_updateBattleEnd.call(this);
};

})();


code:
//
//  発動前コモン ver1.00
//
// author yana
//

var Imported = Imported || {};
Imported['BeforeCommon'] = 1.00;

/*:
 * @plugindesc ver1.00/スキルやアイテムの発動前に、スキルやアイテムに設定されたコモンイベントを発生させます。
 * @author Yana
 *
 * @param IndexVariableID
 * @desc 発動者のインデックスを保存する変数IDです。
 * 発動者がエネミーの場合は値に+1000されます。
 * @default 11
 *
 * @help------------------------------------------------------
 *  プラグインコマンドはありません。
 * ------------------------------------------------------
 * ------------------------------------------------------
 * 設定方法
 * ------------------------------------------------------
 *
 * スキルやアイテムのメモ欄に
 * <発動前コモン:x>
 * または、
 * <BeforeCommon:x>
 * と記述することで、スキルやアイテムが発生する前に、
 * IDがx番のコモンイベントの実行を予約します。
 *
 * また、プラグインパラメータで指定したIDの変数に、
 * 行動者のインデックスが格納されます。
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.00:
 * 公開
 */

(function() {

    ////////////////////////////////////////////////////////////////////////////////////

    var parameters = PluginManager.parameters('BeforeCommon');
    var indexVariableId = Number(parameters['IndexVariableID']);

    ////////////////////////////////////////////////////////////////////////////////////

	DataManager.isBeforeCommon = function(item) {
		if (!item){ return false }
		if (item.meta['発動前コモン']){ return true }
		if (item.meta['BeforeCommon']){ return true }
		return false;
	};

	DataManager.beforeCommonEffect = function(item) {
		var effects = [];
		if (item.meta['発動前コモン']){
			effects = Number(item.meta['発動前コモン']);
		} else if (item.meta['BeforeCommon']) {
			effects = Number(item.meta['BeforeCommon']);
		}
		return effects;
	};

    ////////////////////////////////////////////////////////////////////////////////////

	var __BManager_startAction = BattleManager.startAction;
	BattleManager.startAction = function() {
		var action = this._subject.currentAction();
        if (this.checkBeforeCommon(action)) { return }
		__BManager_startAction.call(this);
        this._execBeforeCommon = false;
	};

    BattleManager.checkBeforeCommon = function(action) {
        if (action && !this._execBeforeCommon && DataManager.isBeforeCommon(action.item())){
            this._execBeforeCommon = true;
            var beforeCommon = DataManager.beforeCommonEffect(action.item());
            $gameTemp.reserveCommonEvent(beforeCommon);
            $gameVariables._data[indexVariableId] = this._subject.index();
            if (this._subject.isEnemy()){ $gameVariables._data[indexVariableId] += 1000 }
            this._phase = 'turn';
            return true;
        }
        return false;
    };

    ////////////////////////////////////////////////////////////////////////////////////

    var __GBattler_removeCurrentAction = Game_Battler.prototype.removeCurrentAction;
    Game_Battler.prototype.removeCurrentAction = function () {
        if (!BattleManager._execBeforeCommon){
            __GBattler_removeCurrentAction.call(this);
        }
    };

    ////////////////////////////////////////////////////////////////////////////////////
}());


code:
//=============================================================================
// BordSkin.js
//=============================================================================

/*:ja
 * @plugindesc ver1.00 能力値にステートに設定した定数を加算します。
 * @author まっつＵＰ
 *
 * @help
 *
 * RPGで笑顔を・・・
 *
 * このヘルプとパラメータの説明をよくお読みになってからお使いください。
 *
 * パラメータとプラグインコマンドともにありません。
 * 定数は基本能力値の倍率やバフの倍率によって変わることはありません。
 *
 * ステートのノートタグ
 *
 * <BSparamId:value>
 *
 * 例：atkを100上昇させる。
 * <BS2:100>
 *
 * このプラグインを利用する場合は
 * readmeなどに「まっつＵＰ」の名を入れてください。
 * また、素材のみの販売はダメです。
 * 上記以外の規約等はございません。
 * もちろんツクールMVで使用する前提です。
 * 何か不具合ありましたら気軽にどうぞ。
 *
 * 免責事項：
 * このプラグインを利用したことによるいかなる損害も制作者は一切の責任を負いません。
 *
 */

(function() {

    //var parameters = PluginManager.parameters('BordSkin');

    Game_BattlerBase.prototype.paramPlus2 = function(paramId) { //新規
    var str1 = 'BS' + paramId;
    var amount = 0;
    this._states.forEach(function(stateId) {
      var val1 = Number($dataStates[stateId].meta[str1] || 0);
      if(val1) amount += val1;
    }, this);
     return amount;
    };

    Game_BattlerBase.prototype.param = function(paramId) {
    var value = this.paramBase(paramId) + this.paramPlus(paramId);
    value *= this.paramRate(paramId) * this.paramBuffRate(paramId);
    value += this.paramPlus2(paramId);
    var maxValue = this.paramMax(paramId);
    var minValue = this.paramMin(paramId);
    return Math.round(value.clamp(minValue, maxValue));
    };

})();


code:
/*:
 * @target MV
 * @plugindesc 画像を良い感じに動かすプラグイン
 * @author こぶら
 *
 * @help なんか動くぷらぐいん
 *
 * @param 許可スイッチ
 * @desc 画像をいい感じに再生するスイッチを指定します（初期値：0）
 * @default 0
 * @type switch
 * @min 0
 *
 * @param 移動速度
 * @desc 画像の移動速度を決定します
 * @default 3
 * @type number
 * @min 0.1
 *
 * @param 透過速度
 * @desc 画像の透過速度を決定します
 * @default 3
 * @type number
 * @min 0.1
 *
 * @param bottom画像
 * @desc ボトムに表示する画像　img/pictures/
 * @type file
 * @dir img/pictures
 *
 * @param top画像
 * @desc ボトムに表示する画像　img/pictures/
 * @type file
 * @dir img/pictures
 *
 */

var parameters = PluginManager.parameters('CBR_milk');
var EnableID = Number(parameters['許可スイッチ'] || 0);
var speed = Number(parameters['移動速度'] || 0);
var opaspeed = Number(parameters['透過速度'] || 0);
var bottomPic = String(parameters['bottom画像'] || 0);
var topPic = String(parameters['top画像'] || 0);

//マップが読み込まれた時動くヤツです
const CBRmilk_Scene_Map_start = Scene_Map.prototype.start;
Scene_Map.prototype.start = function() {
    CBRmilk_Scene_Map_start.call(this);

    this._backSprite4 = new Sprite(
        ImageManager.loadPicture(bottomPic)
    );

    this._backSprite5 = new Sprite(
        ImageManager.loadPicture(topPic)
    );
	this.addChild(this._backSprite4);
	this.addChild(this._backSprite5);

	this.CBRmilk_duration = 0;
};

//で、こっちがマップの時毎フレーム動くヤツっす
const CBRmilk_Scene_Map_update = Scene_Map.prototype.update;
Scene_Map.prototype.update = function() {
	CBRmilk_Scene_Map_update.call(this);
	if($gameSwitches.value(EnableID)){
		this._backSprite4.visible = true;//スプライトを見えるようにする
		this._backSprite5.visible = true;//スプライトを見えるようにする
		// 読み易いように変数tにする
		const t = this.CBRmilk_duration;

		//1024で割った余りね、0-1023を繰り返す ()の中でｔの速度を3倍にします
		this._backSprite4.x = (t * speed) % 1024 - 1024;
		this._backSprite5.x = - (t * speed) % 1024;

		// y座標。画像の高さが115の場合は　画面の高さ-画像の高さでbottom
		this._backSprite4.y = Graphics.height - this._backSprite4.height;
		this._backSprite5.y = 0;

		//透明度、0～1ね
		// cosは 1 ～ -1 ～ 1 って動くので便利です。3.14×2で1周
		// cosを÷ 2すると 0.5 ～ - 0.5 ～ 0.5って動きます。そこに+0.5すると 1 ～ 0 ～ 1に！
		this._backSprite4.alpha = Math.cos(3.14*2*(t*opaspeed)/360)/2 + 0.5;
		this._backSprite5.alpha = Math.cos(3.14*2*(t*opaspeed)/360)/2 + 0.5;

		this.CBRmilk_duration++;// +1するよ！って意味、時間を1秒進める
	}else{
		this._backSprite4.visible = false;//このスプライトを見えなくする
		this._backSprite5.visible = false;//このスプライトを見えなくする
	}
};