code:
//=============================================================================
// AltSaveScreen.js
//=============================================================================

/*:
 * @plugindesc Alternative save/load screen layout.
 * @author Yoji Ojima
 *
 * @help This plugin does not provide plugin commands.
 */

/*:ja
 * @plugindesc セーブ／ロード画面のレイアウトを変更します。
 * @author Yoji Ojima
 *
 * @help このプラグインには、プラグインコマンドはありません。
 */

(function() {

    var _Scene_File_create = Scene_File.prototype.create;
    Scene_File.prototype.create = function() {
        _Scene_File_create.call(this);
        this._listWindow.height = this._listWindow.fittingHeight(8);
        var x = 0;
        var y = this._listWindow.y + this._listWindow.height;
        var width = Graphics.boxWidth;
        var height = Graphics.boxHeight - y;
        this._statusWindow = new Window_SavefileStatus(x, y, width, height);
        this._statusWindow.setMode(this.mode());
        this._listWindow.statusWindow = this._statusWindow;
        this._listWindow.callUpdateHelp();
        this.addWindow(this._statusWindow);
    };

    var _Scene_File_start = Scene_File.prototype.start;
    Scene_File.prototype.start = function() {
        _Scene_File_start.call(this);
        this._listWindow.ensureCursorVisible();
        this._listWindow.callUpdateHelp();
    };

    Window_SavefileList.prototype.windowWidth = function() {
        return Graphics.boxWidth;
    };

    Window_SavefileList.prototype.maxCols = function() {
        return 4;
    };

    Window_SavefileList.prototype.numVisibleRows = function() {
        return 5;
    };

    Window_SavefileList.prototype.spacing = function() {
        return 8;
    };

    Window_SavefileList.prototype.itemHeight = function() {
        return this.lineHeight() * 2;
    };

    var _Window_SavefileList_callUpdateHelp =
            Window_SavefileList.prototype.callUpdateHelp;
    Window_SavefileList.prototype.callUpdateHelp = function() {
        _Window_SavefileList_callUpdateHelp.call(this);
        if (this.active && this.statusWindow) {
            this.statusWindow.setId(this.index() + 1);
        }
    };

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

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

    Window_SavefileStatus.prototype.initialize = function(x, y, width, height) {
        Window_Base.prototype.initialize.call(this, x, y, width, height);
        this._id = 1;
    };

    Window_SavefileStatus.prototype.setMode = function(mode) {
        this._mode = mode;
    };

    Window_SavefileStatus.prototype.setId = function(id) {
        this._id = id;
        this.refresh();
    };

    Window_SavefileStatus.prototype.refresh = function() {
        this.contents.clear();
        var id = this._id;
        var valid = DataManager.isThisGameFile(id);
        var info = DataManager.loadSavefileInfo(id);
        var rect = this.contents.rect;
        this.resetTextColor();
        if (this._mode === 'load') {
            this.changePaintOpacity(valid);
        }
        this.drawFileId(id, rect.x, rect.y);
        if (info) {
            this.changePaintOpacity(valid);
            this.drawContents(info, rect, valid);
            this.changePaintOpacity(true);
        }
    };

    Window_SavefileStatus.prototype.drawFileId = function(id, x, y) {
        this.drawText(TextManager.file + ' ' + id, x, y, 180);
    };

    Window_SavefileStatus.prototype.drawContents = function(info, rect, valid) {
        var bottom = rect.y + rect.height;
        var playtimeY = bottom - this.lineHeight();
        this.drawText(info.title, rect.x + 192, rect.y, rect.width - 192);
        if (valid) {
            this.drawPartyfaces(info, rect.x, bottom - 144);
        }
        this.drawText(info.playtime, rect.x, playtimeY, rect.width, 'right');
    };

    Window_SavefileStatus.prototype.drawPartyfaces = function(info, x, y) {
        if (info && info.faces) {
            for (var i = 0; i < info.faces.length; i++) {
                var data = info.faces[i];
                this.drawFace(data[0], data[1], x + i * 150, y);
            }
        }
    };

})();


code:
//=============================================================================
// AudioStreaming.js
// MIT License (C) 2019 くらむぼん
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// 2019/06/02 ループタグの指定範囲が全長を超えた場合のループ処理を修正
// 2019/06/02 デコード結果がない場合にエラーになるのを修正
// 2019/06/15 Windows7のFirefoxでストリーミングが無効なバグの場合、フォールバック
// 2019/06/16 暗号化音声ファイル対応
// 2019/06/22 Safariでサンプルレート8000～22050に対応
// 2019/06/27 Safariで一部音声が二重に流れることがある不具合を修正
// 2019/06/29 Cordovaで動作するように修正
// 2019/10/20 ループタグがない場合に二周目以降の先頭が途切れることがある不具合を修正
//=============================================================================

/*:
 * @plugindesc Load audio faster and use only ogg files.
 * @author krmbn0576
 *
 * @param mode
 * @type select
 * @option Enable
 * @value 10
 * @option Enable, and measure performance
 * @value 11
 * @option Disable
 * @value 00
 * @option Disable, and measure performance
 * @value 01
 * @desc Sets whether audio streaming is enabled, and whether measure performance.
 * @default 10
 *
 * @param deleteM4a
 * @type boolean
 * @text Delete all m4a files
 * @desc Delete all m4a files the next time you playtest. Backup your files before execute.
 * @default false
 *
 * @help
 * Load audio faster by audio streaming whether on browsers or on standalones.
 * Use only ogg files to play the audio such as BGM and SE.
 * You need no longer to prepare m4a files.
 *
 * Usage:
 * Locate stbvorbis_stream.js, stbvorbis_stream_asm.js, and this plugin in plugins directory.
 * Turn ON Only this plugin, but DO NOT register the others to plugin manager.
 *
 *
 * License:
 * MIT License
 *
 * Library:
 * ogg decoder - stbvorbis.js (C) Hajime Hoshi, krmbn0576
 * https://github.com/hajimehoshi/stbvorbis.js
 */

/*:ja
 * @plugindesc 音声読み込みを高速化し、oggファイルのみを使用します。
 * @author くらむぼん
 *
 * @param mode
 * @type select
 * @option 有効
 * @value 10
 * @option 有効（読み込み速度を計測する）
 * @value 11
 * @option 無効
 * @value 00
 * @option 無効（読み込み速度を計測する）
 * @value 01
 * @text モード
 * @desc このプラグインを有効にするかどうか、読み込み速度を計測するかどうかを設定します。
 * @default 10
 *
 * @param deleteM4a
 * @type boolean
 * @text m4aファイルを消去
 * @desc 次にテストプレイを開始した時、すべてのm4aファイルを削除します。念の為バックアップを取った上でご活用ください。
 * @default false
 *
 * @help
 * 音声ストリーミングにより、音声読み込みを高速化します。
 * BGMや効果音などの音声ファイルにoggファイルのみを使用します。
 * 本プラグインを入れている場合、m4aファイルを用意しなくても音声を再生できます。
 *
 * 使い方：
 * pluginsフォルダに本プラグインとstbvorbis_stream.jsとstbvorbis_stream_asm.jsを配置してください。
 * ３つのうち本プラグイン「だけ」をプラグイン管理でONに設定してください。
 * 他の２つはOFFでも構いませんし、プラグイン管理に登録しなくても構いません。
 *
 *
 * ライセンス：
 * このプラグインを利用する時は、作者名をプラグインから削除しないでください。
 * それ以外の制限はありません。お好きなようにどうぞ。
 *
 * 使用ライブラリ：
 * oggデコーダー - stbvorbis.js (C) Hajime Hoshi, くらむぼん
 * https://github.com/hajimehoshi/stbvorbis.js
 */

