code:
/*:
 * @plugindesc 簡易リズムゲームプラグイン
 * @author Tennana
 * @help
 * 簡単なリズムゲームをプレイするためのプラグインです。
 *
 * 【使い方】
 * プラグイン設定で、譜面情報を設定し、プラグインコマンドでゲームを開始します。
 * プラグインコマンドでゲームを開始すると、「並列処理」以外がブロックされるため、ヒット/ミス時の処理はスイッチを条件にした並列処理で作成してください。
 * 曲の再生が終わるか、並列処理からゲーム終了コマンドが呼ばれると、呼び出し元のイベントに制御が戻ります。
 *
 * 【プラグインコマンド】
 * RhythmGameStart 曲名
 * 　指定した曲名の譜面を読み込んでゲームを開始します。
 *
 * RhythmGameStop
 * 　ゲームを直ちに終了し、起動したイベントに制御を戻します。
 *
 * RhythmGameHidden
 *   プレイエリアを非表示にします。場所移動でも自動的に非表示となります。
 *
 * @param RhythmNotes
 * @type struct<RhythmNotes>[]
 * @text 譜面情報
 *
 * @param NotesType
 * @type struct<NotesType>[]
 * @text ノーツタイプ定義
 * @default ["{\"name\":\"赤\",\"input\":\"left\",\"size\":\"30\",\"color\":\"red\"}","{\"name\":\"青\",\"input\":\"right\",\"size\":\"30\",\"color\":\"blue\"}"]
 *
 * @param NotesSpeed
 * @type number
 * @text ノーツスピード
 * @default 5000
 * @desc ノーツが画面上を流れる速度をミリ秒で指定します。半分のタイミングでノーツが中央になるように調整されます。
 *
 * @param HitRange
 * @type number
 * @text ヒット範囲
 * @default 100
 * @desc 譜面に対するタイミングのずれを許容する範囲をミリ秒で指定します。100で前後100ミリ秒を許容します。
 *
 * @param HitSwitch
 * @type switch
 * @text ヒット時スイッチ
 * @desc ヒット時にONになるスイッチ
 *
 * @param DifferenceVariable
 * @type variable
 * @text 差分格納変数
 * @desc 最後にヒットしたときの譜面との差分ミリ秒を格納する変数
 *
 * @param MissSwitch
 * @type switch
 * @text ミススイッチ
 * @desc ミス時にONになるスイッチ
 *
 * @param PlayAreaX
 * @type number
 * @text プレイエリアX座標
 * @default 0
 * @min 0
 * @desc プレイエリアの左上X座標
 *
 * @param PlayAreaY
 * @type number
 * @text プレイエリアY座標
 * @default -1
 * @min -1
 * @desc プレイエリアの左上Y座標。-1で画面下部になるよう自動調整します。
 *
 * @param PlayAreaWidth
 * @type number
 * @text プレイエリア幅
 * @default -1
 * @min -1
 * @desc プレイエリアの横幅をピクセル数で指定します。-1で画面幅になるよう自動調整します。
 *
 * @param PlayAreaHeight
 * @type number
 * @text プレイエリア高さ
 * @default 200
 * @min 0
 * @desc プレイエリアの高さをピクセル数で指定します。
 *
 * @param PlayAreaWindow
 * @type file
 * @text プレイエリアウィンドウ画像
 * @default Window
 * @dir img/system
 *
 * @param PlayAreaArrowSize
 * @type number
 * @text プレイエリアの矢印サイズ
 * @default 2
 * @min 1
 * @desc プレイエリアの矢印のサイズを倍率で指定します。
 */
/*~struct~RhythmNotes:
 * @param name
 * @text 曲名
 * @type string
 *
 * @param file
 * @type file
 * @dir audio
 *
 * @param volume
 * @text 音量
 * @type number
 * @min 0
 * @max 100
 * @default 90
 *
 * @param pitch
 * @text ピッチ
 * @type number
 * @min 50
 * @max 150
 * @default 100
 *
 * @param pan
 * @text 位相
 * @type number
 * @min -100
 * @max 100
 * @default 0
 *
 * @param notes
 * @text ノーツ情報
 * @type struct<Notes>[]
 *
*/

/*~struct~Notes:
 * @param hitTime
 * @text 判定タイミングミリ秒
 * @min 0
 * @desc ノーツにヒットするタイミングを開始からのミリ秒で指定します。出現時間を上書きします。
 *
 * @param time
 * @text 出現時間ミリ秒
 * @type number
 * @min 0
 * @desc ノーツが出現するタイミングを開始からのミリ秒で指定します。判定タイミングは出現+ノーツスピードの半分になります。
 *
 * @param type
 * @text ノーツタイプ
 * @type combo
 * @option 赤
 * @option 青
 * @desc ノーツの種類を名前で指定します。
 *
 * @param size
 * @text 半径
 * @type number
 * @min 0
 * @default 0
 * @desc ノーツの半径を上書きします。0でデフォルトの大きさになります。
 *
 * @param color
 * @text 色
 * @type string
 * @desc ノーツの色を上書きします。CSS COLOR形式で指定します。空でデフォルトの色になります。
*/

/*~struct~NotesType:
 * @param name
 * @text ノーツタイプ名
 * @type string
 * @desc ノーツタイプの名前です。譜面側で指定する名前になります。
 *
 * @param input
 * @type select
 * @text キー名称
 * @desc このノーツを叩くためのキー名称です。
 * @option 決定
 * @value ok
 * @option キャンセル
 * @value cancel
 * @option ダッシュ
 * @value shift
 * @option メニュー
 * @value menu
 * @option ページアップ
 * @value pageup
 * @option ページダウン
 * @value pagedown
 * @option 上移動
 * @value up
 * @option 下移動
 * @value down
 * @option 左移動
 * @value left
 * @option 右移動
 * @value right
 * @default ok
 *
 * @param size
 * @text 半径
 * @type number
 * @min 2
 * @default 30
 * @desc ノーツの半径をピクセルで指定します。
 *
 * @param color
 * @text 色
 * @type string
 * @desc ノーツの色をCSS COLOR形式で指定します。空でデフォルトの色になります。
 *
 * @param borderColor
 * @text 枠色
 * @type string
 * @desc ノーツの枠線の色をCSS COLORで指定します。空で白色になります。
 * @default white
 *
 * @param borderWidth
 * @text 枠線の太さ
 * @type number
 * @default 1
 * @min 0
 * @desc ノーツの枠線の太さを指定します。
 */

