Double_X

DoubleX RMMV Action Cost Compatibility v101b

May 22nd, 2016
283
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*============================================================================
  2.  *    ## Plugin Info
  3.  *----------------------------------------------------------------------------
  4.  *    # Plugin Name
  5.  *      DoubleX RMMV Action Cost Compatibility
  6.  *----------------------------------------------------------------------------
  7.  *    # Terms Of Use
  8.  *      1. Commercial use's always allowed and crediting me's always optional.
  9.  *      2. You shall keep this plugin's Plugin Info part's contents intact.
  10.  *      3. You shalln't claim that this plugin's written by anyone other than
  11.  *         DoubleX or my aliases. I always reserve the right to deny you from
  12.  *         using any of my plugins anymore if you've violated this.
  13.  *      4. CC BY 4.0, except those conflicting with any of the above, applies
  14.  *         to this plugin, unless you've my permissions not needing follow so.
  15.  *      5. I always reserve the right to deny you from using this plugin
  16.  *         anymore if you've violated any of the above.
  17.  *----------------------------------------------------------------------------
  18.  *    # Prerequisites
  19.  *      Plugins:
  20.  *      1. DoubleX RMMV Action Cost
  21.  *      Abilities:
  22.  *      1. Nothing special
  23.  *----------------------------------------------------------------------------
  24.  *    # Links
  25.  *      This plugin:
  26.  *      1. http://pastebin.com/5DP26uff
  27.  *      Video:
  28.  *      1. https://www.youtube.com/watch?v=TyYqBKaB-Cw
  29.  *----------------------------------------------------------------------------
  30.  *    # Author
  31.  *      DoubleX
  32.  *----------------------------------------------------------------------------
  33.  *    # Changelog
  34.  *      v1.01b(GMT 0300 20-5-2020):
  35.  *      1. In sync with the latest DoubleX RMMV Action Cost version
  36.  *      v1.01a(GMT 0400 5-2-2020):
  37.  *      1. Addressed compatibility with
  38.  *         - Victor Engine MV - Conditional Turn Battle
  39.  *      v1.00d(GMT 1500 11-8-2016):
  40.  *      1. Removed compatibility with DoubleX RMMV Minimalized ATB
  41.  *      1. In sync with the latest DoubleX RMMV Popularized ATB Core version
  42.  *      v1.00c(GMT 1000 5-6-2016):
  43.  *      1. Addressed more compatibility issues with
  44.  *         - DoubleX RMMV Minimalized ATB
  45.  *         - DoubleX RMMV Popularized ATB Core
  46.  *      v1.00b(GMT 0300 29-5-2016):
  47.  *      1. Addressed compatibility with
  48.  *         - DoubleX RMMV Minimalized ATB
  49.  *         - DoubleX RMMV Popularized ATB Core
  50.  *      v1.00a(GMT 1500 22-5-2016):
  51.  *      1. 1st version of this plugin finished
  52.  *============================================================================*/
  53. /*:
  54.  * @plugindesc Fixes DoubleX RMMV Action Cost compatibility issues
  55.  * @author DoubleX
  56.  *
  57.  * @help
  58.  *============================================================================
  59.  *    ## Addressed Plugins
  60.  *----------------------------------------------------------------------------
  61.  *    # DoubleX RMMV Unison Item Config:
  62.  *      1. The action cost is the same for all unison actors
  63.  *         - Reference tag: Unison Item Config Act Cost
  64.  *         - Read <unison item actor act cost: costs> in DM.loadItemNotes
  65.  *         - Drawed the action cost in battle for each unison actor in
  66.  *           WIL.drawActCost and WSL.drawActCost
  67.  *         - The default unison item action cost will be shown for all unison
  68.  *           actors when outside battles
  69.  *    # DoubleX RMMV Unison Item Default:
  70.  *      1. The number of action slot reserved by unison invokees are always 1
  71.  *         - Reference tag: Unison Item Default Invokee Act Slot Num
  72.  *         - Checked the action cost for each unison invokee in
  73.  *           GBB.canUseUnisonSkill and GBB.canUseUnisonItem as well
  74.  *         - Stored and restored the action cost for each unison invokee in
  75.  *           BM.addUnisonActors and BM.eraseUnisonActors as well
  76.  *    # (v1.00b+)DoubleX RMMV Popularized ATB Core:
  77.  *      1. No battler can execute any action at all
  78.  *         - Reference tag: PATB Act Validity
  79.  *         - Extended BattleManager.processTurn to ensure no valid actions
  80.  *           will be falsely regarded as invalid ones
  81.  *    # (v1.00c+)DoubleX RMMV Popularized ATB Core:
  82.  *      1. Battlers inputting skills/items with action cost greater than 1
  83.  *         remains inputable after finishing inputting all skills/items
  84.  *         - Reference tag: PATB Inputability
  85.  *         - Extended Game_Action.prototype.confirm_patb_item,
  86.  *           Scene_Battle.prototype.confirm_patb_act and added GBB.confirmAct
  87.  *           to confirm the reserved action slots as well
  88.  *    # (v1.01a+)Victor Engine MV - Conditional Turn Battle:
  89.  *      1. No actions can be executed at all
  90.  *         - Reference tag: VE CTB Act Validity
  91.  *         - Extended BattleManager.setupAction to ensure no valid actions
  92.  *           will be falsely regarded as invalid ones
  93.  *============================================================================
  94.  *    ## Notetag Info
  95.  *----------------------------------------------------------------------------
  96.  *    # Skill/Item Notetags:
  97.  *      1. <unison item actor act cost: costs>
  98.  *         - Sets the list of action costs needed for each of the
  99.  *           corresponding id of the unison actor in <unison item actors: ids>
  100.  *           , is used to separate the mp costs in ids
  101.  *           E.g.:
  102.  *           If <unison item actors: 1> is used, then
  103.  *           <unison item actor act cost: 2> means actor with id 1 needs to
  104.  *           use 2 action slots for using the unison skill/item
  105.  *           If <unison item actors: 4, 2> is used, then
  106.  *           <unison item actor act cost: 2, 3> means actor with id 4 and 2
  107.  *           need to use 2 and 3 action slots respectively for using the
  108.  *           unison skill/item
  109.  *           If <unison item actors: 4, 2> is used, then
  110.  *           <unison item actor act cost: 2> means actor with id 4 needs to
  111.  *           pay 2 action slots while that with id 2 needs to use the number
  112.  *           of action slots of the unison skill/item for using it
  113.  *============================================================================
  114.  *    ## Plugin Call Info
  115.  *----------------------------------------------------------------------------
  116.  *    # Skill/Item manipulations
  117.  *      1. meta.unisonItemActorActCosts
  118.  *         - Returns the Array of action costs each needed by its
  119.  *           corresponding actor with id in meta.unisonItemActors to use this
  120.  *           skill/item
  121.  *      2. meta.unisonItemActorActCosts = [cost, cost, ...]
  122.  *         - Sets the Array of of action costs each needed by its
  123.  *           corresponding actor with id in meta.unisonItemActors to use this
  124.  *           skill/item
  125.  *         - All meta.unisonItemActorActCosts changes can be saved if
  126.  *           DoubleX RMMV Dynamic Data is used
  127.  *============================================================================
  128.  */
  129.  
  130. var DoubleX_RMMV = DoubleX_RMMV || {};
  131. DoubleX_RMMV['Act Cost Compatibility'] = 'v1.01b';
  132.  
  133. /*============================================================================
  134.  *    ## Plugin Implementations
  135.  *       You need not edit this part as it's about how this plugin works
  136.  *----------------------------------------------------------------------------
  137.  *    # Plugin Support Info:
  138.  *      1. Prerequisites
  139.  *         - Solid understanding of how DoubleX RMMV Action Cost and each
  140.  *           addressed plugin works
  141.  *         - Decent plugin development proficiency to fully comprehend this
  142.  *           plugin
  143.  *      2. Function documentation
  144.  *         - The 1st part describes why this function's rewritten/extended for
  145.  *           rewritten/extended functions or what the function does for new
  146.  *           functions
  147.  *         - The 2nd part describes what the arguments of the function are
  148.  *         - The 3rd part informs which version rewritten, extended or created
  149.  *           this function
  150.  *         - The 4th part informs whether the function's rewritten or new
  151.  *         - The 5th part informs whether the function's a real or potential
  152.  *           hotspot
  153.  *         - The 6th part describes how this function works for new functions
  154.  *           only, and describes the parts added, removed or rewritten for
  155.  *           rewritten or extended functions only
  156.  *         Example:
  157.  * /*----------------------------------------------------------------------
  158.  *  *    Why rewrite/extended/What this function does
  159.  *  *----------------------------------------------------------------------*/
  160. /* // arguments: What these arguments are
  161.  * functionName = function(arguments) { // Version X+; Hotspot
  162.  *     // Added/Removed/Rewritten to do something/How this function works
  163.  *     functionContents
  164.  *     //
  165.  * } // functionName
  166.  *----------------------------------------------------------------------------*/
  167.  
  168. if (DoubleX_RMMV['Act Cost']) {
  169.  
  170. DoubleX_RMMV.Act_Cost_Compatibility = {};
  171.  
  172. /*----------------------------------------------------------------------------*/
  173.  
  174. if (DoubleX_RMMV["PATB Core"]) { // v1.00b+
  175.  
  176. DoubleX_RMMV.Act_Cost_Compatibility["PATB Core"] = {};
  177.  
  178. (function(AC, ACCATB) {
  179.  
  180.     'use strict';
  181.  
  182.     ACCATB.BattleManager = {};
  183.     var BM = ACCATB.BattleManager;
  184.  
  185.     BM.processTurn = BattleManager.processTurn;
  186.     BattleManager.processTurn = function() {
  187.         // Added to ensures battlers can use valid actions upon executing them
  188.         this._subject.actCostInputs = -999;
  189.         // PATB Act Validity
  190.         BM.processTurn.apply(this, arguments);
  191.     }; // BattleManager.processTurn
  192.  
  193.     ACCATB.Game_BattlerBase = {};
  194.     var GBB = ACCATB.Game_BattlerBase;
  195.  
  196.     // act: The action to have all its reserved action slots confirmed
  197.     GBB.confirmAct = function(act) { // v1.00c+; New
  198.         // Ensures all reserved action slots are confirmed as well
  199.         var reservedActs = GB.actCost.call(this, act.item()) - 1;
  200.         var lastAct = this._actions.length - this._actCostInputs - 1;
  201.         for (var index = lastAct; index > lastAct - reservedActs; index--) {
  202.             this._actions[index].patb_confirm = true;
  203.         }
  204.         // PATB Inputability
  205.     }; // GBB.confirmAct
  206.  
  207.     var GB = AC.Game_Battler;
  208.  
  209.     ACCATB.Game_Actor = {};
  210.     var GA = ACCATB.Game_Actor;
  211.  
  212.     GA.confirm_patb_act = Game_Actor.prototype.confirm_patb_act;
  213.     Game_Actor.prototype.confirm_patb_act = function() {
  214.     // v1.00c+
  215.         GA.confirm_patb_act.apply(this, arguments);
  216.         // Added to ensure all reserved action slots are confirmed as well
  217.         GBB.confirmAct.call(this, this.inputtingAction());
  218.         // PATB Inputability
  219.     }; // Game_Actor.prototype.confirm_patb_act
  220.  
  221. })(DoubleX_RMMV.Act_Cost, DoubleX_RMMV.Act_Cost_Compatibility["PATB Core"]);
  222.  
  223. } // if (DoubleX_RMMV["PATB Core"])
  224.  
  225. /*----------------------------------------------------------------------------*/
  226.  
  227. if (DoubleX_RMMV["Unison Item Default"]) {
  228.  
  229. DoubleX_RMMV.Act_Cost_Compatibility["Unison Item Default"] = {};
  230.  
  231. (function(AC, UI, ACCUI) {
  232.  
  233.     'use strict';
  234.  
  235.     var DM = UI.DataManager;
  236.     ACCUI.DataManager = {};
  237.     var DMACCUI = ACCUI.DataManager;
  238.  
  239.     // data: The data to have its notetags read
  240.     DMACCUI.loadItemNotes = DM.loadItemNotes;
  241.     DM.loadItemNotes = function(data) {
  242.         DMACCUI.loadItemNotes(data);
  243.         // Added to read and store values of <unison item actor act cost: costs>
  244.         var uIAACs = data.meta.unisonItemActorActCosts = [];
  245.         var ACs = /< *unison +item +actor +act +cost *: *(\d+(?: *, *\d+)*) *>/i;
  246.         data.note.split(/[\r\n]+/).forEach(function(line) {
  247.             if (line.match(ACs)) { DM.storeItemNotes(uIAACs); }
  248.         });
  249.         // Unison Item Config Act Cost
  250.     }; // DM.loadItemNotes
  251.  
  252.     var BM = AC.BattleManager;
  253.     ACCUI.BattleManager = {};
  254.     var BMACCUI = ACCUI.BattleManager;
  255.  
  256.     BMACCUI.reserveActs = BM.reserveActs;
  257.     BM.reserveActs = function() {
  258.         // Rewritten to not using this function for unison skills/items
  259.         var actor = this.actor();
  260.         if (!actor) { return; }
  261.         if (actor.inputtingAction().item().meta.unisonItemActors.length <= 1) {
  262.             BMACCUI.reserveActs.apply(this, arguments);
  263.         }
  264.         // Unison Item Config Act Cost
  265.     }; // BM.reserveActs
  266.  
  267.     BMACCUI.releaseReservedActs = BM.releaseReservedActs;
  268.     BM.releaseReservedActs = function() {
  269.         // Added to not using this function for unison skills/items
  270.         var actor = this.actor();
  271.         if (!actor) { return; }
  272.         var act = actor.inputtingAction();
  273.         if (act.item().meta.unisonItemActors.length > 1) { return act.clear(); }
  274.         // Unison Item Config Act Cost
  275.         BMACCUI.releaseReservedActs.apply(this, arguments);
  276.     }; // BM.releaseReservedActs
  277.  
  278.     BM = UI.BattleManager;
  279.  
  280.     BM.addUnisonActors = function() { // Rewrite
  281.         var actor = this.actor(), act, item;
  282.         if (actor) { act = actor.inputtingAction(); }
  283.         if (act) { item = act.item(); }
  284.         if (!item || item.meta.unisonItemActors.length <= 1) { return; }
  285.         var actorIds = item.meta.unisonItemActors;
  286.         // Rewritten to store the action cost for each unison invokee as well
  287.         var actSlot = [actor.index(), actor.actionInputIndex];
  288.         var actCosts = item.meta.unisonItemActorActCosts.slice(0);
  289.         var actorId = actor.actorId(), actCost = GB.actCost.call(actor, item);
  290.         BM.unisonActors[actSlot] = [actorIds, actCosts];
  291.         for (var index = 0, length = actorIds.length; index < length; index++) {
  292.             actCosts[index] = actCosts[index] || actCost;
  293.             if (actorId === actorIds[index]) { actCosts[index] -= 1; }
  294.             if (!actCosts[index]) { actCosts.push(actCosts[index]); }
  295.             $gameActors.actor(actorIds[index]).actCostInputs += actCosts[index];
  296.         }
  297.         // Unison Item Config Act Cost
  298.         // Unison Item Default Invokee Act Slot Num
  299.     }; // BM.addUnisonActors
  300.  
  301.     // actor: The currently selected actor
  302.     BM.eraseUnisonActors = function(actor) { // Rewrite
  303.         var actors = BM.unisonActors[[actor.index(), actor.actionInputIndex]];
  304.         if (!actors) { return; }
  305.         BM.unisonActors[[actor.index(), actor.actionInputIndex]] = null;
  306.         // Rewritten to address the action cost for each unison invokee as well
  307.         var actorIds = actors[0], actCosts = actors[1];
  308.         for (var i = 0, length = actorIds.length; i < length; i++) {
  309.             $gameActors.actor(actorIds[i]).actCostInputs -= actCosts[i];
  310.         }
  311.         // Unison Item Config Act Cost
  312.         // Unison Item Default Invokee Act Slot Num
  313.     }; // BM.eraseUnisonActors
  314.  
  315.     BMACCUI.clearUnisonActors = BM.clearUnisonActors;
  316.     BM.clearUnisonActors = function() {
  317.         BMACCUI.clearUnisonActors.apply(this, arguments);
  318.         // Added to actCostInputs for reserving action slots from invokees too
  319.         $gameParty.movableMembers().forEach(function(mem) {
  320.             mem.actCostInputs = -999;
  321.         });
  322.         // Unison Item Config Act Cost
  323.         // Unison Item Default Invokee Act Slot Num
  324.     }; // BM.clearUnisonActors
  325.  
  326.     var GBB = AC.Game_BattlerBase;
  327.     ACCUI.Game_BattlerBase = {};
  328.     var GBBACCUI = ACCUI.Game_BattlerBase;
  329.     GBBACCUI.canReserveActs = GBB.canReserveActs;
  330.     GBB.canReserveActs = function(item) {
  331.         // Added to check for unison acion cost for the unison invoker as well
  332.         if (!item) { return false; }
  333.         if (this.isActor()) {
  334.             var emptyActs = this._actions.filter(function(act) {
  335.                 return !act.item();
  336.             }).length;
  337.             var actorId = this.actorId(), actorIds = item.meta.unisonItemActors;
  338.             var actCosts = item.meta.unisonItemActorActCosts;
  339.             if (actorIds.length > 1) {
  340.                 for (var i = 0, length = actorIds.length; i < length; i++) {
  341.                     if (actorId !== actorIds[i]) { continue; }
  342.                     if (!actCosts[i]) { break; }
  343.                     return actCosts[i] <= emptyActs - this._actCostInputs;
  344.                 }
  345.             }
  346.         }
  347.         // Unison Item Config Act Cost
  348.         return GBBACCUI.canReserveActs.apply(this, arguments);
  349.     }; // GBB.canReserveActs
  350.  
  351.     GBB = UI.Game_BattlerBase;
  352.  
  353.     GBBACCUI.canInput = Game_BattlerBase.prototype.canInput;
  354.     Game_BattlerBase.prototype.canInput = function() {
  355.         // Rewritten to check if at least 1 action slot isn't reserved
  356.         if (!GBBACCUI.canInput.apply(this, arguments)) { return false; }
  357.         if (!this.isActor() || !$gameParty.inBattle()) { return true; }
  358.         return this._actCostInputs < this._actions.length;
  359.         // Unison Item Default Invokee Act Slot Num
  360.     }; // Game_BattlerBase.prototype.canInput
  361.  
  362.     GBB.canUseUnisonSkill = function(skill) { // Rewrite
  363.         var actor, actorIds = skill.meta.unisonItemActors;
  364.         var inBattle = $gameParty.inBattle(), mems = $gameParty.aliveMembers();
  365.         // Added
  366.         var actCosts = skill.meta.unisonItemActorActCosts;
  367.         var actCost = GB.actCost.call(this, skill);
  368.         // Unison Item Default Invokee Act Slot Num
  369.         var learnFlags = skill.meta.unisonItemActorLearn;
  370.         for (var i = 0, length = actorIds.length; i < length; i++) {
  371.             if (this.actorId() === actorIds[i]) { continue; }
  372.             actor = mems.filter(function(m) {
  373.                 return m.index() > this.index() && m.actorId() === actorIds[i];
  374.             }, this)[0];
  375.             if (!actor || inBattle && !actor.canInput()) { return false; }
  376.             if (!actor.meetsSkillConditions(skill)) { return false; }
  377.             // Added to check if the unison invokee can pay the action cost
  378.             if (!inBattle) { continue; }
  379.             if (!GBB.hasEnoughActCost.call(actor, actCosts[i] || actCost)) {
  380.                 return false;
  381.             }
  382.             // Unison Item Default Invokee Act Slot Num
  383.             if (learnFlags[i] && actor.skills().every(function(s) {
  384.                 return s !== skill;
  385.             })) { return false; }
  386.         }
  387.         return true;
  388.     }; // GBB.canUseUnisonSkill
  389.  
  390.     GBB.canUseUnisonItem = function(item) { // Rewrite
  391.         if (!this.meetsItemConditions(item)) { return false; }
  392.         var actor, actorIds = item.meta.unisonItemActors;
  393.         var inBattle = $gameParty.inBattle(), mems = $gameParty.aliveMembers();
  394.         // Added
  395.         var actCosts = item.meta.unisonItemActorActCosts;
  396.         var actCost = GB.actCost.call(this, item);
  397.         // Unison Item Default Invokee Act Slot Num
  398.         for (var i = 0, length = actorIds.length; i < length; i++) {
  399.             if (this.actorId() === actorIds[i]) { continue; }
  400.             actor = mems.filter(function(m) {
  401.                 return m.index() > this.index() && m.actorId() === actorIds[i];
  402.             }, this)[0];
  403.             if (!actor || inBattle && !actor.canInput()) { return false; }
  404.             // Added to check if the unison invokee can pay the action cost
  405.             if (!inBattle) { continue; }
  406.             if (!GBB.hasEnoughActCost.call(actor, actCosts[i] || actCost)) {
  407.                 return false;
  408.             }
  409.             // Unison Item Default Invokee Act Slot Num
  410.         }
  411.         return true;
  412.     }; // GBB.canUseUnisonItem
  413.  
  414.     // actCost: The number of action slots needed for the action
  415.     GBB.hasEnoughActCost = function(actCost) { // New
  416.         // Checks if the unison invokee has enough empty action slots
  417.         return this._actions.length - this._actCostInputs >= actCost;
  418.         // Unison Item Default Invokee Act Slot Num
  419.     }; // GBB.hasEnoughActCost
  420.  
  421.     var GB = AC.Game_Battler;
  422.  
  423.     var WIL = AC.Window_ItemList;
  424.     ACCUI.Window_ItemList = {};
  425.     var WILACCUI = ACCUI.Window_ItemList;
  426.  
  427.     WILACCUI.drawActCost = WIL.drawActCost;
  428.     WIL.drawActCost = function(item, x, y, width) {
  429.         // Added to draw the act cost in battle for each unison actor
  430.         if ($gameParty.inBattle()) {
  431.             var actorIds = item.meta.unisonItemActors;
  432.             if (actorIds.length > 1) {
  433.                 var actCosts = item.meta.unisonItemActorActCosts;
  434.                 var actorId = BattleManager.actor().actorId();
  435.                 for (var i = 0, length = actorIds.length; i < length; i++) {
  436.                     if (!actCosts[i] || actorId !== actorIds[i]) { continue; }
  437.                     return this.drawText(actCosts[i], x, y, width, 'right');
  438.                 }
  439.             }
  440.         }
  441.         // Unison Item Config Act Cost
  442.         WILACCUI.drawActCost.apply(this, arguments);
  443.     }; // WIL.drawActCost
  444.  
  445.     var WSL = AC.Window_SkillList;
  446.     ACCUI.Window_SkillList = {};
  447.     var WSLACCUI = ACCUI.Window_SkillList;
  448.  
  449.     WSLACCUI.drawActCost = WSL.drawActCost;
  450.     WSL.drawActCost = function(skill, x, y, width) {
  451.         // Added to draw the act cost for each unison actor
  452.         this.changeTextColor(this.normalColor());
  453.         var actorIds = skill.meta.unisonItemActors;
  454.         if (actorIds.length > 1) {
  455.             var actCosts = skill.meta.unisonItemActorActCosts;
  456.             var actorId = this._actor.actorId();
  457.             for (var i = 0, length = actorIds.length; i < length; i++) {
  458.                 if (!actCosts[i] || actorId !== actorIds[i]) { continue; }
  459.                 return this.drawText(actCosts[i], x, y, width, 'right');
  460.             }
  461.         }
  462.         // Unison Item Config Act Cost
  463.         WSLACCUI.drawActCost.apply(this, arguments);
  464.     }; // WSL.drawActCost
  465.  
  466. })(DoubleX_RMMV.Act_Cost, DoubleX_RMMV.Unison_Item,
  467.    DoubleX_RMMV.Act_Cost_Compatibility["Unison Item Default"]);
  468.  
  469. } // if (DoubleX_RMMV["Unison Item Default"])
  470.  
  471. /*----------------------------------------------------------------------------*/
  472.  
  473. if (Imported['VE - Conditional Turn Battle']) { // v1.01a+
  474.  
  475. DoubleX_RMMV.Act_Cost_Compatibility["VE CTB"] = {};
  476.  
  477. (function(AC, ACCVECTB) {
  478.  
  479.     'use strict';
  480.  
  481.     ACCVECTB.BattleManager = {};
  482.     var BM = ACCVECTB.BattleManager;
  483.  
  484.     BM.setupAction = BattleManager.setupAction;
  485.     BattleManager.setupAction = function(battler) {
  486.         // Added to ensures battlers can use valid actions upon executing them
  487.         battler.actCostInputs = -999;
  488.         // VE CTB Act Validity
  489.         BM.setupAction.apply(this, arguments);
  490.     }; // BattleManager.setupAction
  491.  
  492. })(DoubleX_RMMV.Act_Cost, DoubleX_RMMV.Act_Cost_Compatibility["VE CTB"]);
  493.  
  494. } // if (Imported['VE - Conditional Turn Battle'])
  495.  
  496. /*----------------------------------------------------------------------------*/
  497.  
  498. } else {
  499.     alert('Place Action Cost Compatibility below Action Cost.');
  500. } // if (DoubleX_RMMV['Act Cost'])
  501.  
  502. /*============================================================================*/
RAW Paste Data