if (function() {
    'use strict';
    const parameters = PluginManager.parameters('AudioStreaming');
    const enabled = parameters['mode'][0] === '1';
    const measured = parameters['mode'][1] === '1';
    const deleteM4a = parameters['deleteM4a'] === 'true';

    const isTest =
        location.search
            .slice(1)
            .split('&')
            .contains('test') ||
        (typeof window.nw !== 'undefined' &&
            nw.App.argv.length > 0 &&
            nw.App.argv[0].split('&').contains('test'));

    if (deleteM4a && isTest && Utils.isNwjs()) {
        const exec = require('child_process').exec;
        let messages, success, failure;
        if (navigator.language.contains('ja')) {
            messages = [
                'すべてのm4aファイルを削除しますか？',
                '本当に削除しますか？念のため、先にプロジェクトフォルダのバックアップをとっておくことをおすすめします。',
                'こうかいしませんね？'
            ];
            success = 'すべてのm4aファイルを削除しました。';
            failure = 'm4aファイルの削除中にエラーが発生しました。 ';
        } else {
            messages = [
                'Delete all m4a files?',
                'Are you sure?',
                'This cannot be undone. Are you really, REALLY sure?'
            ];
            success = 'All m4a files have been deleted.';
            failure = 'Error occured while deleting m4a files.';
        }
        if (messages.every(message => confirm(message))) {
            const command =
                process.platform === 'win32'
                    ? 'del /s *.m4a'
                    : 'find . -name "*.m4a" -delete';
            exec(command, error => alert(error ? failure : success));
        }
    }

    if (measured) {
        const div = document.createElement('div');
        div.style.backgroundColor = 'AliceBlue';
        div.style.position = 'fixed';
        div.style.left = 0;
        div.style.bottom = 0;
        document.body.appendChild(div);

        const updateInfo = info => {
            const decodeEndTime = Date.now();
            const content = `
                name: ${info.url.split('/').pop()}

                mode: ${enabled ? 'streaming' : 'legacy'}

                load time: ${info.loadEndTime - info.loadStartTime}ms

                decode time: ${decodeEndTime - info.loadEndTime}ms
`;

            if (div.innerHTML !== content) div.innerHTML = content;
            div.style.zIndex = 11;
        };

        const _SceneManager_updateManagers = SceneManager.updateManagers;
        SceneManager.updateManagers = function() {
            const _WebAudio__load = WebAudio.prototype._load;
            WebAudio.prototype._load = function(url) {
                _WebAudio__load.apply(this, arguments);
                this._info = { url, loadStartTime: Date.now() };
                this.addLoadListener(() => updateInfo(this._info));
            };

            const _WebAudio__readLoopComments =
                WebAudio.prototype._readLoopComments;
            WebAudio.prototype._readLoopComments = function() {
                this._info.loadEndTime = this._info.loadEndTime || Date.now();
                _WebAudio__readLoopComments.apply(this, arguments);
            };

            SceneManager.updateManagers = _SceneManager_updateManagers;
            SceneManager.updateManagers.apply(this, arguments);
        };
    }

    return enabled;
}()) {

PluginManager.loadScript('stbvorbis_stream.js');

AudioManager.audioFileExt = function() {
    return '.ogg';
};

fetch('').catch(_ => window.cordova = window.cordova || true);

if (window.ResourceHandler) {
    ResourceHandler.fetchWithRetry = async function(
        method,
        url,
        _retryCount = 0
    ) {
        let retry;
        try {
            const response = await (!window.cordova ?
                fetch(url, { credentials: 'same-origin' }) :
                new Promise((resolve, reject) => {
                    const xhr = new XMLHttpRequest();
                    xhr.responseType = 'blob';
                    xhr.onload = () => resolve(new Response(xhr.response, { status: xhr.status }));
                    xhr.onerror = reject;
                    xhr.open('GET', url);
                    xhr.send();
                })
            );
            if (response.ok) {
                switch (method) {
                    case 'stream':
                        if (response.body) {
                            return response.body.getReader();
                        }
                        const value = new Uint8Array(await response.arrayBuffer());
                        return {
                            _done: false,
                            read() {
                                if (!this._done) {
                                    this._done = true;
                                    return Promise.resolve({ done: false, value });
                                } else {
                                    return Promise.resolve({ done: true });
                                }
                            }
                        };
                    case 'arrayBuffer':
                    case 'blob':
                    case 'formData':
                    case 'json':
                    case 'text':
                        return await response[method]();
                    default:
                        return Promise.reject(new Error('method not allowed'));
                }
            } else if (response.status < 500) {
                // client error
                retry = false;
            } else {
                // server error
                retry = true;
            }
        } catch (error) {
            if (Utils.isNwjs() || window.cordova) {
                // local file error
                retry = false;
            } else {
                // network error
                retry = true;
            }
        }
        if (!retry) {
            const error = new Error('Failed to load: ' + url);
            SceneManager.catchException(error);
            throw error;
        } else if (_retryCount < this._defaultRetryInterval.length) {
            await new Promise(resolve =>
                setTimeout(resolve, this._defaultRetryInterval[_retryCount])
            );
            return this.fetchWithRetry(method, url, _retryCount + 1);
        } else {
            if (this._reloaders.length === 0) {
                Graphics.printLoadingError(url);
                SceneManager.stop();
            }
            return new Promise(resolve =>
                this._reloaders.push(() =>
                    resolve(this.fetchWithRetry(method, url, 0))
                )
            );
        }
    };
}

WebAudio.prototype.clear = function() {
    this.stop();
    this._chunks = [];
    this._gainNode = null;
    this._pannerNode = null;
    this._totalTime = 0;
    this._sampleRate = 0;
    this._loopStart = 0;
    this._loopLength = 0;
    this._startTime = 0;
    this._volume = 1;
    this._pitch = 1;
    this._pan = 0;
    this._loadedTime = 0;
    this._offset = 0;
    this._loadListeners = [];
    this._stopListeners = [];
    this._hasError = false;
    this._autoPlay = false;
    this._isReady = false;
    this._isPlaying = false;
    this._loop = false;
};

WebAudio.prototype._load = async function(url) {
    if (WebAudio._context) {
        if (Decrypter.hasEncryptedAudio) {
            url = Decrypter.extToEncryptExt(url);
        }
        const reader = await ResourceHandler.fetchWithRetry('stream', url);
        this._loading(reader);
    }
};

WebAudio.prototype._loading = async function(reader) {
    try {
        const decode = stbvorbis.decodeStream(result => this._onDecode(result));
        while (true) {
            const { done, value } = await reader.read();
            if (done) {
                decode({ eof: true });
                return;
            }
            let array = value;
            if (Decrypter.hasEncryptedAudio) {
                array = Decrypter.decryptUint8Array(array);
            }
            this._readLoopComments(array);
            decode({ data: array, eof: false });
        }
    } catch (error) {
        console.error(error);
        const autoPlay = this._autoPlay;
        const loop = this._loop;
        const pos = this.seek();
        this.initialize(this._url);
        if (autoPlay) {
            this.play(loop, pos);
        }
    }
};

WebAudio.prototype._onDecode = function(result) {
    if (result.error) {
        console.error(result.error);
        return;
    }
    if (result.eof) {
        this._totalTime = this._loadedTime;
        if (this._loopLength === 0) {
            this._loopStart = 0;
            this._loopLength = this._totalTime;
            if (this._loop) {
                this._createSourceNodes();
            }
        } else if (this._totalTime < this._loopStart + this._loopLength) {
            this._loopLength = this._totalTime - this._loopStart;
            if (this._loop) {
                this._createSourceNodes();
            }
        }
        if (this._totalTime <= this.seek()) {
            this.stop();
        }
        return;
    }
    if (result.data[0].length === 0) {
        return;
    }
    let buffer;
    try {
        buffer = WebAudio._context.createBuffer(
            result.data.length,
            result.data[0].length,
            result.sampleRate
        );
    } catch (error) {
        if (8000 <= result.sampleRate && result.sampleRate < 22050) {
            result.sampleRate *= 3;
            for (let i = 0; i < result.data.length; i++) {
                const old = result.data[i];
                result.data[i] = new Float32Array(result.data[i].length * 3);
                for (let j = 0; j < old.length; j++) {
                    result.data[i][j * 3] = old[j];
                    result.data[i][j * 3 + 1] = old[j];
                    result.data[i][j * 3 + 2] = old[j];
                }
            }
            buffer = WebAudio._context.createBuffer(
                result.data.length,
                result.data[0].length,
                result.sampleRate
            );
        } else {
            throw error;
        }
    }
    for (let i = 0; i < result.data.length; i++) {
        if (buffer.copyToChannel) {
            buffer.copyToChannel(result.data[i], i);
        } else {
            buffer.getChannelData(i).set(result.data[i]);
        }
    }
    const chunk = { buffer, sourceNode: null, when: this._loadedTime };
    this._chunks.push(chunk);
    this._loadedTime += buffer.duration;
    this._createSourceNode(chunk);
    if (!this._isReady && this._loadedTime >= this._offset) {
        this._isReady = true;
        this._onLoad();
    }
};

Object.defineProperty(WebAudio.prototype, 'pitch', {
    get: function() {
        return this._pitch;
    },
    set: function(value) {
        if (this._pitch !== value) {
            this._pitch = value;
            if (this.isPlaying()) {
                this.play(this._loop, 0);
            }
        }
    },
    configurable: true
});

WebAudio.prototype.isReady = function() {
    return this._isReady;
};

WebAudio.prototype.isPlaying = function() {
    return this._isPlaying;
};

WebAudio.prototype.play = function(loop, offset) {
    this._autoPlay = true;
    this._loop = loop;
    this._offset = offset || 0;
    if (this._loop && this._loopLength > 0) {
        while (this._offset >= this._loopStart + this._loopLength) {
            this._offset -= this._loopLength;
        }
    }
    if (this.isReady()) {
        this._startPlaying();
    }
};

WebAudio.prototype.stop = function() {
    const wasPlaying = this.isPlaying();
    this._isPlaying = false;
    this._autoPlay = false;
    this._removeNodes();
    if (this._stopListeners && wasPlaying) {
        this._stopListeners.forEach(listener => listener());
        this._stopListeners.length = 0;
    }
};

WebAudio.prototype.seek = function() {
    if (WebAudio._context && this.isPlaying()) {
        let pos =
            (WebAudio._context.currentTime - this._startTime) * this._pitch;
        if (this._loop && this._loopLength > 0) {
            while (pos >= this._loopStart + this._loopLength) {
                pos -= this._loopLength;
            }
        }
        return pos;
    } else {
        return 0;
    }
};

WebAudio.prototype._startPlaying = function() {
    this._isPlaying = true;
    this._startTime =
        WebAudio._context.currentTime - this._offset / this._pitch;
    this._removeNodes();
    this._createNodes();
    this._connectNodes();
    this._createSourceNodes();
};

WebAudio.prototype._calcSourceNodeParams = function(chunk) {
    const currentTime = WebAudio._context.currentTime;
    const chunkEnd = chunk.when + chunk.buffer.duration;
    const pos = this.seek();
    let when, offset, duration;
    if (this._loop && this._loopLength) {
        const loopEnd = this._loopStart + this._loopLength;
        if (pos <= chunk.when) {
            when = currentTime + (chunk.when - pos) / this._pitch;
        } else if (pos <= (window.AudioContext ? chunkEnd : chunkEnd - 0.0001)) {
            when = currentTime;
            offset = pos - chunk.when;
        } else if (this._loopStart <= pos) {
            when =
                currentTime +
                (chunk.when - pos + this._loopLength) / this._pitch;
        } else {
            return;
        }
        if (this._loopStart <= pos && chunk.when < this._loopStart) {
            if (!offset) {
                when += (this._loopStart - chunk.when) / this._pitch;
                offset = this._loopStart - chunk.when;
            }
            if (chunk.buffer.duration <= offset) {
                return;
            }
        }
        if (loopEnd < chunkEnd) {
            if (!offset) {
                offset = 0;
            }
            duration = loopEnd - chunk.when - offset;
            if (duration <= 0) {
                return;
            }
        }
    } else {
        if (pos <= chunk.when) {
            when = currentTime + (chunk.when - pos) / this._pitch;
        } else if (pos <= (window.AudioContext ? chunkEnd : chunkEnd - 0.0001)) {
            when = currentTime;
            offset = pos - chunk.when;
        } else {
            return;
        }
    }
    return { when, offset, duration };
};

WebAudio.prototype._createSourceNode = function(chunk) {
    if (!this.isPlaying() || !chunk) {
        return;
    }
    if (chunk.sourceNode) {
        chunk.sourceNode.onended = null;
        chunk.sourceNode.stop();
        chunk.sourceNode = null;
    }
    const params = this._calcSourceNodeParams(chunk);
    if (!params) {
        if (!this._reservedSeName && this._loopLength) {
            this._chunks[this._chunks.indexOf(chunk)] = null;
        }
        return;
    }
    const { when, offset, duration } = params;
    const context = WebAudio._context;
    const sourceNode = context.createBufferSource();
    sourceNode.onended = _ => {
        this._createSourceNode(chunk);
        if (this._totalTime && this._totalTime <= this.seek()) {
            this.stop();
        }
    };
    sourceNode.buffer = chunk.buffer;
    sourceNode.playbackRate.setValueAtTime(this._pitch, context.currentTime);
    sourceNode.connect(this._gainNode);
    sourceNode.start(when, offset, duration);
    chunk.sourceNode = sourceNode;
};

WebAudio.prototype._createSourceNodes = function() {
    this._chunks.forEach(chunk => this._createSourceNode(chunk));
};

WebAudio.prototype._createNodes = function() {
    const context = WebAudio._context;
    this._gainNode = context.createGain();
    this._gainNode.gain.setValueAtTime(this._volume, context.currentTime);
    this._pannerNode = context.createPanner();
    this._pannerNode.panningModel = 'equalpower';
    this._updatePanner();
};

WebAudio.prototype._connectNodes = function() {
    this._gainNode.connect(this._pannerNode);
    this._pannerNode.connect(WebAudio._masterGainNode);
};

WebAudio.prototype._removeNodes = function() {
    if (this._chunks) {
        this._chunks
            .filter(chunk => chunk && chunk.sourceNode)
            .forEach(chunk => {
                chunk.sourceNode.onended = null;
                chunk.sourceNode.stop();
                chunk.sourceNode = null;
            });
    }
    this._gainNode = null;
    this._pannerNode = null;
};

WebAudio.prototype._onLoad = function() {
    if (this._autoPlay) {
        this.play(this._loop, this._offset);
    }
    this._loadListeners.forEach(listener => listener());
    this._loadListeners.length = 0;
};

WebAudio.prototype._readLoopComments = function(array) {
    if (this._sampleRate === 0) {
        this._readOgg(array);
        if (this._loopLength > 0 && this._sampleRate > 0) {
            this._loopStart /= this._sampleRate;
            this._loopLength /= this._sampleRate;
        }
    }
};

Decrypter.decryptUint8Array = function(uint8Array) {
    const ref = this.SIGNATURE + this.VER + this.REMAIN;
    for (let i = 0; i < this._headerlength; i++) {
        if (uint8Array[i] !== parseInt('0x' + ref.substr(i * 2, 2), 16)) {
            return uint8Array;
        }
    }
    uint8Array = new Uint8Array(uint8Array.buffer, this._headerlength);
    this.readEncryptionkey();
    for (var i = 0; i < this._headerlength; i++) {
        uint8Array[i] = uint8Array[i] ^ parseInt(this._encryptionKey[i], 16);
    }
    return uint8Array;
};

}

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// AutoBattle.js
// ----------------------------------------------------------------------------
// (C) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.0.1 2018/12/30 コマンド位置の指定のパラメータ設定が一部正常に機能していなかった問題を修正
// 1.0.0 2016/09/29 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc AutoBattlePlugin
 * @author triacontane
 *
 * @param PartyCommandName
 * @desc Auto battle command name for Window party command.
 * @default Auto
 *
 * @param PartyCommandIndex
 * @desc Auto battle command index for Window party command.
 * @default -1
 *
 * @param ActorCommandName
 * @desc Auto battle command name for Window actor command.
 * @default Auto
 *
 * @param ActorCommandIndex
 * @desc Auto battle command index for Window actor command.
 * @default -1
 *
 * @help Auto battle system added.
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 自動戦闘プラグイン
 * @author トリアコンタン
 *
 * @param パーティコマンド名称
 * @desc パーティコマンドに追加される一括オートコマンドの名称です。未入力にすると追加されません。
 * @default オート
 *
 * @param パーティコマンド位置
 * @desc パーティコマンドでオートコマンドが追加される位置です。-1の場合、末尾に追加されます。
 * @default -1
 *
 * @param アクターコマンド名称
 * @desc アクターコマンドに追加される個別オートコマンドの名称です。未入力にすると追加されません。
 * @default オート
 *
 * @param アクターコマンド位置
 * @desc アクターコマンドでオートコマンドが追加される位置です。-1の場合、末尾に追加されます。
 * @default -1
 *
 * @help アクターの行動を自動選択するオートバトルを実装します。
 *
 * １．パーティコマンドからオートを選択すると、アクターコマンドの選択をスキップして全員
 * オートバトルになります。
 *
 * ２．アクターコマンドからオートを選択すると、対象アクターのみオートバトルになります。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function() {
    'use strict';
    var pluginName = 'AutoBattle';

    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 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 paramPartyCommandName  = getParamString(['PartyCommandName', 'パーティコマンド名称']);
    var paramPartyCommandIndex = getParamNumber(['PartyCommandIndex', 'パーティコマンド位置']);
    var paramActorCommandName  = getParamString(['ActorCommandName', 'アクターコマンド名称']);
    var paramActorCommandIndex = getParamNumber(['ActorCommandIndex', 'アクターコマンド位置']);

    //=============================================================================
    // BattleManager
    //  オートバトルの実装を追加定義します。
    //=============================================================================
    BattleManager.processActorAuto = function() {
        this.actor().makeAutoBattleActions();
    };

    BattleManager.processPartyAuto = function() {
        $gameParty.members().forEach(function(member) {
            member.makeAutoBattleActions();
        });
        this.startTurn();
    };

    //=============================================================================
    // Scene_Battle
    //  オートバトルコマンドを選択した場合の処理を追加定義します。
    //=============================================================================
    var _Scene_Battle_createPartyCommandWindow      = Scene_Battle.prototype.createPartyCommandWindow;
    Scene_Battle.prototype.createPartyCommandWindow = function() {
        _Scene_Battle_createPartyCommandWindow.apply(this, arguments);
        if (paramPartyCommandName) {
            this._partyCommandWindow.setHandler('auto', this.commandPartyAutoBattle.bind(this));
        }
    };

    var _Scene_Battle_createActorCommandWindow      = Scene_Battle.prototype.createActorCommandWindow;
    Scene_Battle.prototype.createActorCommandWindow = function() {
        _Scene_Battle_createActorCommandWindow.apply(this, arguments);
        if (paramActorCommandName) {
            this._actorCommandWindow.setHandler('auto', this.commandActorAutoBattle.bind(this));
        }
    };

    Scene_Battle.prototype.commandPartyAutoBattle = function() {
        BattleManager.processPartyAuto();
        this.changeInputWindow();
    };

    Scene_Battle.prototype.commandActorAutoBattle = function() {
        BattleManager.processActorAuto();
        this.selectNextCommand();
    };

    //=============================================================================
    // Window_PartyCommand
    //  オートバトルコマンドを追加します。
    //=============================================================================
    var _Window_PartyCommand_makeCommandList      = Window_PartyCommand.prototype.makeCommandList;
    Window_PartyCommand.prototype.makeCommandList = function() {
        _Window_PartyCommand_makeCommandList.apply(this, arguments);
        if (paramPartyCommandName) this.addAutoCommand();
    };

    Window_PartyCommand.prototype.addAutoCommand = function() {
        this.addCommand(paramPartyCommandName, 'auto');
        if (this._list[paramPartyCommandIndex]) {
            var command = this._list.pop();
            this._list.splice(paramPartyCommandIndex, 0, command);
        }
    };

    //=============================================================================
    // Window_ActorCommand
    //  オートバトルコマンドを追加します。
    //=============================================================================
    var _Window_ActorCommand_makeCommandList      = Window_ActorCommand.prototype.makeCommandList;
    Window_ActorCommand.prototype.makeCommandList = function() {
        _Window_ActorCommand_makeCommandList.apply(this, arguments);
        if (this._actor && paramActorCommandName) {
            this.addAutoCommand();
        }
    };

    Window_ActorCommand.prototype.addAutoCommand = function() {
        this.addCommand(paramActorCommandName, 'auto');
        if (this._list[paramActorCommandIndex]) {
            var command = this._list.pop();
            this._list.splice(paramActorCommandIndex, 0, command);
        }
    };
})();