"use strict";
{
	const PARAMS = PluginManagerEx.createParameter(document.currentScript);
	const HIT_RANGE = PARAMS.HitRange; // ヒット可能範囲
	const NOTES_SPEED = PARAMS.NotesSpeed || 5000; // ノーツの速度(ミリ秒)
	const FADE_OUT_TIME = 1; // フェードアウト秒数

	if (!Html5Audio.addStopListener) {
		Html5Audio.addStopListener = function (listener) {
			this._audioElement.addEventListener('ended', listener, { once: true });
		}
	}

	(function (orig) {
		Game_Interpreter.prototype.pluginCommand = function (command, args) {
			orig.call(this, command, args);
			if (command === "RhythmGameStart") {
				this._waitMode = "rhythm";
				RhythmManager.start(args).finally(() => {
					this._waitMode = ""
				});
			}
			if (command === "RhythmGameStop") {
				RhythmManager.stop();
				this._waitMode = "";
				this._waitCount = FADE_OUT_TIME * 60 + 10;
				return;
			}
			if (command === "RhythmGameHidden") {
				RhythmManager.hidden();
				return;
			}
		};
	})(Game_Interpreter.prototype.pluginCommand);
	(function (orig) {
		Game_Interpreter.prototype.updateWaitMode = function () {
			if (this._waitMode === "rhythm") {
				return true;
			}
			return orig.call(this);
		};
	})(Game_Interpreter.prototype.updateWaitMode);

	class RhythmManagerImpl {
		async start(args) {
			const bgmName = args[0];
			const rhythmNote = PARAMS.RhythmNotes.find(rhythmNotes => {
				return rhythmNotes.name === bgmName;
			});
			if (!rhythmNote) {
				throw new Error(`RhythmNotes not found. name: ${bgmName}`);
			}
			this._currentRhythmNote = rhythmNote;
			this._waitNotes = rhythmNote.notes.map(notes => {
				if (Number.isFinite(notes.hitTime)) {
					notes.time = notes.hitTime - NOTES_SPEED / 2;
				}
				return notes;
			}).sort((a, b) => a.time - b.time);

			return Promise.all([
				this.preloadBgm(rhythmNote).then(bgm => {
					this._bgmBuffer = bgm
				}),
				this.createPlayArea()
			]).then(() => {
				this._playing = true;
				AudioManager.updateBufferParameters(this._bgmBuffer,
					ConfigManager.bgmVolume, this._currentRhythmNote);
				this._bgmBuffer.play(false, 0);
				return new Promise((resolve, reject) => {
					this._bgmBuffer.addStopListener(resolve);
				});
			}).then(() => {
				this._playing = false;
			});
		}

		preloadBgm(rhythmNotes) {
			return new Promise((resolve, reject) => {
				const ext = AudioManager.audioFileExt();
				let url = "./audio/" + rhythmNotes.file;
				if (!AudioManager.shouldUseHtml5Audio()) {
					const audio = new WebAudio(url + ext);
					audio.addLoadListener(resolve.bind(null, audio));
					return;
				}
				if (!Decrypter.hasEncryptedAudio) {
					return url + ext;
				}
				return fetch(Decrypter.extToEncryptExt(rhythmNotes.file + ext))
					.then(response => response.arrayBuffer())
					.then(arrayBuffer => {
						return Decrypter.createBlobUrl(arrayBuffer);
					});
			}).then(url => {
				if (typeof url === 'string') {
					Html5Audio.setup(url)
					return new Promise((resolve, reject) => {
						Html5Audio.addLoadListener(resolve.bind(null, Html5Audio));
					});
				}
				return url;
			});
		}

		async createPlayArea() {
			if (this._playArea && this._playArea.parent) {
				this._playArea.visible = true;
			} else {
				await new Promise(resolve => {
					if (!PARAMS.PlayAreaWindow) {
						return resolve();
					}
					ImageManager.loadSystem(PARAMS.PlayAreaWindow).addLoadListener(
						resolve);
				});
				this._playArea = new PlayArea();
			}
			this._playArea.children.filter(child => child instanceof Notes).forEach(
				child => {
					child.destroy();
				});
			SceneManager._scene.addWindow(this._playArea);
			return this._playArea;
		}

		appearNotes(time) {
			if (this._waitNotes.length === 0) {
				return;
			}
			const notes = this._waitNotes[0];
			if (notes.time > time) {
				return;
			}
			const notesType = PARAMS.NotesType.find(
				notesType => notesType.name === notes.type);

			const notesAppearance = Object.assign({
				time: notes.time,
				borderWidth: 1,
				borderColor: 'white',
				zIndex: notes.zIndex
			}, notesType);
			notesAppearance.color = notes.color || notesAppearance.color;
			notesAppearance.size = notes.size || notesAppearance.size;
			this._playArea.addNotes(notesAppearance);
			this._waitNotes.shift();
		}

		stop() {
			this._bgmBuffer.fadeOut(FADE_OUT_TIME);
			setTimeout(this._bgmBuffer.stop.bind(this._bgmBuffer),
				FADE_OUT_TIME * 1000 + 100);
			this._playing = false;
		}

		hidden() {
			if (this._playArea) {
				this._playArea.visible = false;
			}
		}
	}

	Object.defineProperties(RhythmManagerImpl.prototype, {
		playing: {
			get: function () {
				return this._playing;
			}
		},
		currentRhythmNote: {
			get: function () {
				return this._currentRhythmNote;
			}
		},
		currentPlayTime: {
			get: function () {
				return this._bgmBuffer ? this._bgmBuffer.seek() * 1000 : 0;
			}
		}
	});

	class PlayArea extends Window_Base {
		constructor() {
			const width = PARAMS.PlayAreaWidth > 0 ? PARAMS.PlayAreaWidth
				: Graphics.width;
			const height = PARAMS.PlayAreaHeight > 0 ? PARAMS.PlayAreaHeight : 200;
			const x = PARAMS.PlayAreaX > 0 ? PARAMS.PlayAreaX : 0;
			const y = PARAMS.PlayAreaY >= 0 ? PARAMS.PlayAreaY : Graphics.height
				- height;
			super(x, y, width, height);
			this.notesChunk = width / NOTES_SPEED;
			this.resetFontSettings()
			this.downArrowVisible = true;
			this.upArrowVisible = true;
			const scale = PARAMS.PlayAreaArrowSize || 2;
			this._upArrowSprite.scale.x = scale;
			this._upArrowSprite.scale.y = scale;
			this._downArrowSprite.scale.x = scale;
			this._downArrowSprite.scale.y = scale;
		}

		_refreshArrows() {
			super._refreshArrows();
			let cursorX = this.width / 2;
			this._downArrowSprite.move(cursorX, this.standardPadding() * 1.5);
			this._upArrowSprite.move(cursorX,
				this.height - this.standardPadding() * 1.5);
		}

		standardFontSize() {
			return 24;
		}

		update() {
			const time = RhythmManager.currentPlayTime;
			const width = this.width;
			const notesArray = this.children.filter(child => child instanceof Notes).reverse();
			notesArray.forEach(notes => {
				notes.updatePos(time, width, this.notesChunk);
				notes.miss(time);
			});
			super.update();
			if (RhythmManager.playing === false) {
				return;
			}
			RhythmManager.appearNotes(time);
			if (notesArray.length === 0) {
				return;
			}
			PARAMS.NotesType.forEach(notesType => {
				if (Input.isTriggered(notesType.input)) {
					const hitNotes = notesArray.find(notes => {
						return notes.canHit(time, notesType.input);
					});
					if (hitNotes) {
						hitNotes.hit(time);
					} else {
						$gameSwitches.setValue(PARAMS.MissSwitch, true);
					}
				}
			});
		}

		addNotes(notes) {
			this.addChildAt(new Notes(this.width,
				this.contentsHeight() / 2 + this.standardPadding(), notes), 3);
		}

		loadWindowskin() {
			if (!PARAMS.PlayAreaWindow) {
				return super.loadWindowskin();
			}
			this.windowskin = ImageManager.loadSystem(PARAMS.PlayAreaWindow);
		}
	}

	class Notes extends Sprite {
		constructor(x, y, notes) {
			super();
			const radius = notes.size + notes.borderWidth;
			this.bitmap = new Bitmap(radius * 2, radius * 2);
			if (notes.borderWidth > 0) {
				this.bitmap.drawCircle(radius, radius, radius, notes.borderColor);
			}
			this.bitmap.drawCircle(radius, radius, notes.size, notes.color);
			this.x = x || 0;
			this.y = y || 0;
			this.anchor.x = 0.5;
			this.anchor.y = 0.5;
			this.zIndex = notes.zIndex;
			this.hitTime = notes.time + NOTES_SPEED / 2;
			this.appearTime = notes.time;
			this._input = notes.input;
			this._result = null;
		}

		canHit(time, input) {
			if (this._result !== null || (input && input !== this._input)) {
				return false;
			}
			return this.hitTime - HIT_RANGE <= time && time <= this.hitTime
				+ HIT_RANGE;
		}

		hit(time) {
			this.destroy();
			$gameSwitches.setValue(PARAMS.HitSwitch, true);
			$gameVariables.setValue(PARAMS.DifferenceVariable, time - this.hitTime);
			this._result = true;
		}

		miss(time) {
			if (this._result !== null || time <= this.hitTime + HIT_RANGE) {
				return;
			}
			this._result = false;
			$gameSwitches.setValue(PARAMS.MissSwitch, true);
		}

		updatePos(time, parentWidth, chunk) {
			const x = parentWidth - (time - this.appearTime) * chunk;
			if (x < 0 && x < -this.width) {
				// 画面外へ出たら削除
				this.destroy();
				return;
			}
			this.x = x;
		}
	}

	(function (orig) {
		Scene_Map.prototype.onMapLoaded = function () {
			orig.apply(this, arguments);
			if (!window.RhythmManager || !window.RhythmManager.playing) {
				return;
			}
			this.addWindow(window.RhythmManager._playArea);
		};
	})(Scene_Map.prototype.onMapLoaded);

	window.RhythmManager = new RhythmManagerImpl();
}


