DoubleX RMMV Permanent States v102c

/*============================================================================
 *    ## Plugin Info
 *----------------------------------------------------------------------------
 *    # Plugin Name
 *      DoubleX RMMV Permanent States
 *----------------------------------------------------------------------------
 *    # Terms Of Use
 *      You shall keep this plugin's Plugin Info part's contents intact
 *      You shalln't claim that this plugin's written by anyone other than
 *      DoubleX or his aliases
 *      None of the above applies to DoubleX or his aliases
 *----------------------------------------------------------------------------
 *    # Prerequisites
 *      Abilities:
 *      1. Little Javascript coding proficiency to fully utilize this plugin
 *----------------------------------------------------------------------------
 *    # Links
 *      This plugin:
 *      1. http://pastebin.com/avCcChi6
 *      Mentioned Patreon Supporters:
 *      https://www.patreon.com/posts/71738797
 *----------------------------------------------------------------------------
 *    # Author
 *      DoubleX
 *----------------------------------------------------------------------------
 *    # Changelog
 *      v1.02c(GMT 0100 4-12-2015):
 *      1. Fixed undefined all array function which should be empty instead
 *      2. Increased this plugin's compactness, efficiency and robustness
 *      v1.02b(GMT 0800 2-12-2015):
 *      1. Fixed reading repetitive notetag values due to typo bug
 *      2. Fixed permanent state type persist not working due to typo bug
 *      3. Fixed null permanent state container due to wrong init timing bug
 *      4. Fixed undefined $gameParty upon actor initializations bug
 *      v1.02a(GMT 1400 1-12-2015):
 *      1. <permanent state: type> has changed to
 *         <permanent state: scene, type>
 *      2. Added new permanent state type recover restored upon recover all
 *      3. The same state can now have more than 1 permanent state type
 *      4. Removed param allStatesPermanent in the plugin manager
 *      5. Fixed undefined permanent state containers upon loading savefiles
 *      v1.01h(GMT 0600 29-11-2015):
 *      1. Fixed clearing all states upon calling Recover All event command
 *      2. Fixed notetags not reading at all due to treating "null" as falsey
 *      v1.01g(GMT 0300 29-11-2015):
 *      1. Fixed undefined error due to non persist nor revive poermanent type
 *      v1.01f(GMT 1200 27-11-2015):
 *      1. Fixed undefined state_id in store_permanent_states due to typo bug
 *      2. Increased this plugin's efficiency, readability and robustness
 *      v1.01e(GMT 0900 25-11-2015):
 *      1. Fixed wrong number of arguments when loading state notetags bug
 *      2. The aliased functions can be accessed by other custom plugins now
 *      3. Exposed the state plugin calls that can access the notetag values
 *      v1.01d(GMT 1600 6-11-2015):
 *      1. Simplified the notetag reading mechanisms
 *      2. Fixed undefined this under forEach bug
 *      v1.01c(GMT 1300 5-11-2015):
 *      1. Fixed undefined this under DoubleX_RMMV.Permanent_States bug
 *      v1.01b(GMT 0000 5-11-2015):
 *      1. Fixed failing to load notetags due to nil $dataStates bug
 *      v1.01a(GMT 1300 4-11-2015):
 *      1. The notetag <permanent state> has changed to <permanent state: type>
 *      2. Fixed several logic and syntax errors
 *      3. Increased this plugin's maintainability
 *      v1.00a(GMT 0800 31-10-2015):
 *      1. 1st version of this plugin finished
 *============================================================================*/
/*:
 * @plugindesc Lets you sets some states to be kept/restored in some set cases
 * @author DoubleX
 *
 * @help
 *============================================================================
 *    ## Notetag Info
 *----------------------------------------------------------------------------
 *    # State Notetags:
 *      1. <permanent state: scene, type>
 *         - scene can be either battle or map, meaning the state can be
 *           restored in battle or map respectively
 *         - type can be either persist, recover or revive, meaning the state
 *           will be kept upon death or recover all, or added back upon revive
 *           respectively
 *         - The same state can have more than 1 permanent state scene/type
 *============================================================================
 *    ## Plugin Call Info
 *----------------------------------------------------------------------------
 *    # State manipulations
 *      1. meta.permanentStates
 *         - Returns the permanent state scenes and types in
 *           <permanent state: scene, type> in the form of
 *           { battle: types, map: types } with types being an Array storing
 *           all unique String type or an empty Array if scene matches and
 *           doesn't match the property name storing types respectively
 *      2. meta.permanentStates = { battle: types, map: types }
 *         - Sets the permanent state scene and types in
 *           <permanent state: type> as { battle: types, map: types } with
 *           types being an Array storing all unique String type which will be
 *           used in the scene matching the property name storing types
 *         - types can only include persist, recover and revive
 *         - All meta.permanentStates changes can be saved if
 *           DoubleX RMMV Dynamic Data is used
 *============================================================================
 */

"use strict";
var DoubleX_RMMV = DoubleX_RMMV || {};
DoubleX_RMMV["Permanent States"] = "v1.02c";

/*============================================================================
 *    ## Plugin Implementations
 *       You need not edit this part as it's about how this plugin works
 *----------------------------------------------------------------------------
 *    # Plugin Support Info:
 *      1. Prerequisites
 *         - Some Javascript coding 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
 * function_name = function(arguments) { // Version X+; Hotspot
 *     // Added/Removed/Rewritten to do something/How this function works
 *     function_name_code
 *     //
 * } // function_name
 *----------------------------------------------------------------------------*/

DoubleX_RMMV.Permanent_States = {

    scene: function() { // v1.02a+
        // Returns map upon actor initializations as well
        return $gameParty && $gameParty.inBattle() ? "battle" : "map";
        //
    },

    // (v1.02a+)Stores all permanent state scenes
    scenes: ["battle", "map"],

    // (v1.02a+)Stores all permanent state types
    types: ["persist", "recover", "revive"]

}; // DoubleX_RMMV.Permanent_States