code:
//=============================================================================
// BB_EnemyPositionYMax.js
// Copyright (c) 2017 BB ENTERTAINMENT
//=============================================================================

/*:
 * @plugindesc 戦闘時の敵グラフィック配置範囲を画面下端まで拡大or移動できるようにするプラグイン。
 * @author ビービー
 *
 * @param Fit_or_Slide
 * @type boolean
 * @desc 敵配置範囲の高さを拡大するか移動する(ずらす)か。
 * true(ON) = 配置範囲拡大　false(OFF) = 配置範囲移動
 * @default true
 *
 * @param CanNot_Fit_or_Slide
 * @type boolean
 * @desc このプラグインが上手く動作しない時にONにしてみてください。
 * ONで処理する場所を変更。
 * @default false
 *
 * @help 【プラグインの説明】
 * 戦闘時の敵グラフィック配置範囲を画面下端まで
 * 拡大or移動できるようにするプラグイン。
 *
 * 拡大：
 * エディター上で配置した位置の高さを1.42倍した位置に敵を配置します。
 * エディター上で配置した敵同士の感覚が変わりますが、
 * 画面最上部まで敵を配置できます。
 *
 * 移動：
 * エディター上で配置した位置の高さに180pxを足した位置に敵を配置します。
 * 画面最上部への配置ができなくなりますが、
 * エディター上で設定した敵同士の配置間隔は変わりません。
 *
 * 【パラメータ】
 * ◆Fit_or_Slide
 * 敵配置範囲の高さを拡大するか移動する(ずらす)かを選択できます。
 * true(ON) = 配置範囲拡大　false(OFF) = 配置範囲移動
 *
 *
 * 【利用規約】
 * このプラグインは、MITライセンスのもとで公開されています。
 * Copyright (c) 2017 BB ENTERTAINMENT
 * Released under the MIT License.
 * http://opensource.org/licenses/mit-license.php
 *
 * コンタクト：
 * BB ENTERTAINMENT Twitter: https://twitter.com/BB_ENTER/
 * BB ENTERTAINMENT BLOG   : http://bb-entertainment-blog.blogspot.jp/
 */