code:
//=============================================================================
// RingMenuIcon.js
//=============================================================================

/*:ja
 * @plugindesc メニューボタンを押すとリング状にメニューアイコンが表示されます。
 * @author 村人A
 *
 * @param メニュー項目
 * @desc リングコマンドに表示するメニューの項目です。
 * @default アイテム,スキル,装備,ステータス,並び替え,オプション,セーブ,ゲーム終了
 *
 * @param リングメニューサイズ
 * @desc リングコマンドの円の大きさを指定します。
 * @default 100
 * @type number
 *
 * @param 選択時アイコン拡大率
 * @desc 選択しているアイコンの拡大率を百分率で指定します。100でそのままの大きさになります。
 * @default 200
 *
 * @param 選択している項目名のプレイヤーからの相対距離
 * @desc アイコンで選択している項目名のプレイヤーからの位置を指定します。値が大きい程上に移動します。
 * @default 100
 * @type number
 *
 * @param 所持金ウィンドウ位置
 * @desc 所持金ウィンドウの位置を半角カンマ,を挟んでx座標,y座標と指定します。
 * @default 550,300
 *
 * @param 任意テキストウィンドウの位置と大きさ
 * @desc 任意テキストウィンドウの位置を半角カンマ,を挟んでx座標,y座標,幅,高さと指定します。
 * @default 500,400,320,220
 *
 * @param 任意テキスト1
 * @desc 任意テキストウィンドウに表示するテキストを記述します。C,I,V等の制御文字が使用できます。
 * @default テスト変数\V[1]\C[2]テスト\C[0]\I[3]
 *
 * @param 任意テキスト2
 * @desc 任意テキストウィンドウに表示するテキストを記述します。C,I,V等の制御文字が使用できます。
 * @default 任意テキスト２
 *
 * @param 任意テキスト3
 * @desc 任意テキストウィンドウに表示するテキストを記述します。C,I,V等の制御文字が使用できます。
 * @default 任意テキスト３
 *
 * @param 任意テキスト4
 * @desc 任意テキストウィンドウに表示するテキストを記述します。C,I,V等の制御文字が使用できます。
 * @default 任意テキスト４
 *
 * @param 任意テキスト5
 * @desc 任意テキストウィンドウに表示するテキストを記述します。C,I,V等の制御文字が使用できます。
 * @default 任意テキスト５
 *
 * @help
 * --------------------------------------------
 * ◯バージョン管理◯
 * --------------------------------------------
 *　2019/6/21 ver1.3
 *　メニューに所持金ウィンドウと任意テキストウィンドウを追加しました。
 *
 *　2019/3/22 ver1.2
 *　選択中のアイコンの拡大表示と項目名の背景に黒背景を導入
 *
 *　2019/3/19 ver1.1
 *　エンコードやいくつかのバグを修正
 *
 *　2017/7/4 ver1.0
 *　プラグインリリース
 *
 * --------------------------------------------
 * ◯ヘルプ◯
 * --------------------------------------------
 * このプラグインには、プラグインコマンドはありません。
 *
 * メニュー項目には「,」カンマを挟み「アイテム」,「スキル」,「装備」,
 * 「ステータス」,「並び替え」,「オプション」,「セーブ」,「ゲーム終了」の内必要
 * なものを記述してください。
 * 文字が異なったり、スペースなどを入れると認識されません。
 * また、このプラグインのメニューアイコンは汎用性を持たせるため画像を使用
 * しています。
 * それぞれのアイコンは以下のように名前を付けてください。
 * アイテム     item_icon.png
 * スキル      skill_icon.png
 * 装備  　　　 equip_icon.png
 * ステータス   option_icon.png
 * 並び替え   formation_icon.png
 * オプション   status_icon.png
 * セーブ     save_icon.png
 * ゲーム終了 gameEnd_icon.png
 * 画像はimgフォルダのsystemフォルダ内に保存してください。
 * このプラグインのキャラクターのアイコンはビッグキャラクター（$がつくファイル）には対応しておりません。
 * ご希望の方がいらっしゃればコメントかメールにてお知らせください。
 */

