code:
/*
############################################
	作者: COBRA
	改造や配布好き勝手にしても大丈夫だよ
	寧ろ積極的に配布して皆のゲーム開発を快適にしてあげて
	http://cobrara.blogspot.jp/
############################################
*/

// Version 1.1.3
// 2020/4/23 \C[0]に対応してませんでした
// 2018/4/26 ロードした際ステータスの変更もロードされるよう修正
// 2017/12/13 最新のバージョン(1.5)でデプロイメントすると1回目だけ画像が表示されない問題を修正
// 2017/8/27 1.1.0 ページの表示・非表示機能を追加しました
// 2017/7/30 1.0.4 最新のコアスクリプト(ver1.2c)にも対応しました
// 2017/5/4 1.0.3 エロステータス画面を開いてる最中NPCが動いてしまう問題を修正しました
// 2017/1/31 1.0.2 changeにおいて最後の項目に｢@@,@_,@=｣が含まれている場合エスケープされない問題を修正しました
// 2017/1/30 1.0.1 ピクチャ名に変数が反映されないバグを修正しました
// 2017/1/24 1.0.0

/*:
* @plugindesc エロステータス作れちゃうプラグイン(本体)
* @author COBRA
* @help Version 1.1.3
* 自由にいじれちゃうエロステータス画面
*
* 画像はimg/picturesにpngで保存してください
*
* 0pxの画像を表示しようとするとバグります
*
*
* 詳しくはこちらで
* http://cobrara.blogspot.jp/2017/01/blog-post_24.html
*
* 横幅：816　縦幅：624

* @param eroStaName
* @desc メニューに表示される名前だよ
* Default: エロステータス
* @default エロステータス
*
*
* @param
*
*
* @param commonEvent
* @desc エロステ画面を開く直前に実行されるコモンイベント、数値
* Default:
* @default
*/

var CBR_eroStatus = [];
var CBR_eroStatusState = {};

//表示するページ変える
Game_System.prototype.CBR_eroSta_page = function (list) {
  this.availablePage = list;
  CBR_eroStatusState.num = this.availablePage;
};

//起動・ロード・ニューゲーム時
var _CBR_Game_System_initialize = Game_System.prototype.initialize;
Game_System.prototype.initialize = function () {
  _CBR_Game_System_initialize.call(this);

  //初期値
  CBR_eroStatus = [];
  CBR_eroStatusState.num = [];
  CBR_eroStatusState.numOrigin = [];
  CBR_eroStatusState.now = null;
  CBR_eroStatusState.name = null;
  CBR_eroStatusState.event = null;

  this.availablePage = [];

  //ページ数取得
  //こっちがあったら

  for (var i = 0, len = $plugins.length; i < len; i++) {
    var temp = $plugins[i].name.match(/^CBR_eroStatus_(\d+)/); //プラグインが存在して
    if (temp) {
      CBR_eroStatusState.numOrigin[CBR_eroStatusState.numOrigin.length] =
        Number(temp[1]);
      CBR_eroStatusState.num[CBR_eroStatusState.num.length] = Number(temp[1]);
    }
  }

  //変更箇所の保存
  CBR_eroStatusState.numOrigin.sort(function (a, b) {
    return a - b;
  }); //_nの小さい順に
  this._CBR_eroSta_change_list = [];

  //numOriginに[1,2,4,8]ってページが入ってる

  //numには表示すべき[2,4]だけが入ってる

  //エロステには[obj,obj,obj,obj]とOriginに対応した順番で入ってる

  this._CBR_eroSta_pageList = [];

  var param = PluginManager.parameters("CBR_eroStatus_main");
  CBR_eroStatusState.name = "" + (param["eroStaName"] || "エロステータス");
  CBR_eroStatusState.event = Number(param["commonEvent"]) || null;

  for (var i = 0, len = CBR_eroStatusState.numOrigin.length; i < len; i++) {
    //ページの数だけ
    var n = CBR_eroStatusState.numOrigin[i];
    var param = PluginManager.parameters("CBR_eroStatus_" + n);
    //nは_n.js　1,2,3
    //iはページの順番　 0,1,2
    //保存する場合は0から99
    CBR_eroStatus[i] = { p: [], t: [] };

    this._CBR_eroSta_change_list[i] = {
      p: [],
      t: [],
    };

    for (var k = 1; k < 100; k++) {
      this.CBR_eroSta_add(
        "p",
        i,
        k - 1,
        param["picName_" + k],
        param["picX_" + k],
        param["picY_" + k],
        param["picOrigin_" + k],
        param["picShow_" + k],
        param["picOpacity_" + k],
        param["picZoom_" + k]
      );
      this.CBR_eroSta_add(
        "t",
        i,
        k - 1,
        param["txtSubject_" + k],
        param["txtX_" + k],
        param["txtY_" + k],
        param["txtOrigin_" + k],
        param["txtShow_" + k],
        param["txtAlign_" + k],
        param["txtSize_" + k]
      );
    }
  }

  this._CBR_eroSta_change_list = [];
  for (var i = 0, len = CBR_eroStatusState.numOrigin.length; i < len; i++) {
    //ページ分だけチェンジリスト作る
    this._CBR_eroSta_change_list[i] = {
      p: [],
      t: [],
    };
  }
};

//セーブデータ読み込み時に実行
var _CBR_Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
Game_System.prototype.onAfterLoad = function () {
  _CBR_Game_System_onAfterLoad.call(this);

  if (this.availablePage.length) {
    CBR_eroStatusState.num = this.availablePage;
  }

  for (var i = 0, len = CBR_eroStatusState.numOrigin.length; i < len; i++) {
    //ページ数分繰り返す
    for (var j = 0; j < 2; j++) {
      var ty = !j ? "p" : "t";
      var list = this._CBR_eroSta_change_list[i][ty]; //変更したいナンバーリスト
      for (var k = 0, len2 = list.length; k < len2; k++) {
        var koumokuList = list[k].list;
        for (var m = 0, len3 = koumokuList.length; m < len3; m++) {
          //チェンジする項目数
          if (!CBR_eroStatus[i][ty][list[k].page]) {
            //その項目のデフォが存在しなかったら作成
            this.CBR_eroSta_add(ty, i);
          }
          CBR_eroStatus[i][ty][list[k].num][koumokuList[m].name] =
            koumokuList[m].val;
        }
      }
    }
  }
};

Game_System.prototype.CBR_eroSta_getPageIndex = function (num) {
  //aはaligin or opacity bはzoom
  var ary = CBR_eroStatusState.numOrigin;
  for (var i = 0, len = ary.length; i < len; i++) {
    if (ary[i] == num) {
      return i;
    }
  }
};

Game_System.prototype.CBR_eroSta_add = function (
  type,
  page,
  num,
  data,
  x,
  y,
  origin,
  show,
  a,
  b
) {
  //aはaligin or opacity bはzoom
  if (type == "p") {
    CBR_eroStatus[page].p[num] = {
      name: data,
      x: this.CBR_eroSta_changeVal("x", x),
      y: this.CBR_eroSta_changeVal("y", y),
      origin: origin || "left",
      show: show == "on",
      opacity: this.CBR_eroSta_changeVal("opacity", a),
      zoom: this.CBR_eroSta_changeVal("zoom", b),
    };
  } else if (type == "t") {
    CBR_eroStatus[page].t[num] = {
      subject: data,
      x: this.CBR_eroSta_changeVal("x", x),
      y: this.CBR_eroSta_changeVal("y", y),
      origin: origin || "left",
      show: show == "on",
      align: a || "top",
      size: this.CBR_eroSta_changeVal("size", b),
    };
  }
};

Game_System.prototype.CBR_eroSta_changeVal = function (name, val) {
  //チェンジする時 add時　ロード時のチェンジで反映させよう
  switch (name) {
    case "x":
    case "y":
      return Number(val) || 0;
      break;
    case "opacity":
    case "zoom":
      if (val) {
        return Number(val) / 100;
      } else {
        return 1;
      }
      break;
    case "show":
      return val == "on";
      break;
    case "size":
      return Number(val) || 28;
      break;
    case "name":
    case "subject":
      return val || "";
      break;
    default:
      return val;
      break;
  }
};

Game_System.prototype.CBR_eroSta_change = function (ary) {
  var txt_ary = {
    fontsize: "fontSize",
    vardigit: "varDigit",
  };

  var checkList = {
    p: ["name", "origin", "x", "y", "show", "opacity", "zoom"],
    t: ["subject", "origin", "x", "y", "show", "align", "size"],
  };

  for (var i = 0, len = ary.length; i < len; i++) {
    //変更したいpage_type_nの分だけ
    var temp = ary[i].split(/@@|@_|@=|_|=/);
    var temp2 = ary[i].match(/@@|@_|@=|_|=/g);

    var list = []; //aryを分割したものを入れる
    var temp3 = "";
    for (var k = 0, len2 = temp.length; k < len2; k++) {
      if (temp2[k]) {
        if (temp2[k].charAt(0) == "@") {
          temp3 += temp[k] + temp2[k].charAt(1);
        } else {
          list[list.length] = temp3 + temp[k];
          temp3 = "";
        }
      } else {
        list[list.length] = temp3 + temp[k];
      }
    }

    list[0] = Number(list[0]);
    var page = null;
    for (var k = 0, len2 = CBR_eroStatusState.numOrigin.length; k < len2; k++) {
      //ページ数だけ回す
      if (CBR_eroStatusState.numOrigin[k] == list[0]) {
        //nと一致したら
        page = k;
      }
    }
    var type = list[1];
    var n = Number(list[2]) - 1;

    //しつこい気もするけどエロステータス開く時の軽さを最優先で
    var obj = this._CBR_eroSta_change_list[page][type];

    var objNum = false;
    for (var k = 0, len2 = obj.length; k < len2; k++) {
      //このページのchange数
      if (n == obj[k].num) {
        //nとチェンジしたい番号が一緒だったら
        objNum = k;
        break;
      }
    }
    if (objNum === false) {
      objNum = len2;
      obj[objNum] = {
        num: n,
        list: [],
      };
    }

    //変更したいパラメータ数だけ回す
    var chaList = obj[objNum].list;
    for (var k = 3, len2 = list.length; k + 1 < len2; k += 2) {
      var listNum = false;
      for (var m = 0, len3 = chaList.length; m < len3; m++) {
        //既に存在するチェンジ数
        if (list[k] == chaList[m].name) {
          //一致する箇所があるかどうか
          listNum = m;
          break;
        }
      }
      if (listNum === false) {
        //無かったら
        listNum = len3;
        for (var m = 0, len3 = checkList[type].length; m < len3; m++) {
          //ちゃんと項目通りかチェック
          if (list[k] == checkList[type][m]) {
            break;
          } else if (m + 1 == len3) {
            //もし無かったら
            alert("ERROR:CBR_eroSta_change引数");
          }
        }
      }
      list[k + 1] = this.CBR_eroSta_changeVal(list[k], list[k + 1]);
      chaList[listNum] = {
        name: list[k],
        val: list[k + 1],
      };
      CBR_eroStatus[page][type][n][list[k]] = list[k + 1];
    }
  }
};

//########### Scene ###########
function Scene_EroStatus() {
  this.initialize.apply(this, arguments);
}
Scene_EroStatus.prototype = Object.create(Scene_MenuBase.prototype);
Scene_EroStatus.prototype.constructor = Scene_EroStatus;

Scene_EroStatus.prototype.initialize = function () {
  Scene_MenuBase.prototype.initialize.call(this);
};
Scene_EroStatus.prototype.create = function () {
  Scene_MenuBase.prototype.create.call(this);
  if (CBR_eroStatusState.event) {
    $gameTemp.reserveCommonEvent(CBR_eroStatusState.event);
  }
  this._eroStatusWindow = new Window_EroStatus();
  this._eroStatusWindow.setHandler("cancel", this.popScene.bind(this));

  this._eroStatusWindow._margin = 0; //背景ピッチリする為
  this._eroStatusWindow.margin = 0; //本当はこっちだけどね
  this._eroStatusWindow._windowFrameSprite.visible = false; //枠線を消す

  this.addWindow(this._eroStatusWindow);
};

Scene_EroStatus.prototype.update = function () {
  $gameMap.refreshIfNeeded();
  if (this.isActive()) {
    $gameMap.updateInterpreter();
  }
  $gameMap.updateVehicles();

  Scene_Base.prototype.update.call(this);
};

//########### window ###########
function Window_EroStatus() {
  this.initialize.apply(this, arguments);
}

Window_EroStatus.prototype = Object.create(Window_Selectable.prototype);
Window_EroStatus.prototype.constructor = Window_EroStatus;

Window_EroStatus.prototype.initialize = function () {
  //windowを作る
  var width = Graphics.boxWidth;
  var height = Graphics.boxHeight;
  Window_Selectable.prototype.initialize.call(this, 0, 0, width, height);
  CBR_eroStatusState.now = 0;
  this._CBR_complete = false;
};

Window_EroStatus.prototype.CBR_complete = function () {
  //描写終わったかどうか
  return this._CBR_complete;
};