(function() {
    'use strict';
//-----------------------------------------------------------------------------
// プラグインパラメータ管理
    var parameters = PluginManager.parameters('BB_EnemyPositionYMax');
    var BBEPYM = (parameters['Fit_or_Slide'] == "true");
    var BBEPYM2 = (parameters['CanNot_Fit_or_Slide'] == "false");

    var _Sprite_Enemy_updatePosition = Sprite_Enemy.prototype.updatePosition;
    Sprite_Enemy.prototype.updatePosition = function() {
        _Sprite_Enemy_updatePosition.apply(this);
        if (BBEPYM2) {
            if (BBEPYM) {
                this.y = this.y * 1.42;
            } else {
                this.y += 180;
            }
        }
    };

    var _Sprite_Enemy_prototype_setBattler = Sprite_Enemy.prototype.setBattler;
    Sprite_Enemy.prototype.setBattler = function(battler) {
        Sprite_Battler.prototype.setBattler.call(this, battler);
        this._enemy = battler;
        if (!BBEPYM2) {
            if (BBEPYM) {
                this.setHome(battler.screenX(), battler.screenY() * 1.42);
            } else {
                this.setHome(battler.screenX(), battler.screenY() + 180);
            }
        } else {
            this.setHome(battler.screenX(), battler.screenY());
        }
        this._stateIconSprite.setup(battler);
    };

})();


