[MV Plugin] DoubleX RMMV Action Cost Compatibility

Code:
/*============================================================================



 *    ## Plugin Info                                                          

 *----------------------------------------------------------------------------

 *    # Plugin Name                                                           

 *      DoubleX RMMV Action Cost Compatibility                                

 *----------------------------------------------------------------------------

 *    # Terms Of Use                                                          

 *      1. Commercial use's always allowed and crediting me's always optional.

 *      2. You shall keep this plugin's Plugin Info part's contents intact.   

 *      3. You shalln't claim that this plugin's written by anyone other than 

 *         DoubleX or my aliases. I always reserve the right to deny you from 

 *         using any of my plugins anymore if you've violated this.           

 *      4. CC BY 4.0, except those conflicting with any of the above, applies 

 *         to this plugin, unless you've my permissions not needing follow so.

 *      5. I always reserve the right to deny you from using this plugin      

 *         anymore if you've violated any of the above.                       

 *----------------------------------------------------------------------------

 *    # Prerequisites                                                         

 *      Plugins:                                                              

 *      1. DoubleX RMMV Action Cost                                           

 *      Abilities:                                                            

 *      1. Nothing special                                                    

 *----------------------------------------------------------------------------

 *    # Links                                                                 

 *      This plugin:                                                          

 *      1. http://pastebin.com/5DP26uff                                       

 *      Video:                                                                

 *      1. https://www.youtube.com/watch?v=TyYqBKaB-Cw                        

 *      Mentioned Patreon Supporters:

 *      https://www.patreon.com/posts/71738797

 *----------------------------------------------------------------------------

 *    # Author                                                                

 *      DoubleX                                                               

 *----------------------------------------------------------------------------

 *    # Changelog                                                             

 *      v1.00d(GMT 1500 11-8-2016):                                           

 *      1. Removed compatibility with DoubleX RMMV Minimalized ATB            

 *      1. In sync with the latest DoubleX RMMV Popularized ATB Core version  

 *      v1.00c(GMT 1000 5-6-2016):                                            

 *      1. Addressed more compatibility issues with                           

 *         - DoubleX RMMV Minimalized ATB                                     

 *         - DoubleX RMMV Popularized ATB Core                                

 *      v1.00b(GMT 0300 29-5-2016):                                           

 *      1. Addressed compatibility with                                       

 *         - DoubleX RMMV Minimalized ATB                                     

 *         - DoubleX RMMV Popularized ATB Core                                

 *      v1.00a(GMT 1500 22-5-2016):                                           

 *      1. 1st version of this plugin finished                                

 *============================================================================*/