Window_EroStatus.prototype.update = function () {
  //毎回image描写してもいいけどそれだと負荷が多くなるのでこの方法で
  Window_Selectable.prototype.update.call(this);

  if (1 < CBR_eroStatusState.num.length && this.isOpenAndActive()) {
    //操作があった時
    if (Input.isRepeated("right") || Input.isRepeated("left")) {
      SoundManager.playCursor(2); //音楽鳴らす
      CBR_eroStatusState.now =
        CBR_eroStatusState.now + 1 < CBR_eroStatusState.num.length
          ? CBR_eroStatusState.now + 1
          : 0;
      this._CBR_complete = false; //初期化
      //this._statusWindow.refresh();//切り替えしたんでリフレッシュ
    }
  }

  var page = $gameSystem.CBR_eroSta_getPageIndex(
    CBR_eroStatusState.num[CBR_eroStatusState.now]
  );

  if (!this.CBR_complete()) {
    //まだ画像の描写してないのなら
    var flag = false;
    var ary = CBR_eroStatus[page].p;
    var p_data = [];
    //ピクチャの数だけ
    for (var i = 0, len = ary.length; i < len; i++) {
      var name = ary[i].name;
      if (!name || !ary[i].show) {
        continue;
      }
      name = name.replace(
        /\\(\\)|\\([VNP])\[(\d+)\]|\\(<)(.+)\\>/g,
        function (a, b, c, d, e, f) {
          //汚いけどこれは毎回やらないとね
          if (b) {
            //\\
            return "\\";
          } else if (c) {
            //[VNP]
            d = Number(d);
            switch (c) {
              case "V":
                return $gameVariables.value(d);
                break;
              case "N":
                return $gameActors._data[d]._name;
                break;
              case "P":
                return $dataActors[$gameParty._actors[d - 1]].name;
                break;
            }
          } else {
            //script
            return eval(f);
          }
        }
      );

      if (ary[i].var) {
        //変数があったら入れる
        var v = "" + $gameVariables.value(ary[i].var);
        if (ary[i].varDigit) {
          //2ケタの時は2まで
          if (v.length >= ary[i].varDigit) {
            name += v.substr(-1 * ary[i].varDigit, 1);
          } else {
            name = false;
          }
        } else {
          name += v;
        }
      }
      if (name) {
        var temp = ImageManager.loadPicture(name); //初回読み込み
        if (temp) {
          //if(temp._isLoading || temp._loadingState == 'requesting'){//前者は古いver用 ロード中ならアウト
          if (!temp.width) {
            //前者は古いver用 ロード中ならアウト
            flag = true;
            break;
          }
        } else {
          //その名前の画像が無かったら
          flag = true;
          this._CBR_complete = true;
          break;
        }
        p_data[i] = {
          w: temp.width,
          h: temp.height,
        };
      }
    }

    if (!flag) {
      //全ロードが終わってたら
      this.contents.clear();

      //ピクチャの表示
      var ary = CBR_eroStatus[page].p;
      for (var i = 0, len = ary.length; i < len; i++) {
        var name = ary[i].name;
        if (!name || !ary[i].show) {
          continue;
        }

        //変数とか文字化
        name = name.replace(
          /\\(\\)|\\([VNP])\[(\d+)\]|\\(<)(.+)\\>/g,
          function (a, b, c, d, e, f) {
            if (b) {
              //\\
              return "\\";
            } else if (c) {
              //[VNP]
              d = Number(d);
              switch (c) {
                case "V":
                  return $gameVariables.value(d);
                  break;
                case "N":
                  return $gameActors._data[d]._name;
                  break;
                case "P":
                  return $dataActors[$gameParty._actors[d - 1]].name;
                  break;
              }
            } else {
              //script
              return eval(f);
            }
          }
        );

        if (name) {
          this.changePaintOpacity(ary[i].opacity);

          var x = ary[i].x;
          var y = ary[i].y;
          if (ary[i].origin == "center") {
            x -= (p_data[i].w * ary[i].zoom) / 2;
            y -= (p_data[i].h * ary[i].zoom) / 2;
          }
          this.drawPicture("pictures", name, 0, 0, x, y, 0, 0, ary[i].zoom, 0);
        }
      }

      //テキストの表示
      this.resetTextColor();
      var ary = CBR_eroStatus[page].t;
      for (var i = 0, len = ary.length; i < len; i++) {
        var size = ary[i].size; // ary[i].fontSize;
        var temp = ary[i].subject;
        if (!temp || !ary[i].show) {
          continue;
        }

        var opAry = temp.match(/(\\\{|\\\}|\\[CI]\[\d+\])+/g);

        //先頭にある場合は"","tesa"になる
        var strAry = temp.split(/(?:\\\{|\\\}|\\[CI]\[\d+\])+/);

        var str = "";
        var allW = 0;
        var maxSize = null;
        var dataFAry = [];
        var dataWAry = [];
        var drawI = [];
        var drawC = [];
        //分割した配列の数
        for (var k = 0, len2 = strAry.length; k < len2; k++) {
          //前方にある\{のフォントサイズを入れる
          dataFAry[k] = k ? dataFAry[k - 1] : 0;
          drawI[k] = [];

          //変数とか文字化
          strAry[k] = strAry[k].replace(
            /\\(\\)|\\([VNP])\[(\d+)\]|\\(G)|\\(<)(.+)\\>/g,
            function (a, b, c, d, e, f, g) {
              if (b) {
                //\\
                return "\\";
              } else if (c) {
                //[VNP]
                d = Number(d);
                switch (c) {
                  case "V":
                    return $gameVariables.value(d);
                    break;
                  case "N":
                    return $gameActors._data[d]._name;
                    break;
                  case "P":
                    return $dataActors[$gameParty._actors[d - 1]].name;
                    break;
                }
              } else if (e) {
                //G
                return $dataSystem.currencyUnit;
              } else {
                //script
                return eval(g);
              }
            }
          );

          //自身の前に区切りマッチがあったら
          if (0 < k) {
            var temp = opAry[k - 1].split("\\"); //\\{\\}を分割する
            for (var m = 1, len3 = temp.length; m < len3; m++) {
              switch (temp[m].charAt(0)) {
                case "{":
                  dataFAry[k] += 6;
                  break;
                case "}":
                  dataFAry[k] -= 6;
                  break;
                case "C":
                  drawC[k] = Number(temp[m].match(/\[(\d+)\]/)[1]); //Cは複数あっても最後のが適応されれば良いわけで
                  break;
                case "I":
                  drawI[k][drawI[k].length] = Number(
                    temp[m].match(/\[(\d+)\]/)[1]
                  );
                  break;
              }
            }
          }
          this.contents.fontSize = size + dataFAry[k];
          this.contents.context.font = this.contents._makeFontNameText();
          dataWAry[k] = this.contents.context.measureText(strAry[k]).width; //何の為に+4するのか忘れた
          allW += dataWAry[k];

          if (strAry[k]) {
            //先頭に\{や変数がある時の問題　アイコン乃場合もここを通さないと
            if (maxSize === null) {
              //まだ記録されてなかったら入れよう
              maxSize = dataFAry[k];
            } else {
              maxSize = maxSize < dataFAry[k] ? dataFAry[k] : maxSize;
            }
          }
        }

        var x = ary[i].x;
        if (ary[i].origin == "center") {
          x -= allW / 2;
        } else if (ary[i].origin == "right") {
          x -= allW;
        }
        for (var k = 0, len2 = strAry.length; k < len2; k++) {
          this.contents.fontSize = size + dataFAry[k];
          this.contents.context.font = this.contents._makeFontNameText();
          //bottom→下揃え原点の上　top→上揃え原点の下　center→原点
          var line = ary[i].y;
          var iconLine = ary[i].y;
          if (ary[i].align == "top") {
            line += (size + dataFAry[k]) / 2;
          } else if (ary[i].align == "bottom") {
            line -= (size + dataFAry[k]) / 2;
            iconLine -= Window_Base._iconWidth;
          } else {
            iconLine -= Window_Base._iconWidth / 2;
          }
          if (drawI[k].length) {
            for (var m = 0, len3 = drawI[k].length; m < len3; m++) {
              this.drawIcon(drawI[k][m], x, iconLine);
              x += Window_Base._iconWidth;
            }
          }
          if (drawC[k] || drawC[k] === 0) {
            this.changeTextColor(this.textColor(drawC[k]));
          }
          this.contents.drawText(strAry[k], x, line, dataWAry[k], 0, "left");
          x += dataWAry[k];
        }
        this.contents.fontSize = this.standardFontSize();
      }
      this.resetTextColor();
      this.changePaintOpacity(true);

      this.activate();
      this._CBR_complete = true;
    }
  }
};

Window_EroStatus.prototype.drawPicture = function (
  dir,
  filename,
  sx,
  sy,
  x,
  y,
  w,
  h,
  zoom,
  hue
) {
  var bitmap = ImageManager.loadBitmap("img/" + dir + "/", filename, hue, true);
  this.contents.blt(
    bitmap,
    sx,
    sy,
    bitmap.width,
    bitmap.height,
    x,
    y,
    bitmap.width * zoom,
    bitmap.height * zoom
  );
};
Window_EroStatus.prototype.standardPadding = function () {
  return 0;
};
Window_Status.prototype.lineColor = function () {
  return this.normalColor();
};
Window_Status.prototype.maxEquipmentLines = function () {
  return 6;
};

//#########　コマンドの追加　##########
Scene_Menu.prototype.commandEroSta = function () {
  SceneManager.push(Scene_EroStatus);
};
setTimeout(function () {
  var _Scene_Menu_createCommandWindow =
    Scene_Menu.prototype.createCommandWindow;
  Scene_Menu.prototype.createCommandWindow = function () {
    _Scene_Menu_createCommandWindow.call(this);
    this._commandWindow.setHandler("eroStatus", this.commandEroSta.bind(this));
  };
}, 0);
_Window_MenuCommand_addOriginalCommands =
  Window_MenuCommand.prototype.addOriginalCommands;