code:
//=============================================================================
// BMSP_MapFog.js (マップフォグ)
//=============================================================================

/*:
 * @plugindesc マップにフォグを表示します。
 * @author gentlawk
 * @website http://blueredzone.com
 * @url https://github.com/gentlawk/BMSP_MV
 * @license
 * Copyright(c) 2015 BlueRedZone, gentlawk
 * Released under the MIT license
 * https://github.com/gentlawk/BMSP_MV/blob/master/LICENSE
 *
 * @version 1.03
 *
 * @param Label
 * @desc マップフォグメモのラベルです。
 * @default フォグ
 *
 * @help
 * マップのメモ:
 *   <フォグ%n%:%name%, %sx%, %sy%, %opacity%, %z%, %blend%, %switchies%>  # マップにフォグを追加します。
 *     - %n% : フォグの番号です。1以上の整数を指定してください。
 *     - %name% : 使用するファイル名です。(初期値: '')
 *     - %sx% : X方向のスピードです。(初期値: 0)
 *     - %sy% : Y方向のスピードです。(初期値: 0)
 *     - %opacity% : 不透明度です。(初期値: 255)
 *     - %z% : Z座標です。0が遠景直上、1がピクチャ直下、2がピクチャ直上です。(初期値: 1)
 *     - %blend% : 合成方法です。0が通常、1が加算です。(初期値: 1)
 *     - %switchies% : 表示条件スイッチIDリストです。条件にしたいスイッチのIDを「:」区切りで指定します。(初期値: 指定無し※常に表示)
 *   ※メモのラベルはパラメータで変更可能です。
 *   ※フォグ番号はマップごとに1から順番に存在しなければなりません。
 *   ※%n%以外の各パラメータは省略可能です。省略した場合初期値が使用されます。
 *   　また、省略したパラメータ以降のパラメータも全て省略しなければなりません。
 *
 * プラグインコマンド:
 *   MapFog %n% name %value% # フォグ番号%n%に使用するファイルを%value%に変更します。
 *   MapFog %n% sx %value% # フォグ番号%n%のX方向速度を%value%に変更します。
 *   MapFog %n% sy %value% # フォグ番号%n%のY方向速度を%value%に変更します。
 *   MapFog %n% opacity %value% # フォグ番号%n%の不透明度を%value%に変更します。
 *   MapFog %n% blend %value% # フォグ番号%n%の合成方法を%value%に変更します。
 *   MapFog %n% visible %value% # フォグ番号%n%を%value%が1で表示、0で非表示にします。
 *
 * 使用方法:
 *   マップのメモにフォグ設定を記述すると、マップにフォグを表示できます。
 *   1つのマップに表示するフォグの数は任意ですが、フォグ番号は1から順番にふる必要があります。
 *   フォグの表示条件はマップ移動時のみ判定されます。
 *   同一マップ上でフォグの表示を切り替える場合はプラグインコマンドを使用して下さい。
 *   マップフォグ画像は以下のディレクトリに配置してください(fogsディレクトリは新規作成してください)。
 *   img/fogs
 *
 * ●使用例
 *   フォグを表示
 *     <フォグ1:fogfile>
 *
 *   フォグを2つ表示
 *     <フォグ1:fogfile1,1,0,255>
 *     <フォグ2:fogfile2,0,0,255,0,0>
 *
 *   スイッチ10がONの時フォグを表示
 *     <フォグ1:fogfile,0,0,255,1,1,10>
 *
 *   スイッチ10がONの時フォグ1を、スイッチ10と20がONの時フォグ2を表示
 *     <フォグ1:fogfile1,0,0,255,1,1,10>
 *     <フォグ2:fogfile2,0,0,255,1,1,10:20>
 */