(function(PS) {

    PS.DataManager = {};

    PS.DataManager.isDatabaseLoaded = DataManager.isDatabaseLoaded;
    DataManager.isDatabaseLoaded = function() {
        // Rewritten
        if (!PS.DataManager.isDatabaseLoaded.apply(this, arguments)) {
            return false;
        }
        PS.DataManager.loadAllPermanentStateNotes();
        return true;
        //
    }; // DataManager.isDatabaseLoaded

    PS.DataManager.loadAllPermanentStateNotes = function() {
        $dataStates.forEach(function(data) {
            if (data) { PS.DataManager.loadPermanentStateNotes(data); }
        });
    }; // loadAllPermanentStateNotes

    // data: The data to have its notetags read
    PS.DataManager.loadPermanentStateNotes = function(data) {
        var ps, scene, type, lines = data.note.split(/[\r\n]+/);
        var regex = /< *permanent +state *: *(\w+) *, *(\w+) *>/i;
        var scenes = PS.scenes, types = PS.types;
        data.meta.permanentStates = {};
        ps = data.meta.permanentStates;
        scenes.forEach(function(s) { ps[s] = []; });
        // Reads all valid unique combinations until all of them are read
        for (var index = 0, length = lines.length; index < length; index++) {
            if (!lines[index].match(regex)) { continue; }
            scene = RegExp.$1;
            if (scenes.indexOf(scene) < 0) { continue; }
            type = RegExp.$2;
            if (types.indexOf(type) < 0 || ps[scene].indexOf(type) >= 0) {
                continue;
            }
            ps[scene].push(type);
            if (scenes.every(function(s) {
                return ps[s].length >= types.length;
            })) { return; }
        }
        //
    }; // loadPermanentStateNotes

    PS.Game_BattlerBase = {};

    /*------------------------------------------------------------------------
     *    New private instance variables
     *------------------------------------------------------------------------*/
    /* _permanentStates: The id of all permanent states of all scene/type
     * _permanentStateTurns: The turns of all permanent states of all scene/type
     */

    PS.Game_BattlerBase.initMembers = Game_BattlerBase.prototype.initMembers;
    Game_BattlerBase.prototype.initMembers = function() { // v1.01h+
        PS.Game_BattlerBase.initPermanentStates.call(this); // Added
        PS.Game_BattlerBase.initMembers.apply(this, arguments);
    }; // Game_BattlerBase.prototype.initMembers

    PS.Game_BattlerBase.clearStates = Game_BattlerBase.prototype.clearStates;
    Game_BattlerBase.prototype.clearStates = function() {
        PS.Game_BattlerBase.storePermanentStates.call(this); // Added
        PS.Game_BattlerBase.clearStates.apply(this, arguments);
    }; // Game_BattlerBase.prototype.clearStates

    PS.Game_BattlerBase.die = Game_BattlerBase.prototype.die;
    Game_BattlerBase.prototype.die = function() { // v1.01a+
        PS.Game_BattlerBase.die.apply(this, arguments);
        // Added
        PS.Game_BattlerBase.restorePermanentStates.call(this, "persist");
        //
    }; // Game_BattlerBase.prototype.die

    PS.Game_BattlerBase.revive = Game_BattlerBase.prototype.revive;
    Game_BattlerBase.prototype.revive = function() {
        PS.Game_BattlerBase.revive.apply(this, arguments);
        // Added
        PS.Game_BattlerBase.restorePermanentStates.call(this, "revive");
        //
    }; // Game_BattlerBase.prototype.revive

    PS.Game_BattlerBase.recoverAll = Game_BattlerBase.prototype.recoverAll;
    Game_BattlerBase.prototype.recoverAll = function() { // v1.02a+
        PS.Game_BattlerBase.recoverAll.apply(this, arguments);
        // Added
        PS.Game_BattlerBase.restorePermanentStates.call(this, "recover");
        //
    }; // Game_BattlerBase.prototype.recoverAll

    PS.Game_BattlerBase.initPermanentStates = function() { // v1.01h+
        var types = PS.types;
        this._permanentStates = {};
        this._permanentStateTurns = {};
        PS.scenes.forEach(function(scene) {
            this._permanentStates[scene] = {};
            this._permanentStateTurns[scene] = {};
            types.forEach(function(type) {
                this._permanentStates[scene][type] = [];
                this._permanentStateTurns[scene][type] = {};
            }, this);
        }, this);
    }; // initPermanentStates

    PS.Game_BattlerBase.storePermanentStates = function() {
        var sc;
        if (!this._states || !this._stateTurns) { return; }
        sc = PS.scene();
        this.states().forEach(function(s) {
            s.meta.permanentStates[sc].forEach(function(t) {
                this._permanentStates[sc][t].push(s.id);
                this._permanentStateTurns[sc][t][s.id] = this._stateTurns[s.id];
            }, this);
        }, this);
    }; // storePermanentStates

    // type: The permanent state type
    PS.Game_BattlerBase.restorePermanentStates = function(type) {
        var sc;
        if (!this._states || !this._stateTurns) { return; }
        sc = PS.scene();
        this._states = this._states.concat(this._permanentStates[sc][type]);
        this._permanentStates[sc][type].length = 0;
        Object.keys(this._permanentStateTurns[sc][type]).forEach(function(id) {
            id = +id;
            this._stateTurns[id] = this._permanentStateTurns[sc][type][id];
        }, this);
        this._permanentStateTurns[sc][type] = {};
    }; // restorePermanentStates

})(DoubleX_RMMV.Permanent_States);

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