(function () {
	'use strict';

	String.prototype.toNumberArray = function () {
		return this.split(",").map(function (str) { return Number(str) });
	}

	const parameters = PluginManager.parameters('RingMenuIconForFuyuzora');
	const menuList = String(parameters['メニュー項目'] || 'アイテム,スキル,装備,ステータス,並び替え,オプション,セーブ,ゲーム終了').split(",");
	const ringMenuRadius = Number(parameters['リングメニューサイズ']);
	const choosenIconZoomRate = Number(parameters['選択時アイコン拡大率']);
	const iconTitleNameDistance = Number(parameters['選択している項目名のプレイヤーからの相対距離']);
	const goldWindowPos = parameters['所持金ウィンドウ位置'].toNumberArray();
	const optionalTextWindowPosSize = parameters['任意テキストウィンドウの位置と大きさ'].toNumberArray();

	//-----------------------------------------------------------------------------
	// Scene_Map
	//

	Scene_Map.prototype.callMenu = function () {
		SoundManager.playOk();
		SceneManager.push(Scene_RingMenuChoice);
		$gameTemp.clearDestination();
		this._mapNameWindow.hide();
		this._waitCount = 2;
	};

	const _alias_Scene_Map_terminate = Scene_Map.prototype.terminate;
	Scene_Map.prototype.terminate = function () {
		if (!SceneManager.isNextScene(Scene_Battle)) {
			SceneManager.snapForNoBlueBackground();
		}
		_alias_Scene_Map_terminate.call(this);
	};

	//-----------------------------------------------------------------------------
	// Scene_RingMenuChoice
	//
	// The scene class of the ring menu.

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

	Scene_RingMenuChoice.prototype = Object.create(Scene_Base.prototype);
	Scene_RingMenuChoice.prototype.constructor = Scene_RingMenuChoice;

	Scene_RingMenuChoice.prototype.initialize = function () {
		Scene_Base.prototype.initialize.call(this);
		this.ringMeunArray = []
		this.iconSpriteArray = [];
		this._rmcSprites = []
		this.followerIconArray = []
		this.startIconMenu = false;
		this.ringMenuCancel = false;
		this.openChooseRing = false;
		this.touchRound = false;
		this.ringCharaMenuCancel = false;
		this.chooseCharaMode = false;
		this.touchMoveScene = false;
		this.statusNeedScene = ""
		this.on_turn = [false, false];
		this.menuStartFrame = 10;
		this.menuIconRoundRadius = ringMenuRadius;
		this.turnFrame = 10;
		this.nowTurnCount = 0;
		this.preturnIndex = 0;
		this.preChoiceIndex = 0;
		this.nowChoiceIndex = 0;
		this.pw = 0;
		this.ph = 0;
		this.turnIndex = 0;
		this.waitcount = 5;
		this.nomalIconSize = new Point(1, 1)
		const rate = choosenIconZoomRate / 100;
		this.choosenIconSize = new Point(rate, rate)
		const followerName = $gameParty.members()[0]._characterName;
		this.charaSampleSprite = new Sprite();
		this.charaSampleSprite.bitmap = ImageManager.loadCharacter(followerName);
		menuList.forEach(function (str) {
			switch (str) {
				case "アイテム":
					this.ringMeunArray.push(["item", "アイテム"]);
					break;
				case "スキル":
					this.ringMeunArray.push(["skill", "スキル"]);
					break;
				case "装備":
					this.ringMeunArray.push(["equip", "装備"]);
					break;
				case "ステータス":
					this.ringMeunArray.push(["status", "ステータス"]);
					break;
				case "並び替え":
					this.ringMeunArray.push(["formation", "並び替え"]);
					break;
				case "オプション":
					this.ringMeunArray.push(["option", "オプション"]);
					break;
				case "セーブ":
					this.ringMeunArray.push(["save", "セーブ"]);
					break;
				case "ゲーム終了":
					this.ringMeunArray.push(["gameEnd", "ゲーム終了"]);
					break;
			}
		}.bind(this));
		if (this.iconSpriteArray.length != 0) {
			this.iconSpriteArray.forEach(function (sprite) {
				sprite.opacity = 0;
			});
		}
	};

	Scene_RingMenuChoice.prototype.create = function () {
		Scene_Base.prototype.create.call(this);
		this.createBackground();
		this.createMenuIcon();
		this.createActorsIcon();
		this.createGoldWindow();
		this.createOptionalTextWindow();
		this.startIconMenu = true;
	};

	Scene_RingMenuChoice.prototype.createOptionalTextWindow = function () {
		const p = optionalTextWindowPosSize;
		this._optionalTextWindow = new Window_Base(p[0], p[1], p[2], p[3]);
		this._optionalTextWindow.openness = 0;
		for (let i = 1; i <= 5; i++) {
			const textName = '任意テキスト' + i;
			const y = this._optionalTextWindow.lineHeight() * (i - 1);
			this._optionalTextWindow.drawTextEx(parameters[textName], 0, y);
		}
		this.addChild(this._optionalTextWindow);
		this._optionalTextWindow.open();
	}

	Scene_RingMenuChoice.prototype.createGoldWindow = function () {
		this._goldWindow = new Window_Gold(goldWindowPos[0], goldWindowPos[1]);
		this._goldWindow.openness = 0;
		this.addChild(this._goldWindow);
		this._goldWindow.open();
	}

	Scene_RingMenuChoice.prototype.createActorsIcon = function () {
		this.pw = this.charaSampleSprite.bitmap.width / 12;
		this.ph = this.charaSampleSprite.bitmap.height / 8;
		const folloerLength = $gameParty.members().length;
		for (let i = 0; i < folloerLength; i++) {
			const followerName = $gameParty.members()[i]._characterName;
			const followerIndex = $gameParty.members()[i].characterIndex()
			const sprite = new Sprite();
			sprite.bitmap = ImageManager.loadCharacter(followerName);
			const sx = (followerIndex % 4 * 3 + 1) * this.pw;
			const sy = (Math.floor(followerIndex / 4) * 4 + 0) * this.ph;
			sprite.setFrame(sx, sy, this.pw, this.ph);
			sprite.x = $gamePlayer.screenX();
			sprite.y = $gamePlayer.screenY();
			sprite.anchor.x = 0.5;
			sprite.anchor.y = 1;
			sprite.opacity = 0;
			this.addChild(sprite);
			this.followerIconArray.push(sprite);
		}
		this.iconSpriteArray[0].scale = this.choosenIconSize;
	}

	Scene_RingMenuChoice.prototype.createMenuIcon = function () {
		if (this.iconSpriteArray.length == 0) {
			this.ringMeunArray.forEach(function (name) {
				const sprite = new Sprite();
				sprite.bitmap = ImageManager.loadSystem(name[0] + "_icon");
				sprite.x = $gamePlayer.screenX();
				sprite.y = $gamePlayer.screenY();
				sprite.anchor.x = 0.5;
				sprite.anchor.y = 1;
				sprite.opacity = 0;
				this.iconSpriteArray.push(sprite);
				this.addChild(sprite);
			}, this);
		}
	}

	Scene_RingMenuChoice.prototype.start = function () {
		Scene_MenuBase.prototype.start.call(this);
		this.iconWidth = this.iconSpriteArray[0].bitmap.width;
		this.iconHeight = this.iconSpriteArray[0].bitmap.height;
	}

	Scene_RingMenuChoice.prototype.createBackground = function () {
		this._backgroundSprite = new Sprite();
		this._backgroundSprite.bitmap = SceneManager.noblurbackgroundBitmap();
		this.addChild(this._backgroundSprite);
	};

	Scene_RingMenuChoice.prototype.isCanceled = function () {
		return Input.isTriggered('menu') || Input.isTriggered('cancel') || TouchInput.isCancelled();
	};

	Scene_RingMenuChoice.prototype.update = function () {
		Scene_Base.prototype.update.call(this);
		if (this.waitcount > 0) {
			this.waitcount--;
			return;
		}
		this.updateIconContraction();
		if (this.chooseCharaMode) {
			this.updateCharaIconContraction();
			this.updateCharaIconExpansion();
			this.updateRoundCharaIcon();
			return
		}
		this.updateIconExpansion();
		this.updateRoundIcon();
	};

	//メニューアイコン操作＆アイコン回転
	Scene_RingMenuChoice.prototype.updateRoundIcon = function () {
		if (this.on_turn[0]) {
			this.RoundIcon(this.on_turn[1], this.iconSpriteArray);
			return;
		}

		if (TouchInput.isTriggered()) {
			this.touchControll(this.iconSpriteArray);
		}

		if (Input.isRepeated('ok') || this.touchMoveScene) {
			SoundManager.playOk();
			this.iconSpriteArray[this.nowChoiceIndex].scale = this.nomalIconSize;
			this.followerIconArray[0].scale = this.choosenIconSize;
			let command_num = this.ringMeunArray.length - this.turnIndex
			if (this.turnIndex == 0) { command_num = 0 }
			switch (this.ringMeunArray[command_num][0]) {
				case "item":
					SceneManager.goto(Scene_Item);
					break;
				case "equip":
					this.toChooseCharaMode(command_num);
					break;
				case "status":
					this.toChooseCharaMode(command_num);
					break;
				case "formation":
					SceneManager.goto(Scene_Formation_Menu);
					break;
				case "option":
					SceneManager.goto(Scene_Options);
					break;
				case "save":
					SceneManager.goto(Scene_Save);
					break;
				case "skill":
					this.toChooseCharaMode(command_num);
					break;
				case "gameEnd":
					SceneManager.goto(Scene_GameEnd);
					break;
			}
			this.touchMoveScene = false;
		}
		if (Input.isRepeated('right') && !this.ringMenuCancel && !this.startIconMenu) {
			this.preRingRoundPros(true, true);
			this.on_turn = [true, true];
		}
		if (Input.isRepeated('left') && !this.ringMenuCancel && !this.startIconMenu) {
			this.preRingRoundPros(false, true);
			this.on_turn = [true, false];
		}
	}

	Scene_RingMenuChoice.prototype.preRingRoundPros = function (isRight, isIcon) {
		SoundManager.playCursor();
		this.preChoiceIndex = this.nowChoiceIndex;
		const maxIndex = isIcon ? menuList.length : this.followerIconArray.length;
		if (isRight) {
			this.nowChoiceIndex = this.nowChoiceIndex == 0 ? maxIndex - 1 : this.nowChoiceIndex - 1;
		} else {
			this.nowChoiceIndex = (this.nowChoiceIndex + 1) % maxIndex;
		}
		if (isIcon) {
			this.iconSpriteArray[this.preChoiceIndex].scale = this.nomalIconSize;
			this.iconSpriteArray[this.nowChoiceIndex].scale = this.choosenIconSize;
		} else {
			this.followerIconArray[this.preChoiceIndex].scale = this.nomalIconSize;
			this.followerIconArray[this.nowChoiceIndex].scale = this.choosenIconSize;
		}
	}

	Scene_RingMenuChoice.prototype.touchControll = function (array) {
		array.forEach(function (sprite, ind, arr) {
			const angle = 360 * (ind / arr.length) - 90
			const radius = this.menuIconRoundRadius
			const x = $gamePlayer.screenX() + radius * Math.cos(angle * (Math.PI / 180))
			const y = $gamePlayer.screenY() + radius * Math.sin(angle * (Math.PI / 180))
			if (TouchInput.x < x + this.iconWidth / 2 && x - this.iconWidth / 2 < TouchInput.x) {
				if (TouchInput.y < y && y - this.iconHeight < TouchInput.y) {
					if (this.turnIndex != 0) {
						this.preturnIndex = this.turnIndex;
					};
					if (ind == 0) {
						this.touchMoveScene = true;
						return;
					}
					if (this.chooseCharaMode) {
						this.followerIconArray[this.nowChoiceIndex].scale = this.nomalIconSize;
						this.followerIconArray[ind].scale = this.choosenIconSize;
					} else {
						this.iconSpriteArray[this.nowChoiceIndex].scale = this.nomalIconSize;
						this.iconSpriteArray[ind].scale = this.choosenIconSize;
					}
					this.nowChoiceIndex = ind;
					this.turnIndex = array.length - ind;
					this.touchRound = true;
					this.on_turn = [true, true];
				}
			}
		}.bind(this));
	}

	Scene_RingMenuChoice.prototype.toChooseCharaMode = function (num) {
		this.iconWidth = this.pw;
		this.iconHeight = this.ph;
		this.ringMenuCancel = true;
		this.openChooseRing = true;
		this.chooseCharaMode = true;
		this.preturnIndex = 0;
		this.turnIndex = 0;
		this.statusNeedScene = this.ringMeunArray[num][0]
		this.nowChoiceIndex = this.preChoiceIndex = 0;
	}

	//キャラクターアイコン操作＆アイコン回転
	Scene_RingMenuChoice.prototype.updateRoundCharaIcon = function () {
		if (this.updateCharaChooseRing) {
			if (this.on_turn[0]) {
				this.RoundIcon(this.on_turn[1], this.followerIconArray);
				return;
			}

			if (TouchInput.isTriggered()) {
				this.touchControll(this.followerIconArray);
			}

			if (Input.isRepeated('ok') || this.touchMoveScene) {
				this.updateCharaChooseRing = false;
				SoundManager.playOk();
				let num = this.followerIconArray.length - this.turnIndex
				if (num == this.followerIconArray.length) { num = 0 }
				$gameParty.setMenuActor($gameParty.allMembers()[num]);
				switch (this.statusNeedScene) {
					case "equip":
						SceneManager.goto(Scene_Equip);
						break;
					case "skill":
						SceneManager.goto(Scene_Skill);
						break;
					case "status":
						SceneManager.goto(Scene_Status);
						break;
				}
			}
			if (Input.isRepeated('right') && !this.ringMenuCancel && !this.startIconMenu) {
				this.preRingRoundPros(true, false);
				this.on_turn = [true, true];
			}
			if (Input.isRepeated('left') && !this.ringMenuCancel && !this.startIconMenu) {
				this.preRingRoundPros(false, false);
				this.on_turn = [true, false];
			}
		}
	}

	//アイコン回転共通処理
	Scene_RingMenuChoice.prototype.RoundIcon = function (is_right, array) {
		let skipIconNum = 1;
		let nowPositionNum;
		if (this.touchRound) {
			skipIconNum = this.turnIndex;
			nowPositionNum = this.preturnIndex;
		} else {
			nowPositionNum = this.turnIndex;
		}
		array.forEach(function (sprite, ind, arr) {
			let turnRadius = (360 / arr.length) * skipIconNum * (this.nowTurnCount / this.turnFrame);
			if (!is_right) { turnRadius = -turnRadius; }
			const angle = 360 * ((ind + nowPositionNum) / arr.length) - 90 + turnRadius;
			const radius = this.menuIconRoundRadius;
			sprite.x = radius * Math.cos(angle * (Math.PI / 180)) + $gamePlayer.screenX();
			sprite.y = radius * Math.sin(angle * (Math.PI / 180)) + $gamePlayer.screenY();
		}.bind(this));

		this.nowTurnCount++;

		if (this.nowTurnCount > this.turnFrame) {
			this.on_turn = [false, false];
			this.nowTurnCount = 0
			if (this.touchRound) {
				this.touchRound = false;
				this.touchMoveScene = true;
				this.waitcount = 20;
				const num = array.length - this.turnIndex - this.preturnIndex
				if (num < 0) { num = array.length + num }
				if (this.updateCharaChooseRing) {
					this._ring_nemu_text_window.redraw($gameParty.allMembers()[num].name());//$gameActors.actor(num+1).name()
				} else {
					this._ring_nemu_text_window.redraw(this.ringMeunArray[num][1]);
				}
				this.turnIndex = this.turnIndex + this.preturnIndex;
				if (this.turnIndex >= array.length) { this.turnIndex -= array.length }
				return
			}
			is_right ? this.turnIndex++ : this.turnIndex--;
			if (this.turnIndex == array.length) {
				this.turnIndex = 0;
			} else if (this.turnIndex < 0) {
				this.turnIndex = array.length - 1;
			}
			let num = array.length - this.turnIndex
			if (this.turnIndex == 0) { num = 0 }
			if (this.updateCharaChooseRing) {
				this._ring_nemu_text_window.redraw($gameParty.allMembers()[num].name());//$gameActors.actor(num+1).name()
			} else {
				this._ring_nemu_text_window.redraw(this.ringMeunArray[num][1]);
			}
		}
	}

	//メニューアイコンを閉じる
	Scene_RingMenuChoice.prototype.updateIconContraction = function () {
		if (this.isCanceled() && !this.ringMenuCancel && !this.startIconMenu) {
			SoundManager.playCancel();
			this.ringMenuCancel = true;
			if (!this.chooseCharaMode) {
				this._ring_nemu_text_window.close()
				this._goldWindow.close();
				this._optionalTextWindow.close();
			}
		}

		if (this.ringMenuCancel) {
			this._ring_nemu_text_window.fadeTextOn();
			this.updateContraction(this.iconSpriteArray);

			if (this.iconSpriteArray[0].opacity <= 0) {
				this.ringMenuCancel = false;
				this.iconSpriteArray.forEach(function (sprite) {
					sprite.x = $gamePlayer.screenX();
					sprite.y = $gamePlayer.screenY();
				});
				if (!this.chooseCharaMode) {
					SceneManager.push(Scene_Map)
				};
			}
		}
	}

	//キャラクター選択アイコンを閉じる
	Scene_RingMenuChoice.prototype.updateCharaIconContraction = function () {
		if (this.isCanceled() && !this.ringCharaMenuCancel && !this.openChooseRing && this.chooseCharaMode) {
			SoundManager.playCancel();
			this.ringCharaMenuCancel = true;
			this.iconSpriteArray[0].scale = this.choosenIconSize;
			this.followerIconArray[this.nowChoiceIndex].scale = this.nomalIconSize;
			this.nowChoiceIndex = this.preChoiceIndex = 0;
		}

		if (this.ringCharaMenuCancel) {
			this._ring_nemu_text_window.fadeTextOn();
			this.updateContraction(this.followerIconArray);

			if (this.followerIconArray[0].opacity <= 0) {
				this.iconWidth = this.iconSpriteArray[0].bitmap.width;
				this.iconHeight = this.iconSpriteArray[0].bitmap.height;
				this.ringCharaMenuCancel = false;
				this.updateCharaChooseRing = false;
				this.startIconMenu = true;
				this.chooseCharaMode = false;
				this.turnIndex = 0
			}
		}
	}

	//アイコンを閉じる共通処理
	Scene_RingMenuChoice.prototype.updateContraction = function (array) {
		array.forEach(function (sprite, ind, arr) {
			const angle = 360 * ((ind + this.turnIndex) / arr.length) - 90
			const radius = this.menuIconRoundRadius / this.menuStartFrame
			sprite.x -= radius * Math.cos(angle * (Math.PI / 180));
			sprite.y -= radius * Math.sin(angle * (Math.PI / 180));
			sprite.opacity -= 255 / this.menuStartFrame;
		}.bind(this));
	}

	//メニューアイコンを開く
	Scene_RingMenuChoice.prototype.updateIconExpansion = function () {
		if (this.startIconMenu) {
			this.IconExpansion(this.iconSpriteArray);
			if (this.iconSpriteArray[0].opacity >= 255) {
				this.startIconMenu = false
				if (typeof (this._ring_nemu_text_window) == 'undefined') {
					this._ring_nemu_text_window = new Window_RingMenuText($gamePlayer.screenX(), $gamePlayer.screenY() - this.menuIconRoundRadius);
					this.addChild(this._ring_nemu_text_window);
				}
				this._ring_nemu_text_window.redraw(this.ringMeunArray[0][1]);
				this._ring_nemu_text_window.fadeInTextOn();
			}
		}
	}

	//キャラ選択アイコンを開く
	Scene_RingMenuChoice.prototype.updateCharaIconExpansion = function () {
		if (this.openChooseRing) {
			this.IconExpansion(this.followerIconArray);
			if (this.followerIconArray[0].opacity >= 255) {
				this._ring_nemu_text_window.redraw($gameParty.allMembers()[0].name());
				this._ring_nemu_text_window.fadeInTextOn();
				this.openChooseRing = false;
				this.updateCharaChooseRing = true;
			}
		}
	}

	//アイコンを開く共通処理
	Scene_RingMenuChoice.prototype.IconExpansion = function (array) {
		array.forEach(function (sprite, ind, arr) {
			const angle = 360 * (ind / arr.length) - 90
			const radius = this.menuIconRoundRadius / this.menuStartFrame
			sprite.x += radius * Math.cos(angle * (Math.PI / 180));
			sprite.y += radius * Math.sin(angle * (Math.PI / 180));
			sprite.opacity += 255 / this.menuStartFrame;
		}.bind(this));
	}

	Scene_RingMenuChoice.prototype.terminate = function () {
		this.update();
		for (let i = 0, n = this.iconSpriteArray.length; i < n; i++) {
			const sprite = this.iconSpriteArray[i];
			this.removeChild(sprite);
		}
		for (let i = 0, n = this.followerIconArray.length; i < n; i++) {
			const sprite = this.followerIconArray[i];
			this.removeChild(sprite);
		}
		this.removeChild(this._backgroundSprite);
		this.removeChild(this.charaSampleSprite);
	}

	//-----------------------------------------------------------------------------
	// Scene_Formation_Menu
	//
	// The scene class of the menu screen.

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

	Scene_Formation_Menu.prototype = Object.create(Scene_Menu.prototype);
	Scene_Formation_Menu.prototype.constructor = Scene_Formation_Menu;

	Scene_Formation_Menu.prototype.initialize = function () {
		Scene_Menu.prototype.initialize.call(this);
	};
	Scene_Formation_Menu.prototype.createStatusWindow = function () {
		this._statusWindow = new Window_MenuStatus(50, 0);
		this._statusWindow.x = (Graphics.width - this._statusWindow.width) / 2
		this.addWindow(this._statusWindow);
	};

	Scene_Formation_Menu.prototype.commandFormation = function () {
		this._statusWindow.setFormationMode(true);
		this._statusWindow.selectLast();
		this._statusWindow.activate();
		this._statusWindow.setHandler('ok', this.onFormationOk.bind(this));
		this._statusWindow.setHandler('cancel', this.onFormationCancel.bind(this));
	};

	//-----------------------------------------------------------------------------
	// SceneManager
	//
	// The static class that manages scene transitions.

	SceneManager.snapForNoBlueBackground = function () {
		this._noblurbackgroundBitmap = this.snap();
	};

	SceneManager.noblurbackgroundBitmap = function () {
		return this._noblurbackgroundBitmap;
	};

	//-----------------------------------------------------------------------------
	// Scene_Menu
	//
	// The static class that manages scene transitions.

	Scene_Menu.prototype.onFormationCancel = function () {
		if (this._statusWindow.pendingIndex() >= 0) {
			this._statusWindow.setPendingIndex(-1);
			this._statusWindow.activate();
		} else {
			SceneManager.push(Scene_Map)
		}
	};

	Scene_Menu.prototype.create = function () {
		Scene_MenuBase.prototype.create.call(this);
		this.createStatusWindow();
		this.commandFormation();
	};

	Scene_Menu.prototype.commandFormation = function () {
		this._statusWindow.setFormationMode(true);
		this._statusWindow.selectLast();
		this._statusWindow.activate();
		this._statusWindow.setHandler('ok', this.onFormationOk.bind(this));
		this._statusWindow.setHandler('cancel', this.onFormationCancel.bind(this));
	};

	//-----------------------------------------------------------------------------
	// Window_RingMenuText
	//
	// The window class with ring menu.

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

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

	Window_RingMenuText.prototype.initialize = function (x, y) {
		Window_Base.prototype.initialize.call(this, x - 5, y - iconTitleNameDistance, 130, 46);
		this.fade_text_on = false;
		this.fadein_text_on = true;
		this.openness = 255;
		this.opacity = 0;
		this.contentsOpacity = 0;
		this.contents.fontSize = 25
		this.x -= this.contentsWidth() / 2;
		this.drawText("アイテム", 0, 0, 120, "center");
		this.setBackgroundType(1)
	};

	Window_RingMenuText.prototype.standardPadding = function () {
		return 5;
	};

	Window_RingMenuText.prototype.update = function () {
		Window_Base.prototype.update.call(this);
		if (this.fade_text_on) {
			this.contentsOpacity -= 30;
			if (this.contentsOpacity <= 0) { this.fade_text_on = false; }
			return
		}
		if (this.fadein_text_on) {
			this.contentsOpacity += 30;
			if (this.contentsOpacity >= 255) { this.fadein_text_on = false }
		}
	}

	Window_RingMenuText.prototype.fadeTextOn = function () {
		this.fade_text_on = true;
	}

	Window_RingMenuText.prototype.fadeInTextOn = function () {
		this.fadein_text_on = true;
	}

	Window_RingMenuText.prototype.redraw = function (text) {
		this.contents.clear();
		this.drawText(text, 0, 0, 120, "center");
	};
})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// SAN_ActorGenerator.js
//=============================================================================
// Copyright (c) 2015 Sanshiro
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc SAN_ActorGenerator ver1.00
 * Generate actor by script command.
 * @author Sanshiro https://twitter.com/rev2nym
 *
 * @help
 * This plugin generate actor that specified actor ID by script command.
 * To use each script command (function), show ActorGenerator class comment.
 * To use other that isn't implemented on this plugin, please make up
 * with event commands.
 *
 * There is no plugin parameters, no plugin commands.
 *
 * It's possible to commercial use, distribute, and modify under the MIT license.
 * But, don't eliminate and don't alter a comment of the beginning.
 * If it's good, please indicate an author name on credit.
 *
 * Author doesn't shoulder any responsibility in all kind of damage by using this.
 * And please don't expect support. X(
 */