(function() {

    /*
     * プラグインバージョン
     */
    PluginManager.setVersion('BMSP_MapFog', 1.03);

    /*
     * 必須プラグインチェック
     */
    var _Scene_Boot_start = Scene_Boot.prototype.start;
    Scene_Boot.prototype.start = function () {
        BMSP.requirePlugin('BMSP', 1.00);
        _Scene_Boot_start.call(this);
    };

    /*
     * プラグインコマンド
     */
    var _Game_Interpreter_pluginCommand =
            Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === 'MapFog') {
            $gameMap.setFogParameter(args[1], Number(args[0]), args[2]);
        }
    };

    /*
     * MapFog
     */
    BMSP.MapFog = function() {
        throw new Error('This is a static class');
    };

    var parameters = PluginManager.parameters('BMSP_MapFog');
    BMSP.MapFog._label  = parameters['Label'];

    BMSP.MapFog._cache_settings = {};

    BMSP.MapFog.getSettings = function(map) {
        var objectId = BMSP.getObjectId(map);
        if(objectId in this._cache_settings){
            return this._cache_settings[objectId];
        }
        var index = 1;
        var settings = {};
        while((this._label + index) in map.meta){
            settings[index] = map.meta[this._label + index].split(',');
            index++;
        }
        this._cache_settings[objectId] = settings;
        return settings;
    };

    BMSP.MapFog.getSprite = function(index) {
        if(!SceneManager._scene || SceneManager._scene.constructor !== Scene_Map) {
            return null;
        }
        var fogData = SceneManager._scene._spriteset._fogData;
        for(var i in fogData) {
            var data = fogData[i];
            if(data.index == index) return data.sprite;
        }
        return null;
    };

    /*
     * ImageManager
     */
    ImageManager.loadFog = function(filename, hue) {
        return this.loadBitmap('img/fogs/', filename, hue, true);
    };

    var _Game_Map_setup = Game_Map.prototype.setup;
    Game_Map.prototype.setup = function(mapId) {
        _Game_Map_setup.call(this, mapId);
        this.setupFogs();
    };

    Game_Map.prototype.setupFogs = function() {
        this._fogs = {};
        var settings = BMSP.MapFog.getSettings($dataMap);
        for(var index in settings) {
            var setting = settings[index];
            var cond = (setting[6] || '').split(':');
            var visible = true;
            if(cond[0] !== '') {
                visible = cond.every(function(id) {
                    return $gameSwitches.value(id);
                });
            }
            this._fogs[index] = {
                name:    setting[0] || '',
                sx:      Number(setting[1] || 0),
                sy:      Number(setting[2] || 0),
                opacity: Number(setting[3] || 255),
                z:       Number(setting[4] || 1),
                blend:   Number(setting[5] || 1),
                visible: visible,
                x:       0,
                y:       0,
            }
        }
    };

    Game_Map.prototype.fogs = function() {
        return this._fogs;
    }

    var _Game_Map_update = Game_Map.prototype.update;
    Game_Map.prototype.update = function(sceneActive) {
        _Game_Map_update.call(this, sceneActive);
        this.updateFogs();
    };

    Game_Map.prototype.updateFogs = function() {
        for(var index in this._fogs) {
            this._fogs[index].x += this._fogs[index].sx;
            this._fogs[index].y += this._fogs[index].sy;
        }
    };

    Game_Map.prototype.setFogParameter = function(name, index, value) {
        if(!(index in this._fogs)) return;
        if(value === undefined) return;
        var fog = this._fogs[index];
        switch(name) {
            case 'name':
                fog[name] = value;
                break;
            case 'sx':
            case 'sy':
            case 'opacity':
            case 'blend':
                fog[name] = Number(value);
                break;
            case 'visible':
                fog[name] = Boolean(Number(value));
                break;
        }
    };

    /*
     * Spriteset_Map
     */
    var _Spriteset_Map_initialize = Spriteset_Map.prototype.initialize;
    Spriteset_Map.prototype.initialize = function() {
        this._fogContainer = [];
        this._fogData = [];
        _Spriteset_Map_initialize.call(this);
    };

    var _Spriteset_Map_createParallax = Spriteset_Map.prototype.createParallax;
    Spriteset_Map.prototype.createParallax = function() {
        _Spriteset_Map_createParallax.call(this);
        this.createFogs(0);
    };

    var _Spriteset_Map_createPictures = Spriteset_Map.prototype.createPictures;
    Spriteset_Map.prototype.createPictures = function() {
        this.createFogs(1);
        _Spriteset_Map_createPictures.call(this);
        this.createFogs(2);
    };

    var _Spriteset_Map_update = Spriteset_Map.prototype.update;
    Spriteset_Map.prototype.update = function() {
        _Spriteset_Map_update.call(this);
        this.updateFogs();
    };

    Spriteset_Map.prototype.createFogs = function(z) {
        this._fogContainer[z] = new Sprite();
        var fogs = $gameMap.fogs();
        for(var index in fogs) {
            if(fogs[index].z !== z) continue;

            var fogSprite = new TilingSprite();
            fogSprite.move(0, 0, Graphics.width, Graphics.height);
            this._fogContainer[z].addChild(fogSprite);
            this._fogData.push({
                index: index,
                sprite: fogSprite,
                name: null,
            });
        }
        if(z === 2) {
            this.addChild(this._fogContainer[z]);
        } else {

            this._baseSprite.addChild(this._fogContainer[z]);
        }
    };

    Spriteset_Map.prototype.updateFogs = function() {
        var fogs = $gameMap.fogs();
        this._fogData.forEach(function(data) {
            var fog = fogs[data.index];
            var sprite = data.sprite;
            if(data.name !== fog.name) {
                data.name = fog.name;
                sprite.bitmap = ImageManager.loadFog(data.name);
            }
            if(sprite.bitmap) {
                sprite.origin.x = fog.x;
                sprite.origin.y = fog.y;
                sprite.opacity = fog.opacity;
                sprite.visible = fog.visible;
                sprite.blendMode = fog.blend;
            }
        }, this);
    };

})();


code:
//=============================================================================
// Battle_Command_Extend.js
//=============================================================================

/*:
 * @plugindesc パーティーコマンドの非表示やアクターコマンドを編集できます。
 * @author 村人C
 *
 * @help
 *
 * 使い方
 * プラグインコマンド：
 * Battle_Command_Extend 変更する箇所 フラグ
 *
 * 変更する箇所のパラメータ
 * Party   Attack   Skill   Guard    Item
 * Auto    Repeat   Escape
 *
 * フラグ
 * 有効： on
 * 無効： off
 *
 * 例： Battle_Command_Extend Skill on
 * スキルを非表示にします。
 *
 * プラグインパラメータ：
 * 有効： on
 * 無効： off
 *
 * コマンドの並び順
 * 先頭のものほど上に表示されます。
 * 攻撃：  attack   スキル： skill   防御： guard    アイテム： item
 * 逃げる： escape   オート： auto    リピート： repeat
 *
 * オート
 * １ターンのみ個別に自動戦闘にします。
 *
 * リピート
 * 前のターンと同じ行動を取ります。
 *
 * Command_Flag
 * コマンドウインドウを自動でサイズ調整します。
 *
 * PT_Flag
 * パーティーコマンド非表示
 * on の場合、「逃げる」をアクターコマンドに追加します。
 *
 * Attack_Flag
 * 「攻撃」を非表示
 *
 * Skill_Flag
 * 「スキル」を非表示
 *
 * Guard_Flag
 * 「防御」を非表示
 *
 * Item_Flag
 * 「アイテム」を非表示
 *
 * Auto_Flag
 * 「オート」を非表示
 *
 * Repeat_Flag
 * 「リピート」を非表示
 *
 * Escape_Flag
 * 「逃げる」を非表示
 *
 *
 * 仕様
 * プラグインコマンドの大文字、小文字を間違えると正しく動作しません。
 * 「スキル」が非表示の場合に「オート」を選ぶと「通常攻撃」が選択されます。
 * パーティーコマンド時の「オート」は全アクターに適用されます。
 * 戦闘開始時に「リピート」を選択した場合、全アクターの行動が通常攻撃になります。
 * 「リピート」の判定はターン開始時です。ターン開始後、使用不可になった場合は行動しません。
 * ターン開始時に前のターンと同じ行動がコスト不足等で実行できない場合は通常攻撃になります。
 *
 * readmeやスタッフロールの明記、使用報告は任意
 *
 *
 * @param Auto
 * @desc 「オート」
 * デフォルト: オート
 * @default オート
 *
 * @param Repeat
 * @desc 「リピート」
 * デフォルト: リピート
 * @default リピート
 *
 * @param Command
 * @desc コマンドの並び
 * デフォルト: attack skill guard item auto repeat escape
 * @default attack skill guard item auto repeat escape
 *
 * @param Command_Flag
 * @desc コマンドのサイズを自動変更
 * デフォルト: on
 * @default on
 *
 * @param PT_Flag
 * @desc パーティーコマンド非表示
 * デフォルト: on
 * @default on
 *
 * @param Attack_Flag
 * @desc 「攻撃」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Skill_Flag
 * @desc 「スキル」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Guard_Flag
 * @desc 「防御」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Item_Flag
 * @desc 「アイテム」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Auto_Flag
 * @desc 「オート」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Repeat_Flag
 * @desc 「リピート」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Escape_Flag
 * @desc 「逃げる」を非表示
 * デフォルト: off
 * @default off
 *
 */

