white-thirst/www/js/plugins/SealActorCommand.js

//=============================================================================
// SealActorCommand.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015-2017 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.4.0 2018/12/22 禁止コマンドの上に文字を被せられる機能を追加
// 1.3.0 2018/12/17 封印したコマンドを非表示ではなく使用禁止にできる機能を追加
// 1.2.0 2017/03/08 アイテム使用をスキルのひとつとして作成できる機能を追加
// 1.1.0 2017/02/23 封印対象にスキルを追加
// 1.0.0 2017/02/22 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc SealActorCommandPlugin
 * @author triacontane
 *
 * @param commandDisable
 * @desc 封印したコマンドを非表示ではなく使用禁止にします。
 * @default false
 * @type boolean
 *
 * @param disableSign
 * @desc 使用禁止にしたコマンドのうえに被せる文字列です。(コマンド使用禁止が有効な場合のみ機能します)
 * @default \i[1]\i[1]\i[1]
 *
 * @help アクターコマンド「攻撃」「防御」「アイテム」「スキル」を封印できます。
 * 封印されたコマンドはウィンドウから消失します。
 * 特定のコマンドが使用できないアクター、職業、装備品、ステートが作成できます。
 * さらに、スイッチやJavaScript計算式により、細かい条件が指定できます。
 *
 * 特徴を有するデータベースのメモ欄に以下の通り記入してください。
 *
 * <SAC攻撃封印スイッチ:4>   # ID[4]のスイッチがONのとき攻撃を封印
 * <SACAttackSwitch:4>       # 同上
 * <SAC防御封印スイッチ:5>   # ID[5]のスイッチがONのとき防御を封印
 * <SACGuardSwitch:5>        # 同上
 * <SAC道具封印スイッチ:6>   # ID[6]のスイッチがONのときアイテムを封印
 * <SACItemSwitch:6>         # 同上
 * <SACスキル封印スイッチ:7> # ID[7]のスイッチがONのときスキルを封印
 * <SACSkillSwitch:7>        # 同上
 * <SAC攻撃封印計算式:f>     # 計算式[f]の結果がtrueのとき攻撃を封印
 * <SACAttackFormula:f>      # 同上
 * <SAC防御封印計算式:f>     # 計算式[f]の結果がtrueのとき防御を封印
 * <SACGuardFormula:f>       # 同上
 * <SAC道具封印計算式:f>     # 計算式[f]の結果がtrueのときアイテムを封印
 * <SACItemFormula:f>        # 同上
 * <SACスキル封印計算式:f>   # 計算式[f]の結果がtrueのときスキルを封印
 * <SACSkillFormula:f>       # 同上
 *
 * 文章、スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → &lt;
 * > → &gt;
 * 例
 * <SACAttackFormula:\v[1] &gt;= 5> # 変数[1]が5以下の場合攻撃封印
 * <SACGuardFormula:true>           # 常に防御封印
 *
 * 注意！
 * 全てのコマンドを封印するとゲームが続行不可になります。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc アクターコマンド封印プラグイン
 * @author トリアコンタン
 *
 * @param commandDisable
 * @text コマンド使用禁止
 * @desc 封印したコマンドを非表示ではなく使用禁止にします。
 * @default false
 * @type boolean
 *
 * @param disableSign
 * @text 使用禁止サイン
 * @desc 使用禁止にしたコマンドのうえに被せる文字列です。(コマンド使用禁止が有効な場合のみ機能します)
 * @default \c[2]\i[1]禁止\i[1]
 *
 * @help アクターコマンド「攻撃」「防御」「アイテム」「スキル」を封印できます。
 * 封印されたコマンドはウィンドウから消失します。
 * 特定のコマンドが使用できないアクター、職業、装備品、ステートが作成できます。
 * さらに、スイッチやJavaScript計算式により、細かい条件が指定できます。
 *
 * 特徴を有するデータベースのメモ欄に以下の通り記入してください。
 *
 * <SAC攻撃封印スイッチ:4>   # ID[4]のスイッチがONのとき攻撃を封印
 * <SACAttackSwitch:4>       # 同上
 * <SAC防御封印スイッチ:5>   # ID[5]のスイッチがONのとき防御を封印
 * <SACGuardSwitch:5>        # 同上
 * <SAC道具封印スイッチ:6>   # ID[6]のスイッチがONのときアイテムを封印
 * <SACItemSwitch:6>         # 同上
 * <SACスキル封印スイッチ:7> # ID[7]のスイッチがONのときスキルを封印
 * <SACSkillSwitch:7>        # 同上
 * <SAC攻撃封印計算式:f>     # 計算式[f]の結果がtrueのとき攻撃を封印
 * <SACAttackFormula:f>      # 同上
 * <SAC防御封印計算式:f>     # 計算式[f]の結果がtrueのとき防御を封印
 * <SACGuardFormula:f>       # 同上
 * <SAC道具封印計算式:f>     # 計算式[f]の結果がtrueのときアイテムを封印
 * <SACItemFormula:f>        # 同上
 * <SACスキル封印計算式:f>   # 計算式[f]の結果がtrueのときスキルを封印
 * <SACSkillFormula:f>       # 同上
 *
 * 文章、スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → &lt;
 * > → &gt;
 * 例
 * <SACAttackFormula:\v[1] &gt;= 5> # 変数[1]が5以下の場合攻撃封印
 * <SACGuardFormula:true>           # 常に防御封印
 *
 * 注意！
 * 全てのコマンドを封印するとゲームが続行不可になります。
 *
 * アイテム使用をスキル化したい場合は、スキルのメモ欄に以下の通り
 * 入力してください。対象スキルを選択後、アイテムウィンドウが開きます。
 * <SACアイテムスキル> # アイテム使用スキル化
 * <SACItemSkill>      # 同上
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

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

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

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

  var getMetaValues = function (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 === true) return text;
    if (text == null) text = "";
    text = text.replace(/&gt;?/gi, ">");
    text = text.replace(/&lt;?/gi, "<");
    var windowLayer = SceneManager._scene._windowLayer;
    return windowLayer
      ? windowLayer.children[0].convertEscapeCharacters(text)
      : text;
  };

  /**
   * Create plugin parameter. param[paramName] ex. param.commandPrefix
   * @param pluginName plugin name(EncounterSwitchConditions)
   * @returns {Object} Created parameter
   */
  var createPluginParameter = function (pluginName) {
    var paramReplacer = function (key, value) {
      if (value === "null") {
        return value;
      }
      if (value[0] === '"' && value[value.length - 1] === '"') {
        return value;
      }
      try {
        return JSON.parse(value);
      } catch (e) {
        return value;
      }
    };
    var parameter = JSON.parse(
      JSON.stringify(PluginManager.parameters(pluginName), paramReplacer)
    );
    PluginManager.setParameters(pluginName, parameter);
    return parameter;
  };
  var param = createPluginParameter("SealActorCommand");

  //=============================================================================
  // Game_Actor
  //  コマンド封印が有効かどうかを判定します。
  //=============================================================================
  Game_Actor.prototype.getSealMetaInfo = function (names) {
    var metaValue = null;
    this.traitObjects().some(function (traitObject) {
      metaValue = getMetaValues(traitObject, names);
      return metaValue;
    });
    return metaValue;
  };

  Game_Actor.prototype.isSealCommand = function (commandNames) {
    var switchId = this.getSealMetaInfo([
      commandNames[0] + "Switch",
      commandNames[1] + "封印スイッチ",
    ]);
    if (switchId && $gameSwitches.value(getArgNumber(switchId))) {
      return true;
    }
    var formula = this.getSealMetaInfo([
      commandNames[0] + "Formula",
      commandNames[1] + "封印計算式",
    ]);
    return formula && eval(formula);
  };

  Game_Actor.prototype.isSealCommandAttack = function () {
    return this.isSealCommand(["Attack", "攻撃"]);
  };

  Game_Actor.prototype.isSealCommandGuard = function () {
    return this.isSealCommand(["Guard", "防御"]);
  };

  Game_Actor.prototype.isSealCommandItem = function () {
    return this.isSealCommand(["Item", "道具"]);
  };

  Game_Actor.prototype.isSealCommandSkill = function () {
    return this.isSealCommand(["Skill", "スキル"]);
  };

  //=============================================================================
  // Window_ActorCommand
  //  コマンドが封印されていた場合、処理を終了します。
  //=============================================================================
  var _Window_ActorCommand_addAttackCommand =
    Window_ActorCommand.prototype.addAttackCommand;
  Window_ActorCommand.prototype.addAttackCommand = function () {
    if (this._actor.isSealCommandAttack()) {
      if (param.commandDisable) {
        _Window_ActorCommand_addAttackCommand.apply(this, arguments);
        this.disableCommand("attack");
      }
      return;
    }
    _Window_ActorCommand_addAttackCommand.apply(this, arguments);
  };

  var _Window_ActorCommand_addGuardCommand =
    Window_ActorCommand.prototype.addGuardCommand;
  Window_ActorCommand.prototype.addGuardCommand = function () {
    if (this._actor.isSealCommandGuard()) {
      if (param.commandDisable) {
        _Window_ActorCommand_addGuardCommand.apply(this, arguments);
        this.disableCommand("guard");
      }
      return;
    }
    _Window_ActorCommand_addGuardCommand.apply(this, arguments);
  };

  var _Window_ActorCommand_addItemCommand =
    Window_ActorCommand.prototype.addItemCommand;
  Window_ActorCommand.prototype.addItemCommand = function () {
    if (this._actor.isSealCommandItem()) {
      if (param.commandDisable) {
        _Window_ActorCommand_addItemCommand.apply(this, arguments);
        this.disableCommand("item");
      }
      return;
    }
    _Window_ActorCommand_addItemCommand.apply(this, arguments);
  };

  var _Window_ActorCommand_addSkillCommands =
    Window_ActorCommand.prototype.addSkillCommands;
  Window_ActorCommand.prototype.addSkillCommands = function () {
    if (this._actor.isSealCommandSkill()) {
      if (param.commandDisable) {
        _Window_ActorCommand_addSkillCommands.apply(this, arguments);
        this.disableCommand("skill");
      }
      return;
    }
    _Window_ActorCommand_addSkillCommands.apply(this, arguments);
  };

  Window_ActorCommand.prototype.disableCommand = function (symbol) {
    this._list.forEach(function (command) {
      if (command.symbol === symbol) {
        command.enabled = false;
      }
    });
  };

  var _Window_ActorCommand_drawItem = Window_ActorCommand.prototype.drawItem;
  Window_ActorCommand.prototype.drawItem = function (index) {
    _Window_ActorCommand_drawItem.apply(this, arguments);
    var sign = param.disableSign;
    if (!this.isCommandEnabled(index) && sign) {
      var rect = this.itemRectForText(index);
      var width = this.drawTextEx(sign, this.windowWidth(), 0);
      var height = this.calcTextHeight({ text: sign }, false);
      this.resetFontSettings();
      this.resetTextColor();
      this.changePaintOpacity(true);
      this.drawTextEx(
        sign,
        rect.x + rect.width / 2 - width / 2,
        rect.y + rect.height / 2 - height / 2
      );
      this.resetFontSettings();
      this.resetTextColor();
      this.changePaintOpacity(false);
    }
  };

  //=============================================================================
  // Scene_Battle
  //  アイテムスキルを作成します。
  //=============================================================================
  var _Scene_Battle_onItemCancel = Scene_Battle.prototype.onItemCancel;
  Scene_Battle.prototype.onItemCancel = function () {
    if (this._selectItemSkill) {
      this._itemWindow.hide();
      this._skillWindow.show();
      this._skillWindow.activate();
      this._selectItemSkill = false;
    } else {
      _Scene_Battle_onItemCancel.apply(this, arguments);
    }
  };

  var _Scene_Battle_onSkillOk = Scene_Battle.prototype.onSkillOk;
  Scene_Battle.prototype.onSkillOk = function () {
    var skill = this._skillWindow.item();
    if (getMetaValues(skill, ["アイテムスキル", "ItemSkill"])) {
      var action = BattleManager.inputtingAction();
      action.setSkill(skill.id);
      BattleManager.actor().setLastBattleSkill(skill);
      this._skillWindow.hide();
      this.commandItem();
      this._selectItemSkill = true;
    } else {
      _Scene_Battle_onSkillOk.apply(this, arguments);
    }
  };

  var _Scene_Battle_onActorCancel = Scene_Battle.prototype.onActorCancel;
  Scene_Battle.prototype.onActorCancel = function () {
    if (this._selectItemSkill) {
      this._actorWindow.hide();
      this._itemWindow.show();
      this._itemWindow.activate();
    } else {
      _Scene_Battle_onActorCancel.apply(this, arguments);
    }
  };

  var _Scene_Battle_onEnemyCancel = Scene_Battle.prototype.onEnemyCancel;
  Scene_Battle.prototype.onEnemyCancel = function () {
    if (this._selectItemSkill) {
      this._enemyWindow.hide();
      this._itemWindow.show();
      this._itemWindow.activate();
    } else {
      _Scene_Battle_onEnemyCancel.apply(this, arguments);
    }
  };

  var _Scene_Battle_selectNextCommand =
    Scene_Battle.prototype.selectNextCommand;
  Scene_Battle.prototype.selectNextCommand = function () {
    _Scene_Battle_selectNextCommand.apply(this, arguments);
    this._selectItemSkill = false;
  };
})();