/*:ja
 * @plugindesc アクター生成 ver1.00
 * スクリプトコマンドによりアクターを生成します。
 * @author サンシロ https://twitter.com/rev2nym
 * @version 1.00 2015/12/27 公開
 *
 * @help
 * スクリプトコマンドにより指定したアクターIDのアクターを生成します。
 * 各スクリプトコマンド（関数）はActorGeneratorクラスのコメントを参照してください。
 * このプラグインに実装されていない機能はイベントコマンドで補ってください。
 *
 * プラグインパラメータ、プラグインコマンドはありません。
 *
 * MITライセンスのもと、商用利用、改変、再配布が可能です。
 * ただし冒頭のコメントは削除や改変をしないでください。
 * よかったらクレジットに作者名を記載してください。
 *
 * これを利用したことによるいかなる損害にも作者は責任を負いません。
 * サポートは期待しないでください＞＜。
 */

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

var Sanshiro = Sanshiro || {};
Sanshiro.ActorGenerator = Sanshiro.ActorGenerator || {};

//-----------------------------------------------------------------------------
// ActorGenerator
//
// アクター生成クラス

function ActorGenerator() { }

ActorGenerator._actorIdLastGenerated = undefined;

// Generate actor
// アクター生成
// baseActorId: Base actor's ID
//              生成のベースになるアクターのアクターID
// newActorId:  Generated actor's ID (can omission)
//              生成されたアクターのアクターID（省略可）
ActorGenerator.generateActor = function (baseActorId, newActorId) {
	if (newActorId === undefined) {
		for (newActorId = $dataActors.length; !!$gameActors.data()[newActorId]; newActorId++);
	}
	if (!$gameActors.data()[newActorId]) {
		$gameActors.data()[newActorId] = new Game_Actor(baseActorId);
		$gameActors.data()[newActorId].setActorId(newActorId);
		this._actorIdLastGenerated = newActorId;
	} else {
		this._actorIdLastGenerated = undefined;
	}
};