Window_MenuCommand.prototype.addOriginalCommands = function () {
  _Window_MenuCommand_addOriginalCommands.call(this);
  this.addCommand(CBR_eroStatusState.name, "eroStatus", true);
};

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// CharacterGraphicExtend.js
// ----------------------------------------------------------------------------
// (C) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.10.4 2020/03/22 MOG_ChronoEngine.jsとの間で発生するエラーを解消(全面的な競合対策ではありません)
//                   MOG_CharPoses.jsとの競合を解消
// 1.10.3 2020/01/25 フレーム更新時に無駄な処理が実行されることでパフォーマンスが低下していた問題を修正
// 1.10.2 2018/11/19 UltraMode7との競合を解消(by けんせい様)
//                   TMNamePop.jsとの併用時、ネームポップがイベント画像の傾き、反転に影響されないよう修正
// 1.10.1 2018/10/05 敵キャラやピクチャを表示する際、エディタで元画像にインデックス1以外を指定していると画像が表示されない問題を修正
// 1.10.0 2018/09/25 イベント画像をトリミングして表示できる機能を追加
// 1.9.2 2018/07/11 EventEffects.jsとの競合を解消
// 1.9.1 2018/06/05 メモ欄タグで変数指定＋並列処理で変数操作にて発生するいくつかの問題を修正（by 奏ねこま様）
// 1.9.0 2018/02/20 不透明度をメモ欄で設定できる機能を追加
// 1.8.0 2017/08/27 マップで使用しているタイルセット以外のタイルセットを使ったイベントを作成できる機能を追加
// 1.7.0 2017/08/24 画像を別のものに変更するスクリプトを追加
// 1.6.1 2017/08/06 ヘルプを修正
// 1.6.0 2017/08/05 アクターのバトラー画像をマップ上に表示する機能を追加
// 1.5.3 2017/06/22 プラグインを適用していないデータをロードしたときにプレイヤーが表示されない問題を修正
// 1.5.2 2017/06/11 プライオリティの設定を0にすると設定が有効にならない問題を修正
// 1.5.1 2017/06/11 GALV_CamControl.jsとの競合を解消
// 1.5.0 2017/03/28 色調変更機能を追加
// 1.4.2 2017/02/03 メモ欄に制御文字\v[n]を使った場合に、一度マップ移動しないと反映されない問題を修正しました。
// 1.4.1 2016/11/27 T_dashMotion.jsとの競合を解決
// 1.4.0 2016/11/21 複数のページに対して別々の画像を割り当てる機能を追加しました。
// 1.3.0 2016/07/16 以下の機能を追加しました。
//                  遠景をイベントグラフィックとして利用可能
//                  イベント画像の原点を変更する機能、イベント画像の画面表示位置を絶対値指定する機能
// 1.2.1 2016/05/08 HalfMove.jsとの競合を解消
// 1.2.0 2016/03/19 戦闘発生時にイベントを消去しない設定を追加しました。
// 1.1.2 2016/03/04 本体バージョン1.1.0に合わせてキャラクターの乗算とスクリーンに対応しました。
// 1.1.1 2016/01/21 競合対策（YEP_MessageCore.js）
// 1.1.0 2016/01/11 キャラクターに回転角を設定する機能を追加
//                  移動ルートの指定のスクリプトから、回転角、拡大率、位置調整ができる機能を追加
// 1.0.0 2016/01/08 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc キャラクターグラフィック表示拡張プラグイン
 * @author トリアコンタン
 *
 * @param イベント消去無効
 * @desc エンカウント発生時にイベントを一瞬消去するエフェクトを無効にします。
 * @default false
 * @type boolean
 *
 * @help イベントのグラフィック表示方法を拡張して多彩な表現を可能にします。
 * イベントのメモ欄に所定の書式で記入してください。
 * 項目はカンマで区切ってください。引数には文章の表示と同じ制御文字が使用できます。
 * また、ページ数に「A」と入力すると全てのページが対象になります。
 *
 * <CGピクチャ:（ページ数）,（ファイル名）>
 * 指定したページが有効になった場合のグラフィックをピクチャ画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGピクチャ:1,Test> or <CGPicture:1,Test>
 *
 * 〇追加機能
 * 複数のページに対して別々の画像を割り当てたい場合は
 * ページごとにタグを作成してください。
 * 以下の例だと1ページ目ではaaa.pngが、2ページ目ではbbb.pngが使用されます。
 * 他のタグも同様です。
 * 例：<CGピクチャ:1,aaa><CGピクチャ:2,bbb>
 *
 * <CG敵キャラ:（ページ数）,（ファイル名）>
 * 指定したページが有効になった場合のグラフィックを敵キャラ画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CG敵キャラ:1,Bat> or <CGEnemy:1,Bat>
 *
 * <CGアイコン:（ページ数）,（インデックス）>
 * 指定したページが有効になった場合のグラフィックをアイコン画像から取得します。
 * 歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGアイコン:1,128> or <CGIcon:1,128>
 *
 * <CGフェイス:（ページ数）,（ファイル名）（インデックス）>
 * 指定したページが有効になった場合のグラフィックをフェイス画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGフェイス:1,Actor1,4> or <CGFace:1,Actor1,4>
 *
 * <CGアクター:（ページ数）,（ファイル名）（インデックス）>
 * 指定したページが有効になった場合のグラフィックをバトラー画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGアクター:1, Actor1_1, 0> or <CGActor:1, Actor1_1, 0>
 *
 * <CG遠景:（ページ数）,（ファイル名）>
 * 指定したページが有効になった場合のグラフィックを遠景画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CG遠景:1,Test> or <CGParallaxes:1,Test>
 *
 * 要注意！　これらのメモ欄でファイルを指定した場合、デプロイメント時に
 * 未使用ファイルとして除外される可能性があります。
 * その場合、削除されたファイルを入れ直す等の対応が必要です。
 *
 * <CGタイル:（ページ数）,（横幅）,（高さ）>
 * 指定したページが有効になった場合のグラフィックをタイルマップ画像から取得します。
 * 横幅と高さを指定して本棚やベッドが一つのイベントで表現できます。
 * イベントの画像選択から一番左上のタイルを選択してください。
 *
 * 例：<CGタイル:1,2,2> or <CGTile:1,2,2>
 *
 * <CGタイルセット:（ページ数）,（タイルセットID）>
 * 指定したページが有効になった場合のタイルセットを指定します。
 * マップで使用しているタイルセット以外のタイルセット画像が使えます。
 *
 * 例：<CGタイルセット:1,2> or <CGTileset:1,2>
 *
 * <CGシフト:（ページ数）,（X座標）,（Y座標）>
 * 指定したページが有効になった場合のグラフィック表示位置を
 * 指定したピクセル分ずらして表示します。
 *
 * 例：<CGシフト:1,16,-16> or <CGShift:1,16,-16>
 *
 * <CGプライオリティ:（ページ数）,（プライオリティ）>
 * 指定したページが有効になった場合の表示優先度を設定します。
 * 1～9までの値を設定できます。
 *
 * 例：<CGプライオリティ:1,6> or <CGPriority:1,6>
 *
 * ※それぞれのプライオリティの値
 * 0 : 下層タイル
 * 1 : 通常キャラの下
 * 3 : 通常キャラと同じ
 * 4 : 上層タイル
 * 5 : 通常キャラの上
 * 6 : 飛行船の影
 * 7 : フキダシ
 * 8 : アニメーション
 * 9 : マップタッチの行き先（白く光るヤツ）
 *
 * <CG合成方法:（ページ数）,（合成方法）>
 * 指定したページが有効になった場合のグラフィックの合成方法を設定します。
 * 0:通常 1:加算 2:乗算 3:スクリーン
 *
 * 例：<CG合成方法:1,2> or <CGBlendType:1,2>
 *
 * <CG拡大率:（ページ数）,（X拡大率）（Y拡大率）>
 * 指定したページが有効になった場合のグラフィックの拡大率を設定します。
 * 負の値を設定すると画像が反転します。
 *
 * 例：<CG拡大率:1,100,-100> or <CGScale:1,100,-100>
 *
 * <CG回転角:（ページ数）,（回転角）>
 * 指定したページが有効になった場合のグラフィックの回転角を設定します。
 * 回転の中心は、キャラクターの足下になります。0～360の範囲内で設定してください。
 *
 * 例：<CG回転角:1,180> or <CGAngle:1,180>
 *
 * <CG原点:（ページ数）,（X原点）,（Y原点）>
 * 指定したページが有効になった場合のグラフィックの原点(0...100)を設定します。
 * デフォルトではX原点が50、Y原点が100(画像の足下が原点になる)です。
 *
 * 例：<CG原点:1,0,0> or <CGOrigin:1,100,100>
 *
 * <CG絶対座標:（ページ数）,（X座標）,（Y座標）>
 * 指定したページが有効になった場合のグラフィック表示位置を
 * 絶対座標(ピクチャのようにマップのスクロールとは無関係に表示する)にします。
 * ただし、イベントそのものの位置は変わりません。
 *
 * 例：<CG絶対座標:1,16,-16> or <CGAbsolute:1,16,-16>
 *
 * <CG色調:（ページ数）,（R値）,（G値）（B値）>
 * 指定したページが有効になった場合の色調(-255～255)を設定します。
 *
 * 例：<CG色調:1,-255,0,255> or <CGTone:1,-255,0,255>
 *
 * <CG不透明度:（ページ数）,（合成方法）>
 * 指定したページが有効になった場合のグラフィックの不透明度を設定します。
 * 0:透明 - 255:不透明
 *
 * 例：<CG不透明度:1,64> or <CGOpacity:1,64>
 *
 * <CGトリミング:（ページ数）,（X座標）,（Y座標）,（横幅）,（縦幅）>
 * 画像を指定した矩形でトリミングして表示します。
 *
 * 例：<CGトリミング:1,0,0,24,24> or <CGトリミング:1,0,0,24,24>
 *
 * 〇スクリプト（高度な設定。移動ルートの指定からスクリプトで実行）
 *
 * ・拡大率の設定
 * this.setScale(（X座標）,（Y座標）);
 * 例：this.setScale(100, 100);
 *
 * ・回転角の設定
 * this.setAngle(（回転角）);
 * 例：this.setAngle(180);
 *
 * ・ピクセル単位位置の設定
 * this.shiftPosition(（X座標）,（Y座標）);
 * 例：this.shiftPosition(24, 24);
 *
 * ・色調の設定
 * this.setTone(（R値）,（G値）（B値）);
 * 例：this.setTone(255, -255, -255);
 *
 * ・画像の変更
 * this.changeImage(（新しいファイル名）, （インデックス）);
 * 例：this.changeImage('Package1', 3);
 *
 * ※1 画像種別(ピクチャ⇒遠景など)を変更することはできません。
 * ※2 インデックスの指定を省略した場合、変更前の値が維持されます。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * EventEffects.jsと併用する場合は、本プラグインを下に配置してください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function () {
  "use strict";
  var pluginName = "CharacterGraphicExtend";

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

  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 getArgArrayString = function (args, upperFlg) {
    var values = getArgString(args, upperFlg).split(",");
    for (var i = 0; i < values.length; i++) values[i] = values[i].trim();
    return values;
  };

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

  var getArgNumber = function (arg, min, max) {
    if (arguments.length < 2) min = -Infinity;
    if (arguments.length < 3) max = Infinity;
    return (parseInt(convertEscapeCharacters(arg), 10) || 0).clamp(min, max);
  };

  var convertEscapeCharacters = function (text) {
    if (text == null) text = "";
    text = text.replace(/\\/g, "\x1b");
    text = text.replace(/\x1b\x1b/g, "\\");
    text = text.replace(
      /\x1bV\[(\d+)\]/gi,
      function () {
        return $gameVariables.value(parseInt(arguments[1], 10));
      }.bind(this)
    );
    text = text.replace(
      /\x1bV\[(\d+)\]/gi,
      function () {
        return $gameVariables.value(parseInt(arguments[1], 10));
      }.bind(this)
    );
    text = text.replace(
      /\x1bN\[(\d+)\]/gi,
      function () {
        var actor =
          parseInt(arguments[1], 10) >= 1
            ? $gameActors.actor(parseInt(arguments[1], 10))
            : null;
        return actor ? actor.name() : "";
      }.bind(this)
    );
    text = text.replace(
      /\x1bP\[(\d+)\]/gi,
      function () {
        var actor =
          parseInt(arguments[1], 10) >= 1
            ? $gameParty.members()[parseInt(arguments[1], 10) - 1]
            : null;
        return actor ? actor.name() : "";
      }.bind(this)
    );
    text = text.replace(/\x1bG/gi, TextManager.currencyUnit);
    return text;
  };

  //=============================================================================
  // パラメータの取得とバリデーション
  //=============================================================================
  var paramEventHideInvalid = getParamBoolean([
    "EventHideInvalid",
    "イベント消去無効",
  ]);

  //=============================================================================
  // Game_CharacterBase
  //  拡張するプロパティを定義します。
  //=============================================================================
  var _DataManager_extractMetadata = DataManager.extractMetadata;
  DataManager.extractMetadata = function (data) {
    _DataManager_extractMetadata.apply(this, arguments);
    this.extractMetadataArray(data);
  };

  DataManager.extractMetadataArray = function (data) {
    var re = /<([^<>:]+)(:?)([^>]*)>/g;
    data.metaArray = {};
    var match = true;
    while (match) {
      match = re.exec(data.note);
      if (match) {
        var metaName = match[1];
        data.metaArray[metaName] = data.metaArray[metaName] || [];
        data.metaArray[metaName].push(match[2] === ":" ? match[3] : true);
      }
    }
  };

  //=============================================================================
  // Game_System
  //  ロード時にプレイヤーの初期化が必要な場合は初期化します。
  //=============================================================================
  var _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
  Game_System.prototype.onAfterLoad = function () {
    _Game_System_onAfterLoad.apply(this, arguments);
    if (!$gamePlayer.hasOwnProperty("_customResource")) {
      $gamePlayer.clearCgInfo();
    }
  };

  //=============================================================================
  // Game_CharacterBase
  //  拡張するプロパティを定義します。
  //=============================================================================
  var _Game_CharacterBase_initMembers =
    Game_CharacterBase.prototype.initMembers;
  Game_CharacterBase.prototype.initMembers = function () {
    _Game_CharacterBase_initMembers.apply(this, arguments);
    this.clearCgInfo();
  };

  Game_CharacterBase.prototype.clearCgInfo = function () {
    this._customResource = null;
    this._graphicColumns = 1;
    this._graphicRows = 1;
    this._additionalX = 0;
    this._additionalY = 0;
    this._customPriority = -1;
    this._scaleX = 100;
    this._scaleY = 100;
    this._tileBlockWidth = 1;
    this._tileBlockHeight = 1;
    this._angle = 0;
    this._originX = null;
    this._originY = null;
    this._absoluteX = null;
    this._absoluteY = null;
    this._customTilesetId = 0;
    this.setBlendMode(0);
  };

  Game_CharacterBase.prototype.customResource = function () {
    return this._customResource;
  };

  Game_CharacterBase.prototype.customTilesetId = function () {
    return this._customTilesetId;
  };

  Game_CharacterBase.prototype.graphicColumns = function () {
    return this._graphicColumns;
  };

  Game_CharacterBase.prototype.graphicRows = function () {
    return this._graphicRows;
  };

  Game_CharacterBase.prototype.scaleX = function () {
    return this._scaleX;
  };

  Game_CharacterBase.prototype.scaleY = function () {
    return this._scaleY;
  };

  Game_CharacterBase.prototype.setScale = function (x, y) {
    this._scaleX = x;
    this._scaleY = y;

    // ■■■ Altered Mod 開始 ■■■
    const followers = $gamePlayer.followers()._data;
    for (let i = 0; i < followers.length; i++) {
      followers[i]._scaleX = x;
      followers[i]._scaleY = y;
    }
    // ■■■ Altered Mod 終了  ■■■
  };

  Game_CharacterBase.prototype.originX = function () {
    return this._originX;
  };

  Game_CharacterBase.prototype.originY = function () {
    return this._originY;
  };

  Game_CharacterBase.prototype.setOrigin = function (x, y) {
    this._originX = x / 100;
    this._originY = y / 100;
  };

  Game_CharacterBase.prototype.absoluteX = function () {
    return this._absoluteX;
  };

  Game_CharacterBase.prototype.absoluteY = function () {
    return this._absoluteY;
  };

  Game_CharacterBase.prototype.setAbsolute = function (x, y) {
    this._absoluteX = x;
    this._absoluteY = y;
  };

  Game_CharacterBase.prototype.tone = function () {
    return this._tone;
  };

  Game_CharacterBase.prototype.setTone = function (r, g, b) {
    this._tone = [r, g, b];
  };

  Game_CharacterBase.prototype.angle = function () {
    return this._angle;
  };

  Game_CharacterBase.prototype.setAngle = function (angle) {
    this._angle = angle;
  };

  Game_CharacterBase.prototype.shiftPosition = function (x, y) {
    this._additionalX = x;
    this._additionalY = y;
  };

  Game_CharacterBase.prototype.tileBlockWidth = function () {
    return this._tileBlockWidth;
  };

  Game_CharacterBase.prototype.tileBlockHeight = function () {
    return this._tileBlockHeight;
  };

  Game_CharacterBase.prototype.getTrimRect = function () {
    return this._trimRect || null;
  };

  var _Game_CharacterBase_pos = Game_CharacterBase.prototype.pos;
  Game_CharacterBase.prototype.pos = function (x, y) {
    if (this.tileBlockWidth() >= 2) {
      return (
        this._x - this.tileBlockWidth() / 2 <= x &&
        this._x + this.tileBlockWidth() / 2 >= x &&
        this._y === y
      );
    } else {
      return _Game_CharacterBase_pos.apply(this, arguments);
    }
  };

  var _Game_CharacterBase_screenX = Game_CharacterBase.prototype.screenX;
  Game_CharacterBase.prototype.screenX = function () {
    return this._absoluteX > 0
      ? this.absoluteX()
      : _Game_CharacterBase_screenX.apply(this, arguments) + this._additionalX;
  };

  var _Game_CharacterBase_screenY = Game_CharacterBase.prototype.screenY;
  Game_CharacterBase.prototype.screenY = function () {
    return this._absoluteY > 0
      ? this.absoluteY()
      : _Game_CharacterBase_screenY.apply(this, arguments) + this._additionalY;
  };

  var _Game_CharacterBase_screenZ = Game_CharacterBase.prototype.screenZ;
  Game_CharacterBase.prototype.screenZ = function () {
    return this._customPriority >= 0
      ? this._customPriority
      : _Game_CharacterBase_screenZ.apply(this, arguments);
  };

  Game_CharacterBase.prototype.changeImage = function (fileName, fileIndex) {
    if (arguments.length < 2) {
      fileIndex = this._characterIndex;
    }
    Game_CharacterBase.prototype.setImage.call(this, fileName, fileIndex);
  };

  //=============================================================================
  // Game_Event
  //  拡張するプロパティを定義します。
  //=============================================================================
  Game_Event.blendModeParams = {
    1: 1,
    加算: 1,
    2: 2,
    乗算: 2,
    3: 3,
    スクリーン: 3,
  };

  Game_Event.prototype.getMetaCg = function (names) {
    if (!this.event().metaArray) {
      return null;
    }
    if (!Array.isArray(names)) names = [names];
    var metaParams = this.getMetaParameter(names);
    if (!metaParams) return null;
    var result = null;
    metaParams.some(
      function (metaParam) {
        var params = getArgArrayString(metaParam);
        if (this.isValidCgeParam(params)) {
          result = params;
          if (metaParam.match(/\\v/gi)) {
            this._graphicDynamic = true;
          }
        }
        return result;
      }.bind(this)
    );
    return result;
  };

  Game_Event.prototype.getMetaParameter = function (names) {
    var metaParams = null;
    names.some(
      function (name) {
        if (!metaParams || metaParams[0] === "") {
          metaParams = this.event().metaArray["CG" + name];
        }
        return metaParams;
      }.bind(this)
    );
    return metaParams;
  };

  Game_Event.prototype.isValidCgeParam = function (params) {
    var pageIndex = getArgNumber(params[0]);
    return (
      params.length > 1 &&
      (pageIndex === this._pageIndex + 1 || params[0].toUpperCase() === "A")
    );
  };

  var _Game_Event_refresh = Game_Event.prototype.refresh;
  Game_Event.prototype.refresh = function () {
    // added by nekoma start
    var moveRoute = this._moveRoute;
    var moveRouteIndex = this._moveRouteIndex;
    var moveRouteForcing = this._moveRouteForcing;
    var starting = this._starting;
    // added by nekoma end
    if (this._graphicDynamic) {
      this._pageIndex = -1;
    }
    _Game_Event_refresh.apply(this, arguments);
    // added by nekoma start
    if (this._graphicDynamic) {
      this._moveRoute = moveRoute;
      this._moveRouteIndex = moveRouteIndex;
      this._moveRouteForcing = moveRouteForcing;
      this._starting = starting;
    }
    // added by nekoma end
  };

  var _Game_Event_setupPageSettings = Game_Event.prototype.setupPageSettings;
  Game_Event.prototype.setupPageSettings = function () {
    this.clearCgInfo();
    _Game_Event_setupPageSettings.apply(this, arguments);
    var cgParams = this.getMetaCg(["シフト", "Shift"]);
    if (cgParams) {
      this.shiftPosition(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]));
    }
    cgParams = this.getMetaCg(["プライオリティ", "Priority"]);
    if (cgParams) {
      this._customPriority = getArgNumber(cgParams[1], 0, 10);
    }
    cgParams = this.getMetaCg(["合成方法", "BlendType"]);
    if (cgParams) {
      var blendMode = Game_Event.blendModeParams[cgParams[1]] || 0;
      this.setBlendMode(blendMode);
    }
    cgParams = this.getMetaCg(["拡大率", "Scale"]);
    if (cgParams) {
      this._scaleX = getArgNumber(cgParams[1]);
      this._scaleY = getArgNumber(cgParams[2]);
    }
    cgParams = this.getMetaCg(["回転角", "Angle"]);
    if (cgParams) {
      this.setAngle(getArgNumber(cgParams[1], 0, 360));
    }
    cgParams = this.getMetaCg(["原点", "Origin"]);
    if (cgParams) {
      this.setOrigin(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]));
    }
    cgParams = this.getMetaCg(["絶対座標", "Absolute"]);
    if (cgParams) {
      this.setAbsolute(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]));
    }
    cgParams = this.getMetaCg(["色調", "Tone"]);
    if (cgParams) {
      this.setTone(
        getArgNumber(cgParams[1]),
        getArgNumber(cgParams[2]),
        getArgNumber(cgParams[3])
      );
    }
    cgParams = this.getMetaCg(["不透明度", "Opacity"]);
    if (cgParams) {
      this.setOpacity(getArgNumber(cgParams[1]));
    }
    cgParams = this.getMetaCg(["トリミング", "Trimming"]);
    if (cgParams) {
      this._trimRect = new Rectangle(
        getArgNumber(cgParams[1]),
        getArgNumber(cgParams[2]),
        getArgNumber(cgParams[3]),
        getArgNumber(cgParams[4])
      );
    }
  };

  var _Game_Event_setTileImage = Game_Event.prototype.setTileImage;
  Game_Event.prototype.setTileImage = function (tileId) {
    _Game_Event_setTileImage.apply(this, arguments);
    var cgParams = this.getMetaCg(["タイル", "Tile"]);
    if (cgParams) {
      this._tileBlockWidth = getArgNumber(cgParams[1]);
      this._tileBlockHeight = getArgNumber(cgParams[2]);
    }
    cgParams = this.getMetaCg(["タイルセット", "Tileset"]);
    if (cgParams) {
      this._customTilesetId = getArgNumber(cgParams[1]);
    }
  };

  var _Game_Event_setImage = Game_Event.prototype.setImage;
  Game_Event.prototype.setImage = function (characterName, characterIndex) {
    var cgParams = this.getMetaCg(["ピクチャ", "Picture"]);
    if (cgParams) {
      this._customResource = "Picture";
      this._graphicColumns = 1;
      this._graphicRows = 1;
      arguments[0] = cgParams[1];
      arguments[1] = 0;
    }
    cgParams = this.getMetaCg(["敵キャラ", "Enemy"]);
    if (cgParams) {
      this._customResource = $gameSystem.isSideView() ? "SvEnemy" : "Enemy";
      this._graphicColumns = 1;
      this._graphicRows = 1;
      arguments[0] = cgParams[1];
      arguments[1] = 0;
    }
    cgParams = this.getMetaCg(["アイコン", "Icon"]);
    if (cgParams) {
      this._customResource = "System";
      this._graphicColumns = 16;
      this._graphicRows = 20;
      arguments[0] = "IconSet";
      arguments[1] = getArgNumber(
        cgParams[1],
        0,
        this._graphicColumns * this._graphicRows - 1
      );
    }
    cgParams = this.getMetaCg(["フェイス", "Face"]);
    if (cgParams) {
      this._customResource = "Face";
      this._graphicColumns = 4;
      this._graphicRows = 2;
      arguments[0] = cgParams[1];
      arguments[1] = getArgNumber(
        cgParams[2],
        0,
        this._graphicColumns * this._graphicRows - 1
      );
    }
    cgParams = this.getMetaCg(["遠景", "Parallax"]);
    if (cgParams) {
      this._customResource = "Parallax";
      this._graphicColumns = 1;
      this._graphicRows = 1;
      arguments[0] = cgParams[1];
      arguments[1] = 0;
    }
    cgParams = this.getMetaCg(["アクター", "Actor"]);
    if (cgParams) {
      this._customResource = "SvActor";
      this._graphicColumns = 9;
      this._graphicRows = 6;
      arguments[0] = cgParams[1];
      arguments[1] = getArgNumber(
        cgParams[2],
        0,
        this._graphicColumns * this._graphicRows - 1
      );
    }
    _Game_Event_setImage.apply(this, arguments);
  };

  //=============================================================================
  // Spriteset_Map
  //  イベントを消去するエフェクトを無効にします。
  //=============================================================================
  var _Spriteset_Map_hideCharacters = Spriteset_Map.prototype.hideCharacters;
  Spriteset_Map.prototype.hideCharacters = function () {
    if (!paramEventHideInvalid)
      _Spriteset_Map_hideCharacters.apply(this, arguments);
  };

  //=============================================================================
  // Sprite_Character
  //  拡張したプロパティに基づいてエフェクトを反映させます。
  //=============================================================================
  var _Sprite_Character_initMembers = Sprite_Character.prototype.initMembers;
  Sprite_Character.prototype.initMembers = function () {
    _Sprite_Character_initMembers.apply(this, arguments);
    this._customTilesetId = 0;
  };

  var _Sprite_Character_tilesetBitmap =
    Sprite_Character.prototype.tilesetBitmap;
  Sprite_Character.prototype.tilesetBitmap = function (tileId) {
    var customTilesetId = this._character.customTilesetId();
    this._customTilesetId = customTilesetId;
    if (customTilesetId) {
      var tileset = $dataTilesets[customTilesetId];
      var setNumber = 5 + Math.floor(tileId / 256);
      return ImageManager.loadTileset(tileset.tilesetNames[setNumber]);
    } else {
      return _Sprite_Character_tilesetBitmap.apply(this, arguments);
    }
  };

  var _Sprite_Character_updateBitmap = Sprite_Character.prototype.updateBitmap;
  Sprite_Character.prototype.updateBitmap = function () {
    if (this.isImageChanged())
      this._customResource = this._character.customResource();
    _Sprite_Character_updateBitmap.apply(this, arguments);
    this.updateExtend();
  };

  // Resolve conflict for MOG_CharPoses.js
  var _Sprite_Character_setBitmapCache =
    Sprite_Character.prototype.setBitmapCache;
  Sprite_Character.prototype.setBitmapCache = function () {
    if (this._customResource) {
      return;
    }
    _Sprite_Character_setBitmapCache.apply(this, arguments);
  };

  var _Sprite_Character_update = Sprite_Character.prototype.update;
  Sprite_Character.prototype.update = function () {
    _Sprite_Character_update.apply(this, arguments);
    // for T_dashMotion.js
    if (this.updateDashMotion) {
      this.resolveConflictForDashMotion();
    }

    // for UltraMode7.jp PRTN added ----
    if ($gameMap.useUltraMode7) {
      this.resolveConflictForUltraMode7();
    }
  };

  // PRTN added ---------
  Sprite_Character.prototype.resolveConflictForUltraMode7 = function () {
    if (this._character.scaleY() !== 100) {
      this.scale.x = (this._character.scaleX() / 100) * this.scale.x;
      this.scale.y = (this._character.scaleY() / 100) * this.scale.y;
    }
    if (this._character.angle() !== 0) {
      var angle = (this._character.angle() * Math.PI) / 180;
      if (this.rotation !== angle) this.rotation = angle;
    }
  };
  // --------------------

  Sprite_Character.prototype.resolveConflictForDashMotion = function () {
    if (this._character.scaleY() !== 100) {
      this.scale.y = (this._character.scaleY() / 100) * this.scale.y;
    }
    if (this._character.angle() !== 0) {
      var angle = (this._character.angle() * Math.PI) / 180;
      if (this.rotation !== angle) this.rotation = angle;
    }
  };

  Sprite_Character.prototype.updateExtend = function () {
    var scaleX = this._character.scaleX() / 100;
    var scaleY = this._character.scaleY() / 100;
    this.scale.x = scaleX;
    this.scale.y = scaleY;
    // for TMNamePop.js
    if (this._namePop && this._namePopSprite) {
      this._namePopSprite.scale.x = scaleX;
      this._namePopSprite.scale.y = scaleY;
    }
    var originX = this._character.originX();
    if (originX != null) this.anchor.x = originX;
    var originY = this._character.originY();
    if (originY != null) this.anchor.y = originY;
    var angle = (this._character.angle() * Math.PI) / 180;
    if (this.rotation !== angle) this.rotation = angle;
    var tone = this._character.tone();
    if (tone) this.setColorTone(tone);
  };

  // Resolve conflict by EventEffects.js
  var _Sprite_Character_updateAngle = Sprite_Character.prototype.updateAngle;
  Sprite_Character.prototype.updateAngle = function () {
    if (this._character.originY() != null) {
      return;
    }
    _Sprite_Character_updateAngle.apply(this, arguments);
  };

  var _Sprite_Character_setFrame = Sprite_Character.prototype.setFrame;
  Sprite_Character.prototype.setFrame = function (sx, sy, pw, ph) {
    var rect = this._character.getTrimRect();
    if (rect) {
      _Sprite_Character_setFrame.call(
        this,
        sx + rect.x,
        sy + rect.y,
        rect.width,
        rect.height
      );
    } else {
      _Sprite_Character_setFrame.call(
        this,
        sx,
        sy,
        pw * this._character.tileBlockWidth(),
        ph * this._character.tileBlockHeight()
      );
    }
  };

  var _Sprite_Character_isImageChanged =
    Sprite_Character.prototype.isImageChanged;
  Sprite_Character.prototype.isImageChanged = function () {
    return (
      _Sprite_Character_isImageChanged.apply(this, arguments) ||
      this.isCustomImageChanged()
    );
  };

  Sprite_Character.prototype.isCustomImageChanged = function () {
    return (
      this._customResource !== this._character.customResource() ||
      this._customTilesetId !== this._character.customTilesetId()
    );
  };

  var _Sprite_Character_setCharacterBitmap =
    Sprite_Character.prototype.setCharacterBitmap;
  Sprite_Character.prototype.setCharacterBitmap = function () {
    if (this._customResource) {
      this.bitmap = ImageManager["load" + this._customResource](
        this._characterName
      );
    } else {
      _Sprite_Character_setCharacterBitmap.apply(this, arguments);
    }
  };

  var _Sprite_Character_characterBlockX =
    Sprite_Character.prototype.characterBlockX;
  Sprite_Character.prototype.characterBlockX = function () {
    if (this._customResource) {
      return this._characterIndex % this._character.graphicColumns();
    } else {
      return _Sprite_Character_characterBlockX.apply(this, arguments);
    }
  };

  var _Sprite_Character_characterBlockY =
    Sprite_Character.prototype.characterBlockY;
  Sprite_Character.prototype.characterBlockY = function () {
    if (this._customResource) {
      return Math.floor(
        this._characterIndex / this._character.graphicColumns()
      );
    } else {
      return _Sprite_Character_characterBlockY.apply(this, arguments);
    }
  };

  var _Sprite_Character_patternWidth = Sprite_Character.prototype.patternWidth;
  Sprite_Character.prototype.patternWidth = function () {
    if (this._customResource) {
      return this.bitmap.width / this._character.graphicColumns();
    } else {
      return _Sprite_Character_patternWidth.apply(this, arguments);
    }
  };

  var _Sprite_Character_patternHeight =
    Sprite_Character.prototype.patternHeight;
  Sprite_Character.prototype.patternHeight = function () {
    if (this._customResource) {
      return this.bitmap.height / this._character.graphicRows();
    } else {
      return _Sprite_Character_patternHeight.apply(this, arguments);
    }
  };

  var _Sprite_Character_characterPatternX =
    Sprite_Character.prototype.characterPatternX;
  Sprite_Character.prototype.characterPatternX = function () {
    if (this._customResource) {
      return 0;
    } else {
      return _Sprite_Character_characterPatternX.apply(this, arguments);
    }
  };

  var _Sprite_Character_characterPatternY =
    Sprite_Character.prototype.characterPatternY;
  Sprite_Character.prototype.characterPatternY = function () {
    if (this._customResource) {
      return 0;
    } else {
      return _Sprite_Character_characterPatternY.apply(this, arguments);
    }
  };
})();