/*:

 * @plugindesc Fixes DoubleX RMMV Action Cost compatibility issues

 * @author DoubleX

 *

 * @help

 *============================================================================

 *    ## Addressed Plugins                                                    

 *----------------------------------------------------------------------------

 *    # DoubleX RMMV Unison Item Config:                                      

 *      1. The action cost is the same for all unison actors                  

 *         - Reference tag: Unison Item Config Act Cost                       

 *         - Read <unison item actor act cost: costs> in DM.loadItemNotes     

 *         - Drawed the action cost in battle for each unison actor in        

 *           WIL.drawActCost and WSL.drawActCost                              

 *         - The default unison item action cost will be shown for all unison 

 *           actors when outside battles                                      

 *    # DoubleX RMMV Unison Item Default:                                     

 *      1. The number of action slot reserved by unison invokees are always 1 

 *         - Reference tag: Unison Item Default Invokee Act Slot Num          

 *         - Checked the action cost for each unison invokee in               

 *           GBB.canUseUnisonSkill and GBB.canUseUnisonItem as well           

 *         - Stored and restored the action cost for each unison invokee in   

 *           BM.addUnisonActors and BM.eraseUnisonActors as well              

 *    # (v1.00b+)DoubleX RMMV Popularized ATB Core:                           

 *      1. No battler can execute any action at all                           

 *         - Reference tag: PATB Act Validity                                 

 *         - Extended BattleManager.processTurn to ensure no valid actions    

 *           will be falsely regarded as invalid ones                         

 *    # (v1.00c+)DoubleX RMMV Popularized ATB Core:                           

 *      1. Battlers inputting skills/items with action cost greater than 1    

 *         remains inputable after finishing inputting all skills/items       

 *         - Reference tag: PATB Inputability                                 

 *         - Extended Game_Action.prototype.confirm_patb_item,                

 *           Scene_Battle.prototype.confirm_patb_act and added GBB.confirmAct 

 *           to confirm the reserved action slots as well                     

 *============================================================================

 *    ## Notetag Info                                                         

 *----------------------------------------------------------------------------

 *    # Skill/Item Notetags:                                                  

 *      1. <unison item actor act cost: costs>                                

 *         - Sets the list of action costs needed for each of the             

 *           corresponding id of the unison actor in <unison item actors: ids>

 *           , is used to separate the mp costs in ids                        

 *           E.g.:                                                            

 *           If <unison item actors: 1> is used, then                         

 *           <unison item actor act cost: 2> means actor with id 1 needs to   

 *           use 2 action slots for using the unison skill/item               

 *           If <unison item actors: 4, 2> is used, then                      

 *           <unison item actor act cost: 2, 3> means actor with id 4 and 2   

 *           need to use 2 and 3 action slots respectively for using the      

 *           unison skill/item                                                

 *           If <unison item actors: 4, 2> is used, then                      

 *           <unison item actor act cost: 2> means actor with id 4 needs to   

 *           pay 2 action slots while that with id 2 needs to use the number  

 *           of action slots of the unison skill/item for using it            

 *============================================================================

 *    ## Plugin Call Info                                                     

 *----------------------------------------------------------------------------

 *    # Skill/Item manipulations                                              

 *      1. meta.unisonItemActorActCosts                                       

 *         - Returns the Array of action costs each needed by its             

 *           corresponding actor with id in meta.unisonItemActors to use this 

 *           skill/item                                                       

 *      2. meta.unisonItemActorActCosts = [cost, cost, ...]                   

 *         - Sets the Array of of action costs each needed by its             

 *           corresponding actor with id in meta.unisonItemActors to use this 

 *           skill/item                                                       

 *         - All meta.unisonItemActorActCosts changes can be saved if         

 *           DoubleX RMMV Dynamic Data is used                                

 *============================================================================

 */



var DoubleX_RMMV = DoubleX_RMMV || {};

DoubleX_RMMV['Act Cost Compatibility'] = 'v1.00d';



/*============================================================================

 *    ## Plugin Implementations                                               

 *       You need not edit this part as it's about how this plugin works      

 *----------------------------------------------------------------------------

 *    # Plugin Support Info:                                                  

 *      1. Prerequisites                                                      

 *         - Solid understanding of how DoubleX RMMV Action Cost and each     

 *           addressed plugin works                                           

 *         - Decent plugin development proficiency to fully comprehend this   

 *           plugin                                                           

 *      2. Function documentation                                             

 *         - The 1st part describes why this function's rewritten/extended for

 *           rewritten/extended functions or what the function does for new   

 *           functions                                                        

 *         - The 2nd part describes what the arguments of the function are    

 *         - The 3rd part informs which version rewritten, extended or created

 *           this function                                                    

 *         - The 4th part informs whether the function's rewritten or new     

 *         - The 5th part informs whether the function's a real or potential  

 *           hotspot                                                          

 *         - The 6th part describes how this function works for new functions 

 *           only, and describes the parts added, removed or rewritten for    

 *           rewritten or extended functions only                             

 *         Example:                                                           

 * /*----------------------------------------------------------------------

 *  *    Why rewrite/extended/What this function does                      

 *  *----------------------------------------------------------------------*/ 

/* // arguments: What these arguments are                                     

 * functionName = function(arguments) { // Version X+; Hotspot                

 *     // Added/Removed/Rewritten to do something/How this function works     

 *     functionContents                                                       

 *     //                                                                     

 * } // functionName                                                          

 *----------------------------------------------------------------------------*/