var Battle_Command_Extend  = Battle_Command_Extend || {};
Battle_Command_Extend.Flag = []; // 格納用に配列の作成
Battle_Command_Extend.Parameters = PluginManager.parameters('Battle_Command_Extend');
// 初期設定
Battle_Command_Extend.Command  = Battle_Command_Extend.Parameters["Command"] || "attack skill guard item escape";
Battle_Command_Extend.Flag[0]  = Battle_Command_Extend.Parameters["PT_Flag"] || "on";
Battle_Command_Extend.Flag[1]  = Battle_Command_Extend.Parameters["Attack_Flag"]  || "off";
Battle_Command_Extend.Flag[2]  = Battle_Command_Extend.Parameters["Skill_Flag"]   || "off";
Battle_Command_Extend.Flag[3]  = Battle_Command_Extend.Parameters["Guard_Flag"]   || "off";
Battle_Command_Extend.Flag[4]  = Battle_Command_Extend.Parameters["Item_Flag"]    || "off";
Battle_Command_Extend.Flag[5]  = Battle_Command_Extend.Parameters["Command_Flag"] || "on";
Battle_Command_Extend.Flag[6]  = Battle_Command_Extend.Parameters["Auto_Flag"]    || "off";
Battle_Command_Extend.Flag[7]  = Battle_Command_Extend.Parameters["Repeat_Flag"]  || "off";
Battle_Command_Extend.Flag[8]  = Battle_Command_Extend.Parameters["Auto"]    || "オート";
Battle_Command_Extend.Flag[9]  = Battle_Command_Extend.Parameters["Repeat"]  || "リピート";
Battle_Command_Extend.Flag[10] = Battle_Command_Extend.Parameters["Escape_Flag"]  || "off";