code:
/*=============================================================================
 ChoiceWindowInMessage.js
----------------------------------------------------------------------------
 (C)2019 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.0.2 2019/02/19 選択肢のみ表示するとき、ウィンドウ位置をスクリプトで変えられるよう調整
 1.0.1 2019/02/18 顔グラフィックを表示した場合、選択肢のカーソル位置がずれる問題を修正
 1.0.0 2019/02/17 初版
----------------------------------------------------------------------------
 [Blog]   : https://triacontane.blogspot.jp/
 [Twitter]: https://twitter.com/triacontane/
 [GitHub] : https://github.com/triacontane/
=============================================================================*/

/*:
 * @plugindesc ChoiceWindowInMessagePlugin
 * @author triacontane
 *
 * @help ChoiceWindowInMessage.js
 *
 * イベントコマンドの「選択肢」および「数値入力」ウィンドウが
 * メッセージウィンドウの内部に表示されるようになります。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 選択肢のメッセージ内部表示プラグイン
 * @author トリアコンタン
 *
 * @help ChoiceWindowInMessage.js
 *
 * イベントコマンドの「選択肢」および「数値入力」ウィンドウが
 * メッセージウィンドウの内部に表示されるようになります。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
  "use strict";

  /**
   * Scene_Map
   * 選択肢ウィンドウをWindowLayerから外します。(重なり時のマスクを避けるため)
   */
  var _Scene_Map_createMessageWindow = Scene_Map.prototype.createMessageWindow;
  Scene_Map.prototype.createMessageWindow = function () {
    _Scene_Map_createMessageWindow.apply(this, arguments);
    this.changeParentChoiceWindow();
  };

  var _Scene_Battle_createMessageWindow =
    Scene_Battle.prototype.createMessageWindow;
  Scene_Battle.prototype.createMessageWindow = function () {
    _Scene_Battle_createMessageWindow.apply(this, arguments);
    this.changeParentChoiceWindow();
  };

  Scene_Base.prototype.changeParentChoiceWindow = function () {
    this._messageWindow.subWindows().forEach(function (win) {
      if (win.isInnerMessage()) {
        this.addChild(this._windowLayer.removeChild(win));
      }
    }, this);
  };

  /**
   * Game_Message
   * メッセージおよび選択肢の行数を返します。
   */
  Game_Message.prototype.messageLines = function () {
    return this._texts.length;
  };

  Game_Message.prototype.choiceLines = function () {
    return this._choices.length;
  };

  Game_Message.prototype.isChoiceOrInput = function () {
    return this.isChoice() || this.isNumberInput();
  };

  Game_Message.prototype.setBaseWindowLine = function (value) {
    this._baseLine = value;
  };

  Game_Message.prototype.getBaseWindowLine = function () {
    return this._baseLine;
  };

  Game_Message.prototype.isOutInnerMessage = function (addLines) {
    var messageLines = this.messageLines();
    return (
      messageLines > 0 && messageLines + addLines > this.getBaseWindowLine()
    );
  };

  /**
   * Game_Interpreter
   * 文章の表示後に選択肢と数値入力が来た場合の挙動を変更します。
   */
  var _Game_Interpreter_setupChoices = Game_Interpreter.prototype.setupChoices;
  Game_Interpreter.prototype.setupChoices = function (params) {
    if ($gameMessage.isOutInnerMessage(params[0].length)) {
      this._index--;
      return;
    }
    _Game_Interpreter_setupChoices.apply(this, arguments);
  };

  var _Game_Interpreter_setupNumInput =
    Game_Interpreter.prototype.setupNumInput;
  Game_Interpreter.prototype.setupNumInput = function (params) {
    if ($gameMessage.isOutInnerMessage(1)) {
      this._index--;
      return;
    }
    _Game_Interpreter_setupNumInput.apply(this, arguments);
  };

  /**
   * Window_Base
   * メッセージウィンドウに内部に表示するかどうかを返します。
   */
  Window_Base.prototype.isInnerMessage = function () {
    return false;
  };

  /**
   * Window_Message
   * テキストの高さを返します。
   */
  var _Window_Message_initialize = Window_Message.prototype.initialize;
  Window_Message.prototype.initialize = function () {
    _Window_Message_initialize.apply(this, arguments);
    $gameMessage.setBaseWindowLine(this.numVisibleRows());
  };

  var _Window_Message_startMessage = Window_Message.prototype.startMessage;
  Window_Message.prototype.startMessage = function () {
    this.height = this.windowHeight();
    _Window_Message_startMessage.apply(this, arguments);
  };

  var _Window_Message_updatePlacement =
    Window_Message.prototype.updatePlacement;
  Window_Message.prototype.updatePlacement = function () {
    _Window_Message_updatePlacement.apply(this, arguments);
    $gameMessage.setBaseWindowLine(this.numVisibleRows());
  };

  Window_Message.prototype.getTextHeight = function () {
    return this._textState ? this._textState.y + this._textState.height : 0;
  };

  var _Window_Message_doesContinue = Window_Message.prototype.doesContinue;
  Window_Message.prototype.doesContinue = function () {
    return (
      _Window_Message_doesContinue.apply(this, arguments) ||
      $gameMessage.isChoiceOrInput()
    );
  };

  Window_Message.prototype.openForChoice = function () {
    if (!this._textState) {
      this.contents.clear();
    }
    if ($gameMessage.isChoice()) {
      var lines = $gameMessage.choiceLines();
      if (lines > this.numVisibleRows()) {
        this.height = this.fittingHeight(lines);
      } else {
        this.height = this.windowHeight();
      }
    }
    this.updatePlacement();
    this.open();
  };

  /**
   * Window_ChoiceList
   * 選択肢をメッセージウィンドウに含めます。
   */
  var _Window_ChoiceList_start = Window_ChoiceList.prototype.start;
  Window_ChoiceList.prototype.start = function () {
    this._messageWindow.openForChoice();
    _Window_ChoiceList_start.apply(this, arguments);
  };

  var _Window_ChoiceList_updatePlacement =
    Window_ChoiceList.prototype.updatePlacement;
  Window_ChoiceList.prototype.updatePlacement = function () {
    _Window_ChoiceList_updatePlacement.apply(this, arguments);
    this.x = this._messageWindow.x;
    this.y = this._messageWindow.y + this._messageWindow.getTextHeight();
  };

  var _Window_ChoiceList_windowWidth = Window_ChoiceList.prototype.windowWidth;
  Window_ChoiceList.prototype.windowWidth = function () {
    _Window_ChoiceList_windowWidth.apply(this, arguments);
    return this._messageWindow.width;
  };

  var _Window_ChoiceList_updateBackground =
    Window_ChoiceList.prototype.updateBackground;
  Window_ChoiceList.prototype.updateBackground = function () {
    _Window_ChoiceList_updateBackground.apply(this, arguments);
    this.opacity = 0;
  };

  var _Window_ChoiceList_itemRect = Window_ChoiceList.prototype.itemRect;
  Window_ChoiceList.prototype.itemRect = function (index) {
    var rect = _Window_ChoiceList_itemRect.apply(this, arguments);
    var newLineX = this._messageWindow.newLineX();
    rect.x += newLineX;
    rect.width -= newLineX;
    return rect;
  };

  Window_ChoiceList.prototype.isInnerMessage = function () {
    return true;
  };

  /**
   * Window_NumberInput
   * 選択肢をメッセージウィンドウに含めます。
   */
  var _Window_NumberInput_start = Window_NumberInput.prototype.start;
  Window_NumberInput.prototype.start = function () {
    this._messageWindow.openForChoice();
    _Window_NumberInput_start.apply(this, arguments);
  };

  var _Window_NumberInput_updatePlacement =
    Window_NumberInput.prototype.updatePlacement;
  Window_NumberInput.prototype.updatePlacement = function () {
    _Window_NumberInput_updatePlacement.apply(this, arguments);
    this.opacity = 0;
    this.x = this._messageWindow.x;
    this.y = this._messageWindow.y + this._messageWindow.getTextHeight();
  };

  var _Window_NumberInput_windowWidth =
    Window_NumberInput.prototype.windowWidth;
  Window_NumberInput.prototype.windowWidth = function () {
    _Window_NumberInput_windowWidth.apply(this, arguments);
    return this._messageWindow.width;
  };

  Window_NumberInput.prototype.isInnerMessage = function () {
    return true;
  };

  var _Window_NumberInput_buttonY = Window_NumberInput.prototype.buttonY;
  Window_NumberInput.prototype.buttonY = function () {
    if (this._messageWindow.y >= Graphics.boxHeight / 2) {
      return (
        _Window_NumberInput_buttonY.apply(this, arguments) -
        this._messageWindow.getTextHeight()
      );
    } else {
      return this._messageWindow.y + this._messageWindow.height - this.y + 8;
    }
  };

  var _Window_NumberInput_itemRect = Window_NumberInput.prototype.itemRect;
  Window_NumberInput.prototype.itemRect = function (index) {
    var rect = _Window_NumberInput_itemRect.apply(this, arguments);
    rect.x += this._messageWindow.newLineX();
    return rect;
  };
})();