// Last generated actor's ID
// 最後に生成されたアクターのアクターID
ActorGenerator.actorIdLastGenerated = function () {
	return this._actorIdLastGenerated;
};

// Actor ID by party index
// パーティ順番によるアクターIDの取得
ActorGenerator.actorIdByPartyIndex = function (index) {
	return $gameParty.allMembers()[index].actorId();
};

// Add actor to party
// アクターのパーティ加入
ActorGenerator.changePartyMemberAdd = function (actorId) {
	$gameParty.addActor(actorId);
};

// Remove actor to party
// アクターのパーティ除外
ActorGenerator.changePartyMemberRemove = function (actorId) {
	$gameParty.removeActor(actorId);
};

// Change actor's equipment
// アクターの装備変更
ActorGenerator.changeEquipment = function (actorId, etypeId, itemId) {
	$gameActors[actorId].changeEquipById(etypeId, itemId);
};

// Change actor's name
// アクターの名前変更
ActorGenerator.changeName = function (actorId, name) {
	$gameActors[actorId].setName(name);
};

// Change actor's class
// アクターの職業変更
ActorGenerator.changeClass = function (actorId, classId, keepExp) {
	$gameActors[actorId].changeClass(classId, keepExp);
};

// Change actor's nickname
// アクターのニックネーム変更
ActorGenerator.changeNickname = function (actorId, nickname) {
	$gameActors[actorId].setNickname(nickname);
};