(function() {
	// プラグインコマンド
	var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        switch(command) {
			case 'Battle_Command_Extend':
				var id
				switch(args[0]) {
					case 'Party':
						id = 0;
						break;
					case 'Attack':
						id = 1;
						break;
					case 'Skill':
						id = 2;
						break;
					case 'Guard':
						id = 3;
						break;
					case 'Item':
						id = 4;
						break;
					case 'Auto':
						id = 6;
						break;
					case 'Repeat':
						id = 7;
						break;
					case 'Escape':
						id = 10;
						break;
				}
				$gameSystem._battle_command_flag[id] = args[1];
				break;

        }
    };
	// 「リピート」の一時保存
	var _Game_Temp_initialize_Battle_Command_Extend = Game_Temp.prototype.initialize;
	Game_Temp.prototype.initialize = function() {
		_Game_Temp_initialize_Battle_Command_Extend.call(this);
		this._repeat_action = [];
	};
	// 「リピート」の初期化
	Game_Temp.prototype.clear_repeat_action = function() {
		this._repeat_action = [];
	};
	// 設定保存用
	var _Game_System_initialize_Battle_Command_Extend = Game_System.prototype.initialize;
	Game_System.prototype.initialize = function() {
		_Game_System_initialize_Battle_Command_Extend.call(this);
		this._battle_command_flag = []; // 初期化
		this._battle_command_flag[0]  = Battle_Command_Extend.Flag[0]; // PT
		this._battle_command_flag[1]  = Battle_Command_Extend.Flag[1]; // 攻撃
		this._battle_command_flag[2]  = Battle_Command_Extend.Flag[2]; // スキル
		this._battle_command_flag[3]  = Battle_Command_Extend.Flag[3]; // 防御
		this._battle_command_flag[4]  = Battle_Command_Extend.Flag[4]; // アイテム
		this._battle_command_flag[6]  = Battle_Command_Extend.Flag[6]; // オート
		this._battle_command_flag[7]  = Battle_Command_Extend.Flag[7]; // リピート
		this._battle_command_flag[10] = Battle_Command_Extend.Flag[10]; // 逃げる
	};
	// 戦闘開始
	var BattleManager_startBattle_Battle_Command_Extend = BattleManager.startBattle;
	BattleManager.startBattle = function() {
		$gameTemp.clear_repeat_action();
		BattleManager_startBattle_Battle_Command_Extend.call(this);
	};
	// ターン開始
	var BattleManager_startTurn_Battle_Command_Extend = BattleManager.startTurn;
	BattleManager.startTurn = function() {
		BattleManager.repeatSave();
		BattleManager_startTurn_Battle_Command_Extend.call(this);
	};
	// リピート行動の作成
	BattleManager.repeatActor = function() {
		for(var i = 0; i < $gameParty.size(); i++) {
			var actor = $gameParty.members()[i];
			var action = new Game_Action(actor);
			if (actor.canInput()) { // 行動可能な場合
				actor.makeActions(); // 現在の行動を削除と行動回数の適用
				if ($gameTemp._repeat_action[i] === undefined) { // 一時保存がなければ
					$gameTemp._repeat_action[i] = [];
					for (var n = 0; n < actor.numActions(); n++) { // 行動回数
						$gameTemp._repeat_action[i][n] = action;
						$gameTemp._repeat_action[i][n].setSkill(actor.attackSkillId()); // 通常攻撃
						$gameTemp._repeat_action[i][n].setTarget(-1); // ターゲットは初期値
					}
				}
				for (var n = 0; n < actor.numActions(); n++) { // 行動回数
					var ac = $gameTemp._repeat_action[i][n];
					actor.setAction(n, ac);
				}
			}
		}
	};
	// リピート行動の保存
	BattleManager.repeatSave = function() {
		for(var i = 0; i < $gameParty.size(); i++) {
			var actor = $gameParty.members()[i];
			if (actor.canInput()) { // 行動可能な場合
				$gameTemp._repeat_action[i] = []; // 保存準備
				for (var n = 0; n < actor.numActions(); n++) { // 行動回数
					if (actor.action(n).isValid()) { // 使用可能？
						$gameTemp._repeat_action[i][n] = actor.action(n); // 保存
					} else { // 使用不可
						actor.action(n).setSkill(actor.attackSkillId())// 通常攻撃に変更
						$gameTemp._repeat_action[i][n] = actor.action(n);
					}
				}
			}
		}
	};
	// 自動戦闘用の行動候補リストを作成
	var _Game_Actor_makeActionList_Battle_Command_Extend = Game_Actor.prototype.makeActionList;
	Game_Actor.prototype.makeActionList = function() {
		if ($gameSystem._battle_command_flag[2] === "on") { // スキルが非表示ならスキルを使用しない
			var list = [];
			var action = new Game_Action(this);
			action.setAttack(); // 通常攻撃
			list.push(action);
			return list;
		} else {
			return _Game_Actor_makeActionList_Battle_Command_Extend.call(this);
		}
	};
	// SV アクターコマンド時「逃げる」動作改善
	var _Sprite_Actor_updateTargetPosition_Battle_Command_Extend = Sprite_Actor.prototype.updateTargetPosition;
	Sprite_Actor.prototype.updateTargetPosition = function() {
		if ($gameSystem._battle_command_flag[0] === "on") {
			if (this._actor.canMove() && BattleManager.isEscaped()) {
				this.retreat();
			} else if (this._actor.isInputting() || this._actor.isActing()) {
				this.stepForward();
			} else if (!this.inHomePosition()) {
				this.stepBack();
			}
		} else {
			return _Sprite_Actor_updateTargetPosition_Battle_Command_Extend.call(this);
		}
	};
	// 表示行数の取得
	var _Window_ActorCommand_numVisibleRows_Battle_Command_Extend = Window_ActorCommand.prototype.numVisibleRows;
	Window_ActorCommand.prototype.numVisibleRows = function() {
		if (Battle_Command_Extend.Flag[5] === "on") {
			var num = this._list ? this._list.length : 4;
			return num;
		} else {
		return _Window_ActorCommand_numVisibleRows_Battle_Command_Extend.call(this);
		}
	};
	// コマンドリストのリフレッシュ
	var _Window_ActorCommand_refresh_Battle_Command_Extend = Window_ActorCommand.prototype.refresh;
	Window_ActorCommand.prototype.refresh = function() {
		if (Battle_Command_Extend.Flag[5] === "on") {
			var wh = this.fittingHeight(this.numVisibleRows());
			var wy = Math.min(Graphics.boxHeight - wh, this.fittingHeight(this.numVisibleRows()));
			this.move(this.x, Graphics.boxHeight - wh, this.windowWidth(), wh);
		}
		_Window_ActorCommand_refresh_Battle_Command_Extend.call(this);
	};
	// コマンドの削除
	Window_ActorCommand.prototype.delCommandList = function(flag)　{
		if(flag === true || $gameSystem._battle_command_flag[1] === "on") { // 攻撃
			this._list = this._list.filter(function(obj) {
				return obj.symbol !== 'attack';
			}.bind(this));
		}
		if(flag === true || $gameSystem._battle_command_flag[2] === "on") { // スキル
			this._list = this._list.filter(function(obj) {
				return obj.symbol !== 'skill';
			}.bind(this));
		}
		if(flag === true || $gameSystem._battle_command_flag[3] === "on") { // 防御
			this._list = this._list.filter(function(obj) {
				return obj.symbol !== 'guard';
			}.bind(this));
		}
		if(flag === true || $gameSystem._battle_command_flag[4] === "on") { // アイテム
			this._list = this._list.filter(function(obj) {
				return obj.symbol !== 'item';
			}.bind(this));
		}
		if(flag === true || $gameSystem._battle_command_flag[10] === "on") { // 逃げる
			this._list = this._list.filter(function(obj) {
				return obj.symbol !== 'escape';
			}.bind(this));
		}
	};
	// コマンドリストの作成
	var _Window_ActorCommand_makeCommandList_Battle_Command_Extend = Window_ActorCommand.prototype.makeCommandList;
	Window_ActorCommand.prototype.makeCommandList = function() {
		_Window_ActorCommand_makeCommandList_Battle_Command_Extend.call(this); // 元処理
		this.delCommandList(true); // コマンド削除
		if (this._actor) {
			var symbol = Battle_Command_Extend.Command.split(' ');
			for(var n = 0; n < symbol.length; n++) {
				 switch(symbol[n]) {
					case 'attack': // 攻撃
						this.addAttackCommand();
						break;
					case 'skill': // スキル
						this.addSkillCommands();;
						break;
					case 'guard': // 防御
						this.addGuardCommand();;
						break;
					case 'item': // アイテム
						this.addItemCommand();;
						break;
					case 'escape': // 逃げる
						if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[10] === "off") {
							this.addCommand(TextManager.escape, 'escape', BattleManager.canEscape());
						}
						break;
					case 'auto': // オート
						if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[6] === "off") {
							this.addCommand(Battle_Command_Extend.Flag[8],  'auto');
						}
						break;
					case 'repeat': // リピート
						if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[7] === "off") {
							this.addCommand(Battle_Command_Extend.Flag[9],  'repeat');
						}
						break;
				 }
			}
			this.delCommandList();
		}
	};
	// コマンドの削除
	Window_PartyCommand.prototype.delCommandList = function(flag)　{
		if(flag === true || $gameSystem._battle_command_flag[10] === "on") { // 逃げる
			this._list = this._list.filter(function(obj) {
				return obj.symbol !== 'escape';
			}.bind(this));
		}
	};
	// コマンドリストの作成
	var _Window_PartyCommand_makeCommandList_Battle_Command_Extend = Window_PartyCommand.prototype.makeCommandList;
	Window_PartyCommand.prototype.makeCommandList = function() {
		_Window_PartyCommand_makeCommandList_Battle_Command_Extend.call(this);
		this.delCommandList(true);
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[6] === "off") {
			this.addCommand(Battle_Command_Extend.Flag[8],  'auto');
		}
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[7] === "off") {
			this.addCommand(Battle_Command_Extend.Flag[9],  'repeat');
		}
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[10] === "off") {
			this.addCommand(TextManager.escape, 'escape', BattleManager.canEscape());
		}
		this.delCommandList();
	};
	// パーティコマンド選択の開始
	var _Scene_Battle_changeInputWindow_Battle_Command_Extend = Scene_Battle.prototype.changeInputWindow;
	Scene_Battle.prototype.changeInputWindow = function() {
		if ($gameSystem._battle_command_flag[0] === "on") {
			if (BattleManager.isInputting()) {
				if (BattleManager.actor()) {
					this.startActorCommandSelection();
				} else {
					this._partyCommandWindow.deactivate;
					this.commandFight();
				}
			} else {
				this.endCommandSelection();
			}
		} else {
			return _Scene_Battle_changeInputWindow_Battle_Command_Extend.call(this);
		}
	};
	// パーティーコマンドウィンドウの作成
	var _Scene_Battle_createPartyCommandWindow_Battle_Command_Extend = Scene_Battle.prototype.createPartyCommandWindow;
	Scene_Battle.prototype.createPartyCommandWindow = function() {
		_Scene_Battle_createPartyCommandWindow_Battle_Command_Extend.call(this);
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[6] === "off") { // オート
			this._partyCommandWindow.setHandler('auto', this.commandAuto.bind(this));
		}
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[7] === "off") { // リピート
			this._partyCommandWindow.setHandler('repeat', this.commandRepeat.bind(this));
		}
	};
	// アクターコマンドウィンドウの作成
	var _Scene_Battle_createActorCommandWindow_Battle_Command_Extend = Scene_Battle.prototype.createActorCommandWindow;
	Scene_Battle.prototype.createActorCommandWindow = function() {
		_Scene_Battle_createActorCommandWindow_Battle_Command_Extend.call(this);
		if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[6] === "off") { // オート
			this._actorCommandWindow.setHandler('auto', this.commandAuto.bind(this));
		}
		if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[7] === "off") { // リピート
			this._actorCommandWindow.setHandler('repeat', this.commandRepeat.bind(this));
		}
		if ($gameSystem._battle_command_flag[0] === "on") { // 逃げる
			this._actorCommandWindow.setHandler('escape', this.commandEscape.bind(this));
		}
	};
	// コマンド［オート］
	Scene_Battle.prototype.commandAuto = function() {
		if ($gameSystem._battle_command_flag[0] === "on") { // アクターコマンドから
			BattleManager.actor().makeAutoBattleActions(); // オート
			this.selectNextCommand();
		} else { // パーティーコマンドから
			for(var i = 0; i < $gameParty.size(); i++) {
				var actor = $gameParty.members()[i];
				if (actor.canInput()) { // 行動可能な場合
					actor.makeAutoBattleActions(); // オート
				}
			}
			this.endCommandSelection(); // コマンド終了
			BattleManager.startTurn(); // ターン開始
		}
	}
	// コマンド［リピート］
	Scene_Battle.prototype.commandRepeat = function() {
		BattleManager.repeatActor(); // 行動の作成
		this.endCommandSelection(); // コマンド終了
		BattleManager.startTurn(); // ターン開始
	}
})();


code:
//
//  発動前コモン ver1.01
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

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

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

(function() {

    'use strict';

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

    var parameters = PluginManager.parameters('BeforeCommon');
    var indexVariableId = Number(parameters['IndexVariableID']);
    var targetIndexVariableId = Number(parameters['TargetIndexVariableID']) || 0;

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

    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);
            var sId =  this._subject.index();
            var tId = action._targetIndex;
            if (this._subject.isEnemy()) sId += 1000;
            if (this._subject.isActor() && action.isForOpponent() && tId >= 0) tId += 1000;
            if (this._subject.isEnemy() && action.isForFriend() && tId >= 0) tId += 1000;
            if (action.isForUser()) tId = sId;
            if (indexVariableId) $gameVariables._data[indexVariableId] = sId;
            if (targetIndexVariableId) $gameVariables._data[targetIndexVariableId] = tId;
            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);
        }
    };

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