code:
//
//  汎用ポップアップコア ver1.05
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

var Imported = Imported || {};
Imported["CommonPopupCore"] = 1.05;

/*:
 * @plugindesc ver1.05/汎用的なポップアップの仕組みを提供するためのベースプラグインです。
 * @author Yana
 *
 * @param Text Back Color
 * @desc ポップアップの背景カラーです。
 * rgba(red,green,blue,alpha)で設定してください。
 * @default rgba(0,0,0,0.6)
 *
 * @param Text Back FileName
 * @desc ポップアップの背景画像名です。
 * %dがインデックスに変換されます。
 * @default popup_back%d
 *
 * @help プラグインコマンド
 * CommonPopup add param1 param2 param3 ・・・
 *
 * 必要なパラメータのみを指定できます。
 *  例:プレイヤーの上にテストと240フレームポップアップさせる
 * CommonPopup add text:テスト count:240 eventId:-1
 *
 * パラメータ詳細:
 * text:表示テキスト
 * eventId:表示するイベントのID
 * count:表示時間
 * delay:表示遅延
 * moveX:目標地点X(相対座標)
 * moveY:目標地点Y(相対座標)
 * sx:表示位置補正X
 * sy:表示位置補正Y
 * pattern:表示パターン　0がフェード、-1が横ストレッチ、-2が縦ストレッチ
 * back:-1:透明背景,0:背景カラーで塗りつぶし,1以上:画像インデックス
 * bx:内容の表示位置補正X
 * by:内容の表示位置補正Y
 * extend:表示タイミングの調整用配列で指定。 例:extend:[20,50] 20フレーム掛けて出現し、50フレーム目から消え始める。
 * fixed:画面に固定するか？ true/falseで指定。
 * anchorX:
 * anchorY:
 * slideCount:新しいポップアップが発生した際、上にスライドさせる速度。
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 当プラグインはMITライセンスで公開されています。
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * このプラグインは、汎用的なポップアップの仕組みを提供するプラグインです。
 * このプラグイン単体ではプラグインコマンドを追加する以外の機能はありません。
 * 追加機能として、
 * ・\I[x]で描画されるアイコンのサイズが文字サイズに追従する。
 * ・文字サイズ変更の制御文字、\FS[x]が追加される。
 * の2点が追加されます。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.05:170525
 * ポップアップ発生時にSEを再生する機能を追加。
 * ver1.04
 * YEP_MessageCoreとの競合回避処理を追加。
 * 動作パターンに縦ストレッチと横ストレッチを追加。
 * ポップアップ用のプラグインパラメータが正常に動作していなかったバグを修正。
 * ver1.03:
 * backのパラメータにpicturesフォルダのファイル名を指定できるように変更。
 * ver1.02:
 * スライドに上から下に動作するようにする機能を追加。
 * ver1.01:
 * containerが作成されていない状態で、ポップアップが登録される可能性のあるバグを修正しました。
 * ver1.00:
 * 公開
 */

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