// Change actor's profile
// アクターのプロフィール変更
ActorGenerator.changeProfile = function (actorId, profile) {
	$gameActors[actorId].setProfile(profile);
};

// Change actor's face image
// アクターの顔画像変更
ActorGenerator.changeFaceImage = function (actorId, faceName, faceIndex) {
	$gameActors[actorId].setFaceImage(faceName, faceIndex);
};

// Change actor's walking character image
// アクターの歩行キャラ画像変更
ActorGenerator.changeCharacterImage = function (actorId, characterName, characterIndex) {
	$gameActors[actorId].setCharacterImage(characterName, characterIndex);
};

// Change actor's battler image
// アクターの戦闘キャラ画像変更
ActorGenerator.changeBattlerImage = function (actorId, battlerName) {
	$gameActors[actorId].setBattlerImage(battlerName);
};

//-----------------------------------------------------------------------------
// Game_Actors
//
// アクターズクラス

// アクターズクラスのアクター（エイリアス元でアクターオブジェクト生成）
Sanshiro.ActorGenerator.Game_Actors_actor = Game_Actors.prototype.actor;
Game_Actors.prototype.actor = function (actorId) {
	if (!!this._data[actorId]) {
		return this._data[actorId];
	}
	return Sanshiro.ActorGenerator.Game_Actors_actor.call(this, actorId);
};

// アクターズクラスのアクターのリスト
Game_Actors.prototype.data = function () {
	return this._data;
};

//-----------------------------------------------------------------------------
//　Game_Actor
//
// アクタークラス

// アクタークラスの初期化
Sanshiro.ActorGenerator.Game_Actor_initialize = Game_Actor.prototype.initialize;
Game_Actor.prototype.initialize = function (actorId) {
	this._dataActorId = actorId;
	Sanshiro.ActorGenerator.Game_Actor_initialize.call(this, actorId);
};

// アクタークラスのデータベースのデータ
Game_Actor.prototype.actor = function () {
	return $dataActors[this._dataActorId];
};

// アクタークラスのアクターIDの設定
Game_Actor.prototype.setActorId = function (actorId) {
	this._actorId = actorId;
};