if (DoubleX_RMMV['Act Cost']) {



DoubleX_RMMV.Act_Cost_Compatibility = {};



/*----------------------------------------------------------------------------*/



if (DoubleX_RMMV["PATB Core"]) { // v1.00b+



DoubleX_RMMV.Act_Cost_Compatibility["PATB Core"] = {};



(function(AC, ACCATB) {



    'use strict';



    ACCATB.BattleManager = {};

    var BM = ACCATB.BattleManager;



    BM.processTurn = BattleManager.processTurn;

    BattleManager.processTurn = function() {

        // Added to ensures battlers can use valid actions upon executing them

        this._subject.actCostInputs = -999;

        // PATB Act Validity

        BM.processTurn.apply(this, arguments);

    }; // BattleManager.processTurn



    ACCATB.Game_BattlerBase = {};

    var GBB = ACCATB.Game_BattlerBase;



    // act: The action to have all its reserved action slots confirmed

    GBB.confirmAct = function(act) { // v1.00c+; New

        // Ensures all reserved action slots are confirmed as well

        var reservedActs = act.item().meta.actCost - 1;

        var lastAct = this._actions.length - this._actCostInputs - 1;

        for (var index = lastAct; index > lastAct - reservedActs; index--) {

            this._actions[index].patb_confirm = true;

        }

        // PATB Inputability

    }; // GBB.confirmAct



    ACCATB.Game_Actor = {};

    var GA = ACCATB.Game_Actor;



    GA.confirm_patb_act = Game_Actor.prototype.confirm_patb_act;

    Game_Actor.prototype.confirm_patb_act = function() {

    // v1.00c+

        GA.confirm_patb_act.apply(this, arguments);

        // Added to ensure all reserved action slots are confirmed as well

        GBB.confirmAct.call(this, this.inputtingAction());

        // PATB Inputability

    }; // Game_Actor.prototype.confirm_patb_act



})(DoubleX_RMMV.Act_Cost, DoubleX_RMMV.Act_Cost_Compatibility["PATB Core"]);



} // if DoubleX_RMMV["PATB Core"])



/*----------------------------------------------------------------------------*/



if (DoubleX_RMMV["Unison Item Default"]) {



DoubleX_RMMV.Act_Cost_Compatibility["Unison Item Default"] = {};



(function(AC, UI, ACCUI) {



    'use strict';



    var DM = UI.DataManager;

    ACCUI.DataManager = {};

    var DMACCUI = ACCUI.DataManager;



    // data: The data to have its notetags read

    DMACCUI.loadItemNotes = DM.loadItemNotes;

    DM.loadItemNotes = function(data) {

        DMACCUI.loadItemNotes(data);

        // Added to read and store values of <unison item actor act cost: costs>

        var uIAACs = data.meta.unisonItemActorActCosts = [];

        var ACs = /< *unison +item +actor +act +cost *: *(\d+(?: *, *\d+)*) *>/i;

        data.note.split(/[\r\n]+/).forEach(function(line) {

            if (line.match(ACs)) { DM.storeItemNotes(uIAACs); }

        });

        // Unison Item Config Act Cost

    }; // DM.loadItemNotes



    var BM = AC.BattleManager;

    ACCUI.BattleManager = {};

    var BMACCUI = ACCUI.BattleManager;



    BMACCUI.reserveActs = BM.reserveActs;

    BM.reserveActs = function() {

        // Rewritten to not using this function for unison skills/items

        var actor = this.actor();

        if (!actor) { return; }

        if (actor.inputtingAction().item().meta.unisonItemActors.length <= 1) {

            BMACCUI.reserveActs.apply(this, arguments);

        }

        // Unison Item Config Act Cost

    }; // BM.reserveActs



    BMACCUI.releaseReservedActs = BM.releaseReservedActs;

    BM.releaseReservedActs = function() {

        // Added to not using this function for unison skills/items

        var actor = this.actor();

        if (!actor) { return; }

        var act = actor.inputtingAction();

        if (act.item().meta.unisonItemActors.length > 1) { return act.clear(); }

        // Unison Item Config Act Cost

        BMACCUI.releaseReservedActs.apply(this, arguments);

    }; // BM.releaseReservedActs



    BM = UI.BattleManager;



    BM.addUnisonActors = function() { // Rewrite

        var actor = this.actor(), act, item;

        if (actor) { act = actor.inputtingAction(); }

        if (act) { item = act.item(); }

        if (!item || item.meta.unisonItemActors.length <= 1) { return; }

        var actorIds = item.meta.unisonItemActors;

        // Rewritten to store the action cost for each unison invokee as well

        var actSlot = [actor.index(), actor.actionInputIndex];

        var actCosts = item.meta.unisonItemActorActCosts.slice(0);

        var actorId = actor.actorId(), actCost = item.meta.actCost;

        BM.unisonActors[actSlot] = [actorIds, actCosts];

        for (var index = 0, length = actorIds.length; index < length; index++) {

            actCosts[index] = actCosts[index] || actCost;

            if (actorId === actorIds[index]) { actCosts[index] -= 1; }

            if (!actCosts[index]) { actCosts.push(actCosts[index]); }

            $gameActors.actor(actorIds[index]).actCostInputs += actCosts[index];

        }

        // Unison Item Config Act Cost

        // Unison Item Default Invokee Act Slot Num

    }; // BM.addUnisonActors



    // actor: The currently selected actor

    BM.eraseUnisonActors = function(actor) { // Rewrite

        var actors = BM.unisonActors[[actor.index(), actor.actionInputIndex]];

        if (!actors) { return; }

        BM.unisonActors[[actor.index(), actor.actionInputIndex]] = null;

        // Rewritten to address the action cost for each unison invokee as well

        var actorIds = actors[0], actCosts = actors[1];

        for (var i = 0, length = actorIds.length; i < length; i++) {

            $gameActors.actor(actorIds[i]).actCostInputs -= actCosts[i];

        }

        // Unison Item Config Act Cost

        // Unison Item Default Invokee Act Slot Num

    }; // BM.eraseUnisonActors



    BMACCUI.clearUnisonActors = BM.clearUnisonActors;

    BM.clearUnisonActors = function() {

        BMACCUI.clearUnisonActors.apply(this, arguments);

        // Added to actCostInputs for reserving action slots from invokees too

        $gameParty.movableMembers().forEach(function(mem) {

            mem.actCostInputs = -999;

        });

        // Unison Item Config Act Cost

        // Unison Item Default Invokee Act Slot Num

    }; // BM.clearUnisonActors



    var GBB = AC.Game_BattlerBase;

    ACCUI.Game_BattlerBase = {};

    var GBBACCUI = ACCUI.Game_BattlerBase;

    GBBACCUI.canReserveActs = GBB.canReserveActs;

    GBB.canReserveActs = function(item) {

        // Added to check for unison acion cost for the unison invoker as well

        if (!item) { return false; }

        if (this.isActor()) {

            var emptyActs = this._actions.filter(function(act) {

                return !act.item();

            }).length;

            var actorId = this.actorId(), actorIds = item.meta.unisonItemActors;

            var actCosts = item.meta.unisonItemActorActCosts;

            if (actorIds.length > 1) {

                for (var i = 0, length = actorIds.length; i < length; i++) {

                    if (actorId !== actorIds[i]) { continue; }

                    if (!actCosts[i]) { break; }

                    return actCosts[i] <= emptyActs - this._actCostInputs;

                }

            }

        }

        // Unison Item Config Act Cost

        return GBBACCUI.canReserveActs.apply(this, arguments);

    }; // GBB.canReserveActs



    GBB = UI.Game_BattlerBase;



    GBBACCUI.canInput = Game_BattlerBase.prototype.canInput;

    Game_BattlerBase.prototype.canInput = function() {

        // Rewritten to check if at least 1 action slot isn't reserved

        if (!GBBACCUI.canInput.apply(this, arguments)) { return false; }

        if (!this.isActor() || !$gameParty.inBattle()) { return true; }

        return this._actCostInputs < this._actions.length;

        // Unison Item Default Invokee Act Slot Num

    }; // Game_BattlerBase.prototype.canInput



    GBB.canUseUnisonSkill = function(skill) { // Rewrite

        var actor, actorIds = skill.meta.unisonItemActors;

        var inBattle = $gameParty.inBattle(), mems = $gameParty.aliveMembers();

        // Added

        var actCosts = skill.meta.unisonItemActorActCosts;

        var actCost = skill.meta.actCost;

        // Unison Item Default Invokee Act Slot Num

        var learnFlags = skill.meta.unisonItemActorLearn;

        for (var i = 0, length = actorIds.length; i < length; i++) {

            if (this.actorId() === actorIds[i]) { continue; }

            actor = mems.filter(function(m) {

                return m.index() > this.index() && m.actorId() === actorIds[i];

            }, this)[0];

            if (!actor || inBattle && !actor.canInput()) { return false; }

            if (!actor.meetsSkillConditions(skill)) { return false; }

            // Added to check if the unison invokee can pay the action cost

            if (!inBattle) { continue; }

            if (!GBB.hasEnoughActCost.call(actor, actCosts[i] || actCost)) {

                return false;

            }

            // Unison Item Default Invokee Act Slot Num

            if (learnFlags[i] && actor.skills().every(function(s) {

                return s !== skill;

            })) { return false; }

        }

        return true;

    }; // GBB.canUseUnisonSkill



    GBB.canUseUnisonItem = function(item) { // Rewrite

        if (!this.meetsItemConditions(item)) { return false; }

        var actor, actorIds = item.meta.unisonItemActors;

        var inBattle = $gameParty.inBattle(), mems = $gameParty.aliveMembers();

        // Added

        var actCosts = item.meta.unisonItemActorActCosts;

        var actCost = item.meta.actCost;

        // Unison Item Default Invokee Act Slot Num

        for (var i = 0, length = actorIds.length; i < length; i++) {

            if (this.actorId() === actorIds[i]) { continue; }

            actor = mems.filter(function(m) {

                return m.index() > this.index() && m.actorId() === actorIds[i];

            }, this)[0];

            if (!actor || inBattle && !actor.canInput()) { return false; }

            // Added to check if the unison invokee can pay the action cost

            if (!inBattle) { continue; }

            if (!GBB.hasEnoughActCost.call(actor, actCosts[i] || actCost)) {

                return false;

            }

            // Unison Item Default Invokee Act Slot Num

        }

        return true;

    }; // GBB.canUseUnisonItem



    // actCost: The number of action slots needed for the action

    GBB.hasEnoughActCost = function(actCost) { // New

        // Checks if the unison invokee has enough empty action slots

        return this._actions.length - this._actCostInputs >= actCost;

        // Unison Item Default Invokee Act Slot Num

    }; // GBB.hasEnoughActCost



    var WIL = AC.Window_ItemList;

    ACCUI.Window_ItemList = {};

    var WILACCUI = ACCUI.Window_ItemList;



    WILACCUI.drawActCost = WIL.drawActCost;

    WIL.drawActCost = function(item, x, y, width) {

        // Added to draw the act cost in battle for each unison actor

        if ($gameParty.inBattle()) {

            var actorIds = item.meta.unisonItemActors;

            if (actorIds.length > 1) {

                var actCosts = item.meta.unisonItemActorActCosts;

                var actorId = BattleManager.actor().actorId();

                for (var i = 0, length = actorIds.length; i < length; i++) {

                    if (!actCosts[i] || actorId !== actorIds[i]) { continue; }

                    return this.drawText(actCosts[i], x, y, width, 'right');

                }

            }

        }

        // Unison Item Config Act Cost

        WILACCUI.drawActCost.apply(this, arguments);

    }; // WIL.drawActCost



    var WSL = AC.Window_SkillList;

    ACCUI.Window_SkillList = {};

    var WSLACCUI = ACCUI.Window_SkillList;



    WSLACCUI.drawActCost = WSL.drawActCost;

    WSL.drawActCost = function(skill, x, y, width) {

        // Added to draw the act cost for each unison actor

        this.changeTextColor(this.normalColor());

        var actorIds = skill.meta.unisonItemActors;

        if (actorIds.length > 1) {

            var actCosts = skill.meta.unisonItemActorActCosts;

            var actorId = this._actor.actorId();

            for (var i = 0, length = actorIds.length; i < length; i++) {

                if (!actCosts[i] || actorId !== actorIds[i]) { continue; }

                return this.drawText(actCosts[i], x, y, width, 'right');

            }

        }

        // Unison Item Config Act Cost

        WSLACCUI.drawActCost.apply(this, arguments);

    }; // WSL.drawActCost



})(DoubleX_RMMV.Act_Cost, DoubleX_RMMV.Unison_Item, 

   DoubleX_RMMV.Act_Cost_Compatibility["Unison Item Default"]);



} // if (DoubleX_RMMV["Unison Item Default"])



/*----------------------------------------------------------------------------*/



} else {

    alert('Place Action Cost Compatibility below Action Cost.');

} // if (DoubleX_RMMV['Act Cost'])



/*============================================================================*/