function CommonPopupManager() {
  throw new Error("This is a static class");
}

(function () {
  var parameters = PluginManager.parameters("CommonPopupCore");
  var commonPopupTextBackColor = String(
    parameters["Text Back Color"] || "rgba(0, 0, 0, 0.6)"
  );
  var commonPopupTextBackFileName = String(
    parameters["Text Back FileName"] || "popup_back%d"
  );

  var _cPU_GInterpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _cPU_GInterpreter_pluginCommand.call(this, command, args);
    if (command === "CommonPopup" || command === "ポップアップ") {
      switch (args[0]) {
        case "add":
        case "表示":
          this.addPopup(args);
          break;
        case "clear":
        case "消去":
          CommonPopupManager.clearPopup();
          break;
      }
    }
  };

  Array.prototype.setNullPos = function (object) {
    for (var i = 0; i < this.length; i++) {
      if (this[i] === null || this[i] === undefined) {
        this[i] = object;
        return i;
      }
    }
    this.push(object);
  };

  Array.prototype.compact = function () {
    var result = [];
    for (var i = 0; i < this.length; i++) {
      if (this[i] !== null && this[i] !== undefined) {
        result.push(this[i]);
      }
    }
    return result;
  };

  CommonPopupManager.initTempSprites = function () {
    this._tempCommonSprites = new Array(50);
    this._setedPopups = [];
    this._readyPopup = [];
  };

  CommonPopupManager.window = function () {
    if (this._window) {
      return this._window;
    }
    this._window = new Window_Base(0, 0, Graphics.boxWidth, Graphics.boxHeight);
    return this._window;
  };

  CommonPopupManager.testBitmap = function () {
    if (this._testBitmap) {
      return this._testBitmap;
    }
    this._testBitmap = new Bitmap(1, 1);
    return this._testBitmap;
  };

  Sprite_Popup.prototype = Object.create(Sprite.prototype);
  Sprite_Popup.prototype.constructor = Sprite_Popup;

  Sprite_Popup.prototype.initialize = function (index) {
    Sprite.prototype.initialize.call(this);
    this._index = index;
    this._count = 0;
    this._enable = false;
    this.update();
  };

  Sprite_Popup.prototype.setMembers = function (arg) {
    this._count = arg.count;
    this._arg = arg;
    this.anchor.x = arg.anchorX;
    this.anchor.y = arg.anchorY;
    this.x = arg.x;
    this.y = arg.y;
    this.z = 6;
    this.visible = true;
    this._enable = true;
    this.createBitmap();
    if (arg.slideCount) {
      CommonPopupManager._setedPopups.push([
        this._index,
        this.height,
        this._arg.slideCount,
      ]);
    }
  };

  Sprite_Popup.prototype.createBitmap = function () {
    if (this._arg.bitmap) {
      this.bitmap = this._arg.bitmap;
    } else {
      CommonPopupManager.window().resetFontSettings();
      var text = this._arg.text;
      var width = CommonPopupManager.window().textWidth(text);
      var height = CommonPopupManager.window().contents.fontSize + 8;
      var sh = 8;
      if (this._arg.back === 0) {
        sh = 2;
      }
      CommonPopupManager.window().createContents();
      this.bitmap = new Bitmap(width + 24, height + sh);
      this.drawBackRect(width + 24, height + sh);
      CommonPopupManager.window().drawTextEx(this._arg.text, 12, 4);
      this.bitmap.blt(
        CommonPopupManager.window().contents,
        0,
        0,
        width + 24,
        height + sh,
        this._arg.bx,
        this._arg.by + 2
      );
    }
  };

  Sprite_Popup.prototype.drawBackRect = function (width, height) {
    switch (this._arg.back) {
      case 0:
        var color1 = commonPopupTextBackColor;
        var color2 = "rgba(0,0,0,0)";
        var dSize = width / 4;
        this.bitmap.gradientFillRect(0, 0, dSize, height, color2, color1);
        this.bitmap.fillRect(dSize, 0, dSize * 2, height, color1);
        this.bitmap.gradientFillRect(
          dSize * 3,
          0,
          dSize,
          height,
          color1,
          color2
        );
        break;
      case -1:
        break;
      default:
        var bitmap = CommonPopupManager.makeBitmap(this._arg);
        var w = this._bitmap.width;
        var h = this._bitmap.height;
        if (typeof this._arg.back === "string") {
          w = bitmap.width > this._bitmap.width ? bitmap.width : w;
          h = bitmap.height > this._bitmap.height ? bitmap.height : h;
          if (w > this._bitmap.width || h > this._bitmap.height) {
            this.bitmap = new Bitmap(w, h);
          }
        }
        this.bitmap.blt(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, w, h);
        bitmap.clear();
        bitmap = null;
    }
  };

  Sprite_Popup.prototype.update = function () {
    Sprite.prototype.update.call(this);
    if (CommonPopupManager._tempCommonSprites[this._index] && !this._enable) {
      if (CommonPopupManager._tempCommonSprites[this._index].delay === 0) {
        this.setMembers(CommonPopupManager._tempCommonSprites[this._index]);
        if (this._arg && this._arg.se.name) AudioManager.playSe(this._arg.se);
      } else {
        CommonPopupManager._tempCommonSprites[this._index].delay--;
      }
    }
    if (this._count > 0) {
      this._count--;
      if (!this._arg) {
        this.terminate;
        return;
      }
      switch (this._arg.pattern) {
        case 0:
        case "0":
        case "Normal":
          this.updateSlide();
          break;
        case -1:
        case "-1":
        case "Stretch":
          this.updateTurn();
          break;
        case -2:
        case "-2":
        case "GrowUp":
          this.updateGrowUp();
          break;
        default:
          this.updateAnime();
      }
      if (this._count === 0) {
        this.terminate();
      }
    }
    if (this._arg && this._arg.slideCount) {
      this.updateMoveSlide();
    }
  };

  Sprite_Popup.prototype.updateMoveSlide = function () {
    if (CommonPopupManager._setedPopups) {
      var array = CommonPopupManager._setedPopups.clone().reverse();
      var n = 0;
      for (var i = 0; i < array.length; i++) {
        if (this._index === array[i][0]) {
          if (this._arg.slideAction === "Down") {
            this.y = this.y + n;
          } else {
            this.y = this.y - n;
          }
        }
        var sprite = CommonPopupManager._tempCommonSprites[array[i][0]];
        if (sprite.pattern === -2 || sprite.pattern === "GrowUp") {
          n += array[i][1] * sprite.rate;
        } else {
          n +=
            array[i][1] *
            ((this._arg.slideCount - array[i][2]) / this._arg.slideCount);
        }
      }
      for (var i = 0; i < CommonPopupManager._setedPopups.length; i++) {
        CommonPopupManager._setedPopups[i][2]--;
        if (CommonPopupManager._setedPopups[i][2] < 0) {
          CommonPopupManager._setedPopups[i][2] = 0;
        }
      }
      array = null;
    }
  };

  Sprite_Popup.prototype.updateSlide = function () {
    var originalWait = this._arg.count;
    var cnt = originalWait - this._count;
    this.opacity = 255;
    var act = [originalWait / 4, (originalWait * 3) / 4];
    if (this._arg.extend !== "") {
      act = this._arg.extend;
    }
    var oa = Math.max(originalWait - act[1], 1);
    var n1 = Math.max(originalWait / oa, 0.1);
    var up = this._arg.moveY / (originalWait / n1);
    var slide = this._arg.moveX / (originalWait / n1);
    var opTime1 = originalWait / 3.0;
    var moveX = 0;
    var moveY = 0;
    if (act[2]) {
      opTime1 = originalWait - act[2];
    }
    var opTime2 = originalWait / 3.0;
    if (act[3]) {
      opTime2 = act[3];
    }
    if (this._count >= act[1]) {
      this.opacity = Math.floor(255 * (cnt / opTime1));
      moveY = Math.floor(up * cnt);
      moveX = Math.floor(slide * cnt);
    } else if (this._count < act[0]) {
      this.opacity = Math.floor(255 * (this._count / opTime2));
      moveY = Math.floor((originalWait / n1) * up);
      moveX = Math.floor((originalWait / n1) * slide);
    } else {
      moveY = Math.floor((originalWait / n1) * up);
      moveX = Math.floor((originalWait / n1) * slide);
    }
    this._times = cnt;
    this.setPosition(moveX, moveY);
  };

  Sprite_Popup.prototype.updateTurn = function () {
    var originalWait = this._arg.count;
    var cnt = originalWait - this._count;
    var act = [originalWait * 0.25, originalWait * 0.75];
    if (this._arg.extend) act = this._arg.extend;
    if (this._count === 0) this.scale.x = 0;
    var oa = Math.max(originalWait - act[1], 1);
    var n1 = Math.max(originalWait / oa, 0.1);
    var up = this._arg.moveY / (originalWait / n1);
    var slide = this._arg.moveX / (originalWait / n1);
    var moveX = 0;
    var moveY = 0;
    if (this._count >= act[1]) {
      var rate = cnt / (originalWait - act[1]);
      this.scale.x = rate;
      moveY = Math.floor(up * cnt);
      moveX = Math.floor(slide * cnt);
    } else if (this._count < act[0]) {
      var rate = this._count / act[0];
      this.scale.x = rate;
      moveY = Math.floor((originalWait / n1) * up);
      moveX = Math.floor((originalWait / n1) * slide);
    } else {
      moveY = Math.floor((originalWait / n1) * up);
      moveX = Math.floor((originalWait / n1) * slide);
    }
    this._times = cnt;
    this.setPosition(moveX, moveY);
  };

  Sprite_Popup.prototype.updateGrowUp = function () {
    var originalWait = this._arg.count;
    var cnt = originalWait - this._count;
    var act = [originalWait * 0.25, originalWait * 0.75];
    if (this._arg.extend) act = this._arg.extend;
    if (this._count === 0) this.scale.y = 0;
    var oa = Math.max(originalWait - act[1], 1);
    var n1 = Math.max(originalWait / oa, 0.1);
    var up = this._arg.moveY / (originalWait / n1);
    var slide = this._arg.moveX / (originalWait / n1);
    var moveX = 0;
    var moveY = 0;
    if (this._count >= act[1]) {
      var rate = cnt / (originalWait - act[1]);
      this.scale.y = rate;
      moveY = Math.floor(up * cnt);
      moveX = Math.floor(slide * cnt);
      this._arg.rate = rate;
    } else if (this._count < act[0]) {
      var rate = this._count / act[0];
      this.scale.y = rate;
      moveY = Math.floor((originalWait / n1) * up);
      moveX = Math.floor((originalWait / n1) * slide);
      this._arg.rate = rate;
    } else {
      moveY = Math.floor((originalWait / n1) * up);
      moveX = Math.floor((originalWait / n1) * slide);
    }
    this._times = cnt;
    this.setPosition(moveX, moveY);
  };

  Sprite_Popup.prototype.setPosition = function (x, y) {
    this.x = this._arg.x + x + this._arg.sx;
    this.y = this._arg.y + y + this._arg.sy;
    if (this._arg.battler) {
      if ($gameParty.inBattle()) {
        this.x += this._arg.battler.x;
        this.y += this._arg.battler.y;
      } else {
        this.x += this._arg.battler._realX * $gameMap.tileWidth();
        this.y += this._arg.battler._realY * $gameMap.tileHeight();
      }
    }
    var xx = this.x;
    var yy = this.y;
    if (this._arg.fixed) {
      var dx = $gameMap._displayX;
      var dy = $gameMap._displayY;
      xx = this.x - dx * $gameMap.tileWidth();
      yy = this.y - dy * $gameMap.tileHeight();
      if (xx < 0 || yy < 0) {
        if (xx < 0 && $gameMap.isLoopHorizontal()) dx -= $dataMap.width;
        if (yy < 0 && $gameMap.isLoopVertical()) dy -= $dataMap.height;
        xx = this.x - dx * $gameMap.tileWidth();
        yy = this.y - dy * $gameMap.tileHeight();
      }
    }
    this.x = xx;
    this.y = yy;
  };

  Sprite_Popup.prototype.updateAnime = function () {
    var anime = $dataAnimations[Number(this._arg.pattern)];
    var frameId = Math.floor(
      (anime.frames.length * (this._arg.count - this._count)) / this._arg.count
    );
    if (frameId !== anime.frames.length) {
      var array = anime.frames[frameId][0];
      var x = array[1];
      var y = array[2];
      this.x = this._arg.x + x + this._arg.sx;
      this.y = this._arg.y + y + this._arg.sy;
      this.scale = new Point(array[3] / 100, array[3] / 100);
      this.rotation = array[4];
      this.opacity = array[6];
      this.blendMode = array[7];
    }
  };

  Sprite_Popup.prototype.terminate = function () {
    this.bitmap = null;
    this.visible = false;
    this._enable = false;
    this._count = 0;
    this._arg = null;

    if (CommonPopupManager._tempCommonSprites[this._index]) {
      CommonPopupManager._tempCommonSprites[this._index].terminate = true;
    }
    if (CommonPopupManager._setedPopups) {
      for (var i = 0; i < CommonPopupManager._setedPopups.length; i++) {
        if (CommonPopupManager._setedPopups[i][0] === this._index) {
          delete CommonPopupManager._setedPopups[i];
        }
      }
      CommonPopupManager._setedPopups =
        CommonPopupManager._setedPopups.compact();
    }
  };

  Game_Interpreter.prototype.addPopup = function (argParam) {
    var eventId = 0;
    for (var i = 0; i < argParam.length; i++) {
      if (argParam[i].match(/^eventId:(.+)/g)) {
        eventId = Number(RegExp.$1);
        break;
      }
    }
    var character = this.character(eventId);
    var arg = CommonPopupManager.setPopup(argParam, character);
    if (arg.back > 0 || typeof arg.back === "string") {
      CommonPopupManager.bltCheck(CommonPopupManager.makeBitmap(arg));
      CommonPopupManager._readyPopup.push(arg);
    } else {
      CommonPopupManager._tempCommonSprites.setNullPos(arg);
    }
  };

  CommonPopupManager.setPopup = function (argParam, character) {
    var arg = {
      x: null,
      y: null,
      text: "", // 表示テキスト
      eventId: -1, // 表示するイベントのID
      count: 60, // 表示時間
      delay: 0, // 表示遅延
      moveX: 0, // 目標地点X(相対座標)
      moveY: -48, // 目標地点Y(相対座標)
      sx: 0, // 表示位置補正X
      sy: 0, // 表示位置補正Y
      pattern: 0, // 表示パターン
      back: -1, // 背景に使う画像インデックス
      bx: 0, // 内容の表示位置補正X
      by: 0, // 内容の表示位置補正Y
      extend: "", //
      fixed: true, //
      anchorX: 0.5,
      anchorY: 0.5,
      battler: null,
      se: { name: "", volume: 90, pitch: 100, pan: 0 },
    };
    var array = [
      "x",
      "y",
      "text",
      "eventId",
      "count",
      "delay",
      "moveX",
      "moveY",
      "sx",
      "sy",
      "pattern",
      "back",
      "bx",
      "by",
      "extend",
      "fixed",
      "anchorX",
      "anchorY",
      "slideCount",
    ];
    for (var i = 0; i < argParam.length; i++) {
      if (i > 0) {
        for (var j = 0; j < array.length; j++) {
          var r = new RegExp("^(" + array[j] + ")" + ":(.+)");
          if (argParam[i].match(r)) {
            var code = RegExp.$1;
            var value = RegExp.$2;
            if (code === "text" || code === "extend") {
              arg[code] = value;
            } else if (code === "fixed") {
              arg[code] = value === "true";
            } else if (code === "back") {
              arg[code] = Number(value) !== NaN ? value : Number(value);
            } else {
              arg[code] = Number(value);
            }
          }
        }
      }
    }
    if (arg.x === null) {
      if (character) {
        var screenX = $gameParty.inBattle() ? 0 : character.screenX();
        var displayX = $gameParty.inBattle() ? 0 : $gameMap._displayX * 48;
        arg.x = screenX + displayX;
      } else {
        arg.x = 0;
      }
    }
    if (arg.y === null) {
      if (character) {
        var screenY = $gameParty.inBattle() ? 0 : character.screenY();
        var displayY = $gameParty.inBattle() ? 0 : $gameMap._displayY * 48;
        arg.y = screenY + displayY;
      } else {
        arg.y = 0;
      }
    }
    if (arg.extend) {
      arg.extend = eval(arg.extend);
    }

    arg.terminate = false;
    return arg;
  };

  CommonPopupManager.setPopUpdate = function () {
    if (this._readyPopup) {
      for (var i = 0; i < this._readyPopup.length; i++) {
        if (this._readyPopup[i]) {
          var arg = this._readyPopup[i];
          if (ImageManager.isReady()) {
            this.startPopup(arg);
            delete this._readyPopup[i];
            this._readyPopup.compact();
            return;
          } else {
            this.bltCheck(this.makeBitmap(arg));
          }
        }
      }
    }
  };

  CommonPopupManager.makeBitmap = function (arg) {
    if (typeof arg.back === "number") {
      var fileName = commonPopupTextBackFileName;
      fileName = fileName.replace(/%d/g, arg.back);
      return ImageManager.loadSystem(fileName);
    } else {
      var fileName = arg.back;
      return ImageManager.loadPicture(fileName);
    }
  };

  CommonPopupManager.bltCheck = function (bitmap) {
    this.testBitmap().blt(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0);
    //this.testBitmap().clear();
    //bitmap.clear();
    bitmap = null;
  };

  CommonPopupManager.startPopup = function (arg) {
    CommonPopupManager._tempCommonSprites.setNullPos(arg);
  };

  CommonPopupManager.clearPopup = function (tag) {
    if (!CommonPopupManager._tempCommonSprites) {
      CommonPopupManager.initTempSprites();
    }

    for (var i = 0; i < CommonPopupManager._tempCommonSprites.length; i++) {
      if (CommonPopupManager._tempCommonSprites[i]) {
        if (!tag || tag === CommonPopupManager._tempCommonSprites[i].tag) {
          CommonPopupManager._tempCommonSprites[i].delay = 0;
          CommonPopupManager._tempCommonSprites[i].count = 1;
          var sprite = CommonPopupManager._tempCommonSprites[i].sprite;
          if (sprite) sprite._count = 1;
        }
      }
    }
  };

  var _cPU_SsBase_initialize = Spriteset_Base.prototype.initialize;
  Spriteset_Base.prototype.initialize = function () {
    _cPU_SsBase_initialize.call(this);
    this.createSpritePopup();
  };

  var _cPU_SsBase_update = Spriteset_Base.prototype.update;
  Spriteset_Base.prototype.update = function () {
    _cPU_SsBase_update.call(this);
    if (this._popupContainer === undefined) {
      return;
    }
    if (CommonPopupManager._tempCommonSprites) {
      for (var i = 0; i < CommonPopupManager._tempCommonSprites.length; i++) {
        if (CommonPopupManager._tempCommonSprites[i]) {
          if (CommonPopupManager._tempCommonSprites[i].terminate) {
            var sprite = CommonPopupManager._tempCommonSprites[i].sprite;
            this._popupContainer.removeChild(sprite);
            delete CommonPopupManager._tempCommonSprites[i];
          } else if (!CommonPopupManager._tempCommonSprites[i].sprite) {
            var sprite = new Sprite_Popup(i);
            this._popupContainer.addChild(sprite);
            CommonPopupManager._tempCommonSprites[i].sprite = sprite;
          }
        }
      }
    }
  };

  var _cPU_SBase_update = Scene_Base.prototype.update;
  Scene_Base.prototype.update = function () {
    _cPU_SBase_update.call(this);
    if (CommonPopupManager) {
      CommonPopupManager.setPopUpdate();
    }
  };

  Spriteset_Base.prototype.createSpritePopup = function () {
    var width = Graphics.boxWidth;
    var height = Graphics.boxHeight;
    var x = (Graphics.width - width) / 2;
    var y = (Graphics.height - height) / 2;
    this._popupContainer = new Sprite();
    this._popupContainer.setFrame(x, y, width, height);
    this.addChild(this._popupContainer);
  };

  var _cPU_SBase_terminate = Scene_Base.prototype.terminate;
  Scene_Base.prototype.terminate = function () {
    _cPU_SBase_terminate.call(this);
    this.terminatePopup();
  };

  Scene_Base.prototype.terminatePopup = function () {
    if (!CommonPopupManager._tempCommonSprites) {
      CommonPopupManager.initTempSprites();
    }
    for (var i = 0; i < CommonPopupManager._tempCommonSprites.length; i++) {
      if (CommonPopupManager._tempCommonSprites[i]) {
        var sprite = CommonPopupManager._tempCommonSprites[i].sprite;
        if (sprite) sprite.terminate();
        delete CommonPopupManager._tempCommonSprites[i];
      }
    }
    CommonPopupManager._setedPopupss = [];
    CommonPopupManager._readyPopup = [];
  };

  var _cPU_SMap_launchBattle = Scene_Map.prototype.launchBattle;
  Scene_Map.prototype.launchBattle = function () {
    _cPU_SMap_launchBattle.call(this);
    this.terminatePopup();
  };

  // 再定義　文字サイズに合わせてアイコンのサイズを調整する
  Window_Base.prototype.drawIcon = function (iconIndex, x, y) {
    if (this.contents.fontSize === 27) {
      var bitmap = ImageManager.loadSystem("IconSet");
      var pw = Window_Base._iconWidth;
      var ph = Window_Base._iconHeight;
      var sx = (iconIndex % 16) * pw;
      var sy = Math.floor(iconIndex / 16) * ph;
      var n = Math.floor(
        (this.contents.fontSize / 28) * Window_Base._iconWidth
      );
      var nn = (32 - n) / 2;
      let adjSx = 0;
      if (sx === 0) adjSx = 1;
      this.contents.blt(bitmap, sx - 1 + adjSx, sy, pw, ph, x + 4, y, n, n);
    } else {
      var bitmap = ImageManager.loadSystem("IconSet");
      var pw = Window_Base._iconWidth;
      var ph = Window_Base._iconHeight;
      var sx = (iconIndex % 16) * pw;
      var sy = Math.floor(iconIndex / 16) * ph;
      var n = Math.floor(
        (this.contents.fontSize / this.standardFontSize()) *
          Window_Base._iconWidth
      );
      var nn = (32 - n) / 2;
      this.contents.blt(bitmap, sx, sy, pw, ph, x, y, n, n);
    }
  };

  Window_Message.prototype.drawIcon = function (iconIndex, x, y) {
    var bitmap = ImageManager.loadSystem("IconSet");
    var pw = Window_Base._iconWidth;
    var ph = Window_Base._iconHeight;
    var sx = (iconIndex % 16) * pw;
    var sy = Math.floor(iconIndex / 16) * ph;
    var n = Math.floor(
      (this.contents.fontSize / this.standardFontSize()) *
        Window_Base._iconWidth
    );
    var nn = (32 - n) / 2;
    this.contents.blt(bitmap, sx, sy, pw, ph, x, y, n, n);
  };

  Window_ChoiceList.prototype.drawIcon = function (iconIndex, x, y) {
    var bitmap = ImageManager.loadSystem("IconSet");
    var pw = Window_Base._iconWidth;
    var ph = Window_Base._iconHeight;
    var sx = (iconIndex % 16) * pw;
    var sy = Math.floor(iconIndex / 16) * ph;
    var n = Math.floor(
      (this.contents.fontSize / this.standardFontSize()) *
        Window_Base._iconWidth
    );
    var nn = (32 - n) / 2;
    this.contents.blt(bitmap, sx, sy, pw, ph, x, y, n, n);
  };

  ///////////////////////////////////////////////////////////////////////////////
  // ■■■ Altered Mod ■■■
  ///////////////////////////////////////////////////////////////////////////////

  // 再定義 processDrawIconをストレッチされた文字サイズに合わせたズレに調整する
  Window_Base.prototype.processDrawIcon = function (iconIndex, textState) {
    this.drawIcon(iconIndex, textState.x + 2, textState.y + 2);
    var n = Math.floor(
      (this.contents.fontSize / this.standardFontSize()) *
        Window_Base._iconWidth
    );
    textState.x += n + 4;
  };

  Window_Message.prototype.processDrawIcon = function (iconIndex, textState) {
    let y = textState.y;
    if (textState.y === 0) y += 3;
    this.drawIcon(iconIndex, textState.x + 2 + 3, y + 2);
    var n = Math.floor(
      (this.contents.fontSize / this.standardFontSize()) *
        Window_Base._iconWidth
    );
    textState.x += n + 4 + 3;
  };

  Window_ChoiceList.prototype.processDrawIcon = function (
    iconIndex,
    textState
  ) {
    this.drawIcon(iconIndex, textState.x + 2 + 3, textState.y + 2 - 1);
    var n = Math.floor(
      (this.contents.fontSize / this.standardFontSize()) *
        Window_Base._iconWidth
    );
    textState.x += n + 4 + 3;
  };

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

  if (!Imported.YEP_MessageCore) {
    // \FS[FontSize]の制御文字を追加する部分です。
    var _cPU_Window_Base_processEscapeCharacter =
      Window_Base.prototype.processEscapeCharacter;
    Window_Base.prototype.processEscapeCharacter = function (code, textState) {
      if (code === "FS") {
        var param = this.obtainEscapeParam(textState);
        if (param != "") {
          this.makeFontSize(param);
        }
      } else {
        _cPU_Window_Base_processEscapeCharacter.call(this, code, textState);
      }
    };
  }
  Window_Base.prototype.makeFontSize = function (fontSize) {
    this.contents.fontSize = fontSize;
  };
})();


code:
/*:
 * @plugindesc Plugin used to set basic parameters.
 * @author RM CoreScript team
 *
 * @help This plugin does not provide plugin commands.
 *
 * @param cacheLimit
 * @desc For setting the upper limit of image memory cache. (MPix)
 * @default 10
 *
 * @param screenWidth
 * @desc For setting the screen width.
 * @default 816
 *
 * @param screenHeight
 * @desc For setting the screen height.
 * @default 624
 *
 * @param changeWindowWidthTo
 * @desc If set, change window width to this value
 *
 * @param changeWindowHeightTo
 * @desc If set, change window height to this value
 *
 * @param renderingMode
 * @desc Rendering mode (canvas/webgl/auto)
 * @default auto
 *
 * @param alwaysDash
 * @desc To set initial value as to whether the player always dashes. (on/off)
 * @default off
 */

/*:ja
 * @plugindesc 基本的なパラメーターを設定するプラグインです。
 * @author RM CoreScript team
 *
 * @help このプラグインにはプラグインコマンドはありません。
 *
 * @param cacheLimit
 * @desc 画像のメモリへのキャッシュの上限値 (MPix)
 * @default 10
 *
 * @param screenWidth
 * @desc 画面サイズの幅
 * @default 816
 *
 * @param screenHeight
 * @desc 画面サイズの高さ
 * @default 624
 *
 * @param changeWindowWidthTo
 * @desc 値が設定された場合、ウインドウの幅を指定した値に変更
 *
 * @param changeWindowHeightTo
 * @desc 値が設定された場合、ウインドウの高さを指定した値に変更
 *
 * @param renderingMode
 * @desc レンダリングモード (canvas/webgl/auto)
 * @default auto
 *
 * @param alwaysDash
 * @desc プレイヤーが常時ダッシュするかどうかの初期値 (on/off)
 * @default off
 */

(function () {
  function toNumber(str, def) {
    return isNaN(str) ? def : +(str || def);
  }

  var parameters = PluginManager.parameters("Community_Basic");
  var cacheLimit = toNumber(parameters["cacheLimit"], 10);
  var screenWidth = toNumber(parameters["screenWidth"], 816);
  var screenHeight = toNumber(parameters["screenHeight"], 624);
  var renderingMode = parameters["renderingMode"].toLowerCase();
  var alwaysDash = parameters["alwaysDash"].toLowerCase() === "on";
  var windowWidthTo = toNumber(parameters["changeWindowWidthTo"], 0);
  var windowHeightTo = toNumber(parameters["changeWindowHeightTo"], 0);

  var windowWidth;
  var windowHeight;

  if (windowWidthTo) {
    windowWidth = windowWidthTo;
  } else if (screenWidth !== SceneManager._screenWidth) {
    windowWidth = screenWidth;
  }

  if (windowHeightTo) {
    windowHeight = windowHeightTo;
  } else if (screenHeight !== SceneManager._screenHeight) {
    windowHeight = screenHeight;
  }

  ImageCache.limit = cacheLimit * 1000 * 1000;
  SceneManager._screenWidth = screenWidth;
  SceneManager._screenHeight = screenHeight;
  SceneManager._boxWidth = screenWidth;
  SceneManager._boxHeight = screenHeight;

  SceneManager.preferableRendererType = function () {
    if (Utils.isOptionValid("canvas")) {
      return "canvas";
    } else if (Utils.isOptionValid("webgl")) {
      return "webgl";
    } else if (renderingMode === "canvas") {
      return "canvas";
    } else if (renderingMode === "webgl") {
      return "webgl";
    } else {
      return "auto";
    }
  };

  var _ConfigManager_applyData = ConfigManager.applyData;
  ConfigManager.applyData = function (config) {
    _ConfigManager_applyData.apply(this, arguments);
    if (config["alwaysDash"] === undefined) {
      this.alwaysDash = alwaysDash;
    }
  };

  var _SceneManager_initNwjs = SceneManager.initNwjs;
  SceneManager.initNwjs = function () {
    _SceneManager_initNwjs.apply(this, arguments);

    if (Utils.isNwjs() && windowWidth && windowHeight) {
      var dw = windowWidth - window.innerWidth;
      var dh = windowHeight - window.innerHeight;
      window.moveBy(-dw / 2, -dh / 2);
      window.resizeBy(dw, dh);
    }
  };
})();


code:
//=============================================================================
// CustomizeAttackGuard.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015-2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.0.0 2016/07/03 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc Attack And Guard Customize Plugin
 * @author triacontane
 *
 * @help Change skill ID for attack and guard
 *
 * Note for Actor, Weapon, Armor and others.(has Trait)
 *
 * Change attack skill ID
 * <CAGAttack:n> n:Skill ID
 *
 * Change guard skill ID
 * <CAGGuard:n> n:Skill ID
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 攻撃防御カスタマイズプラグイン
 * @author トリアコンタン
 *
 * @help 通常攻撃と防御を任意のスキルに差し替えることができます。
 * 特定の武器を装備すると通常攻撃が別のスキルに変化したり、
 * 強力な防御が実行できるアクターや職業を表現できます。
 *
 * アクターや武器、防具など「特徴」を有するデータベースのメモ欄に以下の通り入力してください。
 *
 * 通常攻撃のスキル(通常は1)を指定したスキルIDに差し替えます。
 * <CAG攻撃:n> n:スキルID
 *
 * 防御のスキル(通常は2)を指定したスキルIDに差し替えます。
 * <CAG防御:n> n:スキルID
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
  "use strict";
  var metaTagPrefix = "CAG";

  var getArgNumber = function (arg, min, max) {
    if (arguments.length < 2) min = -Infinity;
    if (arguments.length < 3) max = Infinity;
    return (parseInt(convertEscapeCharacters(arg), 10) || 0).clamp(min, max);
  };

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

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

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

  //=============================================================================
  // Game_BattlerBase
  //  特徴から情報を取得します。
  //=============================================================================
  var _Game_BattlerBase_attackSkillId =
    Game_BattlerBase.prototype.attackSkillId;
  Game_BattlerBase.prototype.attackSkillId = function () {
    var id = this.getCustomizeSkillId(["攻撃", "Attack"]);
    return id ? id : _Game_BattlerBase_attackSkillId.apply(this, arguments);
  };

  Game_BattlerBase.prototype.getDefaultAttackSkillId = function () {
    return _Game_BattlerBase_attackSkillId.apply(this, arguments);
  };

  var _Game_BattlerBase_guardSkillId = Game_BattlerBase.prototype.guardSkillId;
  Game_BattlerBase.prototype.guardSkillId = function () {
    var id = this.getCustomizeSkillId(["防御", "Guard"]);
    return id ? id : _Game_BattlerBase_guardSkillId.apply(this, arguments);
  };

  Game_BattlerBase.prototype.getDefaultGuardSkillId = function () {
    return _Game_BattlerBase_guardSkillId.apply(this, arguments);
  };

  Game_BattlerBase.prototype.getCustomizeSkillId = function (tagNames) {
    var skillId = null;
    this.traitObjects().some(function (data) {
      var value = getMetaValues(data, tagNames);
      if (value) skillId = getArgNumber(value, 1, $dataSkills.length - 1);
      return !!value;
    });
    return skillId;
  };

  //=============================================================================
  // Scene_Battle
  //  攻撃と防御コマンド選択時の挙動を変更します。
  //=============================================================================
  var _Scene_Battle_commandAttack = Scene_Battle.prototype.commandAttack;
  Scene_Battle.prototype.commandAttack = function () {
    var actor = BattleManager.actor();
    var id = actor.attackSkillId();
    if (id !== actor.getDefaultAttackSkillId()) {
      BattleManager.inputtingAction().setAttack();
      this.onSelectAction();
    } else {
      _Scene_Battle_commandAttack.apply(this, arguments);
    }
  };

  var _Scene_Battle_commandGuard = Scene_Battle.prototype.commandGuard;
  Scene_Battle.prototype.commandGuard = function () {
    var actor = BattleManager.actor();
    var id = actor.guardSkillId();
    if (id !== actor.getDefaultGuardSkillId()) {
      BattleManager.inputtingAction().setGuard();
      this.onSelectAction();
    } else {
      _Scene_Battle_commandGuard.apply(this, arguments);
    }
  };

  //=============================================================================
  // Window_ActorCommand
  //  攻撃と防御の表示名を変更します。
  //=============================================================================
  var _Window_ActorCommand_addAttackCommand =
    Window_ActorCommand.prototype.addAttackCommand;
  Window_ActorCommand.prototype.addAttackCommand = function () {
    var id = this._actor.attackSkillId();
    if (id !== this._actor.getDefaultAttackSkillId()) {
      this.addCommand($dataSkills[id].name, "attack", this._actor.canAttack());
    } else {
      _Window_ActorCommand_addAttackCommand.apply(this, arguments);
    }
  };

  var _Window_ActorCommand_addGuardCommand =
    Window_ActorCommand.prototype.addGuardCommand;
  Window_ActorCommand.prototype.addGuardCommand = function () {
    var id = this._actor.guardSkillId();
    if (id !== this._actor.getDefaultGuardSkillId()) {
      this.addCommand($dataSkills[id].name, "guard", this._actor.canGuard());
    } else {
      _Window_ActorCommand_addGuardCommand.apply(this, arguments);
    }
  };
})();