SHARE
TWEET

DoubleX RMMV Popularized ATB Compatibility v103b

Double_X Apr 12th, 2016 (edited) 536 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 Popularized ATB Compatibility                            
  6.  *----------------------------------------------------------------------------
  7.  *    # Terms Of Use                                                          
  8.  *      You shall keep this plugin's Plugin Info part's contents intact      
  9.  *      You shalln't claim that this plugin's written by anyone other than    
  10.  *      DoubleX or his aliases                                                
  11.  *      None of the above applies to DoubleX or his aliases                  
  12.  *----------------------------------------------------------------------------
  13.  *    # Prerequisites                                                        
  14.  *      Plugins:                                                              
  15.  *      1. DoubleX RMMV Popularized ATB Core                                  
  16.  *      Abilities:                                                            
  17.  *      1. Nothing special                                                    
  18.  *----------------------------------------------------------------------------
  19.  *    # Links                                                                
  20.  *      This plugin:                                                          
  21.  *      1. http://pastebin.com/SXpV9Zwt                                      
  22.  *      Video:                                                                
  23.  *      1. https://www.youtube.com/watch?v=aoBI3DaE3g8                        
  24.  *----------------------------------------------------------------------------
  25.  *    # Instructions                                                          
  26.  *      1. Place this plugin below all DoubleX RMMV Popularized ATB addons    
  27.  *----------------------------------------------------------------------------
  28.  *    # Author                                                                
  29.  *      DoubleX                                                              
  30.  *----------------------------------------------------------------------------
  31.  *    # Changelog                                                            
  32.  *      v1.03b(GMT 0200 7-9-2017):                                            
  33.  *      1. Fixed returning the sprite of the currently inputable actor to its
  34.  *         home position when an action performs its finish sequence          
  35.  *         compatiblity issue                                                
  36.  *      v1.03a(GMT 0400 27-8-2017):                                          
  37.  *      1. Supports Action Sequences in                                      
  38.  *         Yanfly Engine Plugins - Battle Engine Core                        
  39.  *      2. Fixed more changing currently inputable actor with                
  40.  *         Yanfly Engine Plugins - Target Extension - Selection Control      
  41.  *         compatibility issues                                              
  42.  *      v1.02b(GMT 1400 26-8-2017):                                          
  43.  *      1. Fixed showing status window with MOG_BattleHud compatility issue  
  44.  *      2. Fixed changing currently inputable actor with                      
  45.  *         Yanfly Engine Plugins - Target Extension - Selection Control      
  46.  *         compatibility issue                                                
  47.  *      v1.02a(GMT 1400 13-8-2017):                                          
  48.  *      1. Compatible with                                                    
  49.  *         Yanfly Engine Plugins - Target Extension - Selection Control      
  50.  *      v1.01b(GMT 0400 11-8-2017):                                          
  51.  *      1. Fixed the wrong actor window position bug when using skills/items  
  52.  *         on party members                                                  
  53.  *      v1.01a(GMT 0500 10-8-2017):                                          
  54.  *      1. Compatible with MOG_BattleHud                                      
  55.  *      v1.00e(GMT 1200 5-8-2017):                                            
  56.  *      1. Fixed the next action incorrectly highlighting all members in the  
  57.  *         same party/troop after using an party/troop targeting skill/item  
  58.  *      v1.00d(GMT 1500 11-8-2016):                                          
  59.  *      1. In sync with the latest DoubleX RMMV Popularized ATB Core version  
  60.  *      v1.00c(GMT 1400 9-8-2016):                                          
  61.  *      1. Fixed skills/items not needing selections not working when        
  62.  *         Select Help Window in Yanfly Engine Plugins - Battle Engine Core is
  63.  *         set as false                                                      
  64.  *      v1.00b(GMT 0400 16-7-2016):                                          
  65.  *      1. PATB Hotkey supports selecting inputable actors via touch input    
  66.  *         when Yanfly Engine Plugins - Battle Engine Core is used with      
  67.  *         Visual Actor Select being set as true as well                      
  68.  *         Mouse Over applies to PATB Hotkey as well                          
  69.  *      v1.00a(GMT 1600 12-4-2016):                                          
  70.  *      1. 1st version of this plugin finished                                
  71.  *============================================================================*/
  72. /*:
  73.  * @plugindesc Fixes DoubleX RMMV Popularized ATB compatibility issues
  74.  * @author DoubleX
  75.  *
  76.  * @help
  77.  *============================================================================
  78.  *    ## (v1.03a+)Action Sequences(Yanfly Engine Plugins - Battle Engine Core)
  79.  *       Reference tag: YEP_BattleEngineCore_ActionSequences                  
  80.  *----------------------------------------------------------------------------
  81.  *    # DoubleX RMMV Popularized ATB Core                                    
  82.  *      1. atb val: Target Typing, Operator Value                            
  83.  *         - Use Operator to assign Value to the atb value of targets included
  84.  *           by Target Typing, which can be any Target Typing supported by    
  85.  *           Action Sequences that targets battlers not cooling down          
  86.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  87.  *           by, subtract by, multiply by, divide by or modulo by respectively
  88.  *      2. atb val %: Target Typing, Operator Value                          
  89.  *         - Use Operator to assign Value% of the maximum atb value to the atb
  90.  *           value of targets included by Target Typing, which can be any    
  91.  *           Target Typing supported by Action Sequences that targets battlers
  92.  *           not cooling down                                                
  93.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  94.  *           by, subtract by, multiply by, divide by or modulo by respectively
  95.  *      3. reset atb val: Target Typing                                      
  96.  *         - Resets the atb value of targets included by Target Typing, which
  97.  *           can be any Target Typing supported by Action Sequences, to the  
  98.  *           maximum atb value in delay fill mode and 0 if otherwise          
  99.  *      4. reset atb: Target Typing                                          
  100.  *         - Clears all actions of targets included by Target Typing, which  
  101.  *           can be any Target Typing supported by Action Sequences          
  102.  *    # DoubleX RMMV Popularized ATB Charge                                  
  103.  *      1. charge val: Target Typing, Operator Value                          
  104.  *         - Use Operator to assign Value to the charge value of targets      
  105.  *           included by Target Typing, which can be any Target Typing        
  106.  *           supported by Action Sequences that targets battlers charging    
  107.  *           actions                                                          
  108.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  109.  *           by, subtract by, multiply by, divide by or modulo by respectively
  110.  *      2. charge val %: Target Typing, Operator Value                        
  111.  *         - Use Operator to assign Value% of the maximum atb value to the    
  112.  *           charge value of targets included by Target Typing, which can be  
  113.  *           any Target Typing supported by Action Sequences that targets    
  114.  *           battlers charging actions                                        
  115.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  116.  *           by, subtract by, multiply by, divide by or modulo by respectively
  117.  *    # DoubleX RMMV Popularized ATB Cooldown                                
  118.  *      1. cooldown val: Target Typing, Operator Value                        
  119.  *         - Use Operator to assign Value to the cooldown value of targets    
  120.  *           included by Target Typing, which can be any Target Typing        
  121.  *           supported by Action Sequences that targets battlers cooling down
  122.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  123.  *           by, subtract by, multiply by, divide by or modulo by respectively
  124.  *      2. cooldown val %: Target Typing, Operator Value                      
  125.  *         - Use Operator to assign Value% of the maximum atb value to the    
  126.  *           cooldown value of targets included by Target Typing, which can be
  127.  *           any Target Typing supported by Action Sequences that targets    
  128.  *           battlers cooling down                                            
  129.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  130.  *           by, subtract by, multiply by, divide by or modulo by respectively
  131.  *    # DoubleX RMMV Popularized ATB Countdown                                
  132.  *      1. countdown clock: Target Typing, Operator Value State              
  133.  *         - Use operator to assign Value to the number of frames as the      
  134.  *           countdown clock of state with id State for targets included by  
  135.  *           Target Typing, which can be any any Target Typing supported by  
  136.  *           Action Sequences that targets battlers having said state        
  137.  *         - The fps is assumed to be always 60                              
  138.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  139.  *           by, subtract by, multiply by, divide by or modulo by respectively
  140.  *      2. countdown freeze: Target Typing, Flag State                        
  141.  *         - Assign Flag, which is either true or false, to set whether the  
  142.  *           countdown clock of state with id State is frozen for targets    
  143.  *           included by Target Typing, which can be any any Target Typing    
  144.  *           supported by Action Sequences that targets battlers having said  
  145.  *           state                                                            
  146.  *    # DoubleX RMMV Popularized ATB Delay                                    
  147.  *      1. delay frame: Target Typing, Operator Value                        
  148.  *         - Use Operator to assign Value to the number of frames as delay for
  149.  *           targets included by Target Typing, which can be any Target Typing
  150.  *           supported by Action Sequences                                    
  151.  *         - The fps is assumed to be always 60                              
  152.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  153.  *           by, subtract by, multiply by, divide by or modulo by respectively
  154.  *    # DoubleX RMMV Popularized ATB Reset                                    
  155.  *      1. reset val: Target Typing, Operator Value                          
  156.  *         - Use Operator to assign Value to the atb reset value for targets  
  157.  *           included by Target Typing, which can be any Target Typing        
  158.  *           supported by Action Sequences                                    
  159.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  160.  *           by, subtract by, multiply by, divide by or modulo by respectively
  161.  *      2. reset val %: Target Typing, Operator Value                        
  162.  *         - Use Operator to assign Value% of the maximum atb value to the atb
  163.  *           reset value for targets included by Target Typing, which can be  
  164.  *           any Target Typing supported by Action Sequences                  
  165.  *         - Operator can be either =, +, -, *, / or %, meaning set to, add  
  166.  *           by, subtract by, multiply by, divide by or modulo by respectively
  167.  *============================================================================
  168.  *    ## Addressed Plugins                                                    
  169.  *----------------------------------------------------------------------------
  170.  *    # (v1.02a+)Yanfly Engine Plugins - Target Extension - Selection Control
  171.  *      1. The enemy window freezes when the current inputable actor becomes  
  172.  *         not inputable                                                      
  173.  *         - Reference tag: YEP_X_SelectionControl_StopUnlockingEnemyWindow  
  174.  *         - Extended Scene_Battle.prototype.close_patb_selection_windows to  
  175.  *           stop closing the enemy window upon the aforementioned event      
  176.  *      2. (v1.02b+)The currently inputable actor changes when picking targets
  177.  *         - Reference tag: YEP_X_SelectionControl_NewStatusWindowIndex      
  178.  *         - Added get property patb_index in Window_BattleStatus            
  179.  *         - Extended Window_BattleStatus.prototype.select to use a new      
  180.  *           variable to store the index that are not affected by selecting  
  181.  *           targets
  182.  *         - Extended Window_BattleEnemy.prototype.hide and                  
  183.  *           Window_BattleEnemy.prototype.select to select targets without    
  184.  *           changing the new index                                          
  185.  *    # (v1.01a+)MOG_BattleHud:                                              
  186.  *      1. The ATB bar doesn't gather any DoubleX RMMV Popularized ATB data  
  187.  *         - Reference tag: MOG_BattleHud_PATB_Data                          
  188.  *         - Rewritten Battle_Hud.prototype.update_at to support cooldown too
  189.  *         - Extended Battle_Hud.prototype.at, Battle_Hud.prototype.max_at,  
  190.  *           Battle_Hud.prototype.cast_at, Battle_Hud.prototype.cast_max_at  
  191.  *           and Battle_Hud.prototype.is_casting to support atb and charge    
  192.  *         - Added Battle_Hud.prototype.cooldown_at,                          
  193.  *           Battle_Hud.prototype.cooldown_max_at,                            
  194.  *           Battle_Hud.prototype.is_cooling_down and                        
  195.  *           Battle_Hud.prototype.is_max_cooldown to support cooldown        
  196.  *      2. (v1.01b+) The actor window isn't fully shown                      
  197.  *         - Reference tag: MOG_BattleHud_Actor_Window                        
  198.  *         - Removed Scene_Battle.prototype.update_patb_window_positions to  
  199.  *           let MOG_BattleHud handle the actor window position              
  200.  *      3. (v1.02b+)The original status window will be shown when the current
  201.  *         inputable actor becomes not inputable                              
  202.  *         - Reference tag: MOG_BattleHud_StopShowingStatusWindow            
  203.  *         - Extended Scene_Battle.prototype.close_patb_selection_windows to  
  204.  *           stop showing the status window upon the aforementioned event    
  205.  *    # Yanfly Engine Plugins - Battle Engine Core:                          
  206.  *      1. All battler actions are recreated upon starting actor inputs      
  207.  *         - Reference tag: YEP_BattleEngineCore_StopRecreateAction          
  208.  *         - Stopped calling BattleManager.createActions when patb's effective
  209.  *      2. Valid actions don't execute at all                                
  210.  *         - Reference tag: YEP_BattleEngineCore_HandleNewPhases              
  211.  *         - Extended BattleManager.can_update_patb_process to handle new    
  212.  *           phases added by Yanfly Engine Plugins - Battle Engine Core      
  213.  *      3. The battler's atb's reset right after executing 1 action already  
  214.  *         - Reference tag: YEP_BattleEngineCore_StopAllActsEnd              
  215.  *         - Stopped calling Game_Battler.prototype.on_all_patb_acts_end when
  216.  *           the battler still has actions                                    
  217.  *      4. Skills/Items targeting all/random allies/enemies are confirmed    
  218.  *         before the target selection's complete                            
  219.  *         - Reference tag: YEP_BattleEngineCore_StopConfirmAllRandomSelection
  220.  *         - Removed all Game_Action.prototype.confirm_patb_item contents    
  221.  *         - (v1.00c+) Stopped this fix when Select Help Window is false      
  222.  *      5. Right now wait_cond_code full and force run atb are still          
  223.  *         functioning as act                                                
  224.  *         - Due to BattleManager.can_update_patb_process to handle new phases
  225.  *           added by Yanfly Engine Plugins - Battle Engine Core              
  226.  *      6. (v1.00e+) Subsequent actions of an all-selection one all wrongly  
  227.  *         mark all party/troop members                                      
  228.  *         - Reference tag: YEP_BattleEngineCore_StopWrongAllSelections      
  229.  *         - Extended Scene_Battle.prototype.select_next_patb_command to stop
  230.  *           marking actions as all selections                                
  231.  *      7. (v1.03b+) The sprite of the currently inputable actor will return  
  232.  *         to its home position when any action performs its finish sequence  
  233.  *         - Reference tag: YEP_BattleEngineCore_StopInputableActorReturnHome
  234.  *         - Extended Game_Battler.prototype.spriteReturnHome to disable this
  235.  *           function for the currently inputable actor                      
  236.  *============================================================================
  237.  */
  238.  
  239. "use strict";
  240. var DoubleX_RMMV = DoubleX_RMMV || {};
  241. DoubleX_RMMV["PATB Compatibility"] = "v1.03b";
  242.  
  243. /*============================================================================
  244.  *    ## Plugin Implementations                                              
  245.  *       You need not edit this part as it's about how this plugin works      
  246.  *----------------------------------------------------------------------------
  247.  *    # Plugin Support Info:                                                  
  248.  *      1. Prerequisites                                                      
  249.  *         - Basic knowledge of how DoubleX RMMV Popularized ATB and each    
  250.  *           addressed plugin works                                          
  251.  *         - Some Javascript coding proficiency to fully comprehend this      
  252.  *           plugin                                                          
  253.  *      2. Function documentation                                            
  254.  *         - The 1st part describes why this function's rewritten/extended for
  255.  *           rewritten/extended functions or what the function does for new  
  256.  *           functions                                                        
  257.  *         - The 2nd part describes what the arguments of the function are    
  258.  *         - The 3rd part informs which version rewritten, extended or created
  259.  *           this function                                                    
  260.  *         - The 4th part informs whether the function's rewritten or new    
  261.  *         - The 5th part informs whether the function's a real or potential  
  262.  *           hotspot                                                          
  263.  *         - The 6th part describes how this function works for new functions
  264.  *           only, and describes the parts added, removed or rewritten for    
  265.  *           rewritten or extended functions only                            
  266.  *         Example:                                                          
  267.  * /*----------------------------------------------------------------------
  268.  *  *    Why rewrite/extended/What this function does                      
  269.  *  *----------------------------------------------------------------------*/
  270. /* // arguments: What these arguments are                                    
  271.  * function_name = function(arguments) { // Version X+; Rewrite/New; Hotspot  
  272.  *     // Added/Removed/Rewritten to do something/How this function works    
  273.  *     function_name_code;                                                    
  274.  *     //                                                                    
  275.  * } // function_name                                                        
  276.  *----------------------------------------------------------------------------*/
  277.  
  278. if (DoubleX_RMMV["PATB Core"]) {
  279.  
  280. /*----------------------------------------------------------------------------*/
  281.  
  282. if (Imported.YEP_BattleEngineCore) {
  283.  
  284. /*----------------------------------------------------------------------------
  285.  *    # Edit class: BattleManager                                            
  286.  *----------------------------------------------------------------------------*/
  287.  
  288. BattleManager.initMembersPatbCompatibility = BattleManager.initMembers;
  289. BattleManager.initMembers = function() { // v1.03a+
  290.     this.initMembersPatbCompatibility();
  291.     // Added to setup the mapping from the action sequence tag to their handlers
  292.     this.init_patb_act_sequences();
  293.     // YEP_BattleEngineCore_ActionSequences
  294. }; // BattleManager.initMembers
  295.  
  296. BattleManager.processActionSequencePatbCompatibility =
  297. BattleManager.processActionSequence;
  298. BattleManager.processActionSequence = function(actionName, actionArgs) {
  299. // v1.03a+
  300.     // Added to process new action sequences mimicking patb plugin calls
  301.     if (this.is_patb_act_sequence(actionName)) {
  302.         return this.process_patb_act_sequence(actionName, actionArgs);
  303.     }
  304.     // YEP_BattleEngineCore_ActionSequences
  305.     return this.processActionSequencePatbCompatibility(actionName, actionArgs);
  306. }; // BattleManager.processActionSequence
  307.  
  308. BattleManager.createActionsPatbCompatibility = BattleManager.createActions;
  309. BattleManager.createActions = function() {
  310.     // Rewritten to stop recreating battler actions when starting actor inputs
  311.     if (!$gameSystem.is_patb()) { this.createActionsPatbCompatibility(); }
  312.     // YEP_BattleEngineCore_StopRecreateAction
  313. }; // BattleManager.createActions
  314.  
  315. BattleManager.can_update_patb_process_compatibility =
  316. BattleManager.can_update_patb_process;
  317. BattleManager.can_update_patb_process = function() { // Hotspot
  318.     // Added to let BattleManager.update handle all phases when executing action
  319.     if (this._phase === 'actionList' || this._phase === 'actionTargetList') {
  320.         this.update();
  321.         return false;
  322.     } else if (this._phase === 'phaseChange') {
  323.         this.update();
  324.         return false;
  325.     }
  326.     // YEP_BattleEngineCore_HandleNewPhases
  327.     return this.can_update_patb_process_compatibility();
  328. }; // BattleManager.can_update_patb_process
  329.  
  330. BattleManager.init_patb_act_sequences = function() { // v1.03a+; New
  331.     this._patb_act_sequences = {
  332.         // DoubleX RMMV Popularized ATB Core
  333.         'ATB VAL': 'process_patb_val_act_sequence',
  334.         'ATB VAL %': 'process_patb_val_percent_act_sequence',
  335.         'RESET ATB VAL': 'process_reset_patb_val_act_sequence',
  336.         'RESET ATB': 'process_reset_patb_act_sequence',
  337.         //
  338.         // DoubleX RMMV Popularized ATB Charge
  339.         'CHARGE VAL': 'process_patb_charge_val_act_sequence',
  340.         'CHARGE VAL %': 'process_patb_charge_val_percent_act_sequence',
  341.         //
  342.         // DoubleX RMMV Popularized ATB Cooldown
  343.         'COOLDOWN VAL': 'process_patb_cooldown_val_act_sequence',
  344.         'COOLDOWN VAL %': 'process_patb_cooldown_val_percent_act_sequence',
  345.         //
  346.         // DoubleX RMMV Popularized ATB Countdown
  347.         'COUNTDOWN CLOCK': 'process_patb_countdown_clock_act_sequence',
  348.         'COUNTDOWN FREEZE': 'process_patb_countdown_freeze_act_sequence',
  349.         //
  350.         // DoubleX RMMV Popularized ATB Delay
  351.         'DELAY FRAME': 'process_patb_delay_frame_act_sequence',
  352.         //
  353.         // DoubleX RMMV Popularized ATB Reset
  354.         'RESET VAL': 'process_patb_reset_val_act_sequence',
  355.         'RESET VAL %': 'process_patb_reset_val_percent_act_sequence'
  356.         //
  357.     };
  358.     this._patb_act_sequence_regex = {
  359.         // DoubleX RMMV Popularized ATB Core
  360.         'ATB VAL': / *(.+) +(\d+) */i,
  361.         'ATB VAL %': / *(.+) +(\d+) */i,
  362.         'RESET ATB VAL': /.*/i,
  363.         'RESET ATB': /.*/i,
  364.         //
  365.         // DoubleX RMMV Popularized ATB Charge
  366.         'CHARGE VAL': / *(.+) +(\d+) */i,
  367.         'CHARGE VAL %': / *(.+) +(\d+) */i,
  368.         //
  369.         // DoubleX RMMV Popularized ATB Cooldown
  370.         'COOLDOWN VAL': / *(.+) +(\d+) */i,
  371.         'COOLDOWN VAL %': / *(.+) +(\d+) */i,
  372.         //
  373.         // DoubleX RMMV Popularized ATB Countdown
  374.         'COUNTDOWN CLOCK': / *(.+) +(\d+) +(\d+) */i,
  375.         'COUNTDOWN FREEZE': / *(\w+) +(\d+) */i,
  376.         //
  377.         // DoubleX RMMV Popularized ATB Delay
  378.         'DELAY FRAME': / *(.+) +(\d+) */i,
  379.         //
  380.         // DoubleX RMMV Popularized ATB Reset
  381.         'RESET VAL': / *(.+) +(\d+) */i,
  382.         'RESET VAL %': / *(.+) +(\d+) */i
  383.         //
  384.     };
  385. }; // BattleManager.init_patb_act_sequences
  386.  
  387. BattleManager.is_patb_act_sequence = function(actionName) { // v1.03a+; New
  388.     return Object.keys(this._patb_act_sequences).indexOf(actionName) >= 0;
  389. }; // BattleManager.processActionSequence
  390.  
  391. BattleManager.process_patb_act_sequence = function(actionName, actionArgs) {
  392. // v1.03a+; New
  393.     if (!$gameSystem.is_patb()) { return true; }
  394.     var targets = this.makeActionTargets(actionArgs[0]);
  395.     if (targets.length <= 0) { return true; };
  396.     var cmd = actionArgs[1];
  397.     if (cmd && !cmd.match(this._patb_act_sequence_regex[actionName])) {
  398.         return true;
  399.     }
  400.     return this[this._patb_act_sequences[actionName]](targets, cmd);
  401. }; // BattleManager.process_patb_act_sequence
  402.  
  403. BattleManager.process_patb_val_act_sequence = function(targets) {
  404. // v1.03a+; New
  405.     var operator = RegExp.$1, val = +RegExp.$2 * 1.0;
  406.     targets.forEach(function(target) {
  407.         if (this.is_patb_charge(target)) { target.reset_patb(); }
  408.         var atb = target.patb_val.atb;
  409.         target.patb_val.atb = target.operate_patb_notes(atb, operator, val);
  410.     }, this);
  411.     return true;
  412. }; // BattleManager.process_patb_val_act_sequence
  413.  
  414. BattleManager.process_patb_val_percent_act_sequence = function(targets) {
  415. // v1.03a+; New
  416.     var operator = RegExp.$1, temp = +RegExp.$2;
  417.     targets.forEach(function(target) {
  418.         if (this.is_patb_charge(target)) { target.reset_patb(); }
  419.         var val = temp * target.max_patb_val / 100.0, atb = target.patb_val.atb;
  420.         target.patb_val.atb = target.operate_patb_notes(atb, operator, val);
  421.     }, this);
  422.     return true;
  423. }; // BattleManager.process_patb_val_percent_act_sequence
  424.  
  425. BattleManager.process_reset_patb_val_act_sequence = function(targets) {
  426. // v1.03a+; New
  427.     targets.forEach(function(target) { target.reset_patb_val(); }, this);
  428.     return true;
  429. }; // BattleManager.process_reset_patb_val_act_sequence
  430.  
  431. BattleManager.process_reset_patb_act_sequence = function(targets) {
  432. // v1.03a+; New
  433.     targets.forEach(function(target) { target.reset_patb(); }, this);
  434.     return true;
  435. }; // BattleManager.process_reset_patb_act_sequence
  436.  
  437. BattleManager.process_patb_charge_val_act_sequence = function(targets) {
  438. // v1.03a+; New
  439.     if (!DoubleX_RMMV["PATB Charge"]) { return true; }
  440.     var operator = RegExp.$1, val = +RegExp.$2 * 1.0;
  441.     targets.filter(this.is_patb_charge, this).forEach(function(target) {
  442.         var charge = target.patb_val.charge;
  443.         target.patb_val.charge =
  444.                 target.operate_patb_notes(charge, operator, val);
  445.     }, this);
  446.     return true;
  447. }; // BattleManager.process_patb_charge_val_act_sequence
  448.  
  449. BattleManager.process_patb_charge_val_percent_act_sequence = function(targets) {
  450. // v1.03a+; New
  451.     if (!DoubleX_RMMV["PATB Charge"]) { return true; }
  452.     var operator = RegExp.$1, temp = +RegExp.$2;
  453.     targets.filter(this.is_patb_charge, this).forEach(function(target) {
  454.         var val = temp * target.max_patb_val / 100.0;
  455.         var charge = target.patb_val.charge;
  456.         target.patb_val.charge =
  457.                 target.operate_patb_notes(charge, operator, val);
  458.     }, this);
  459.     return true;
  460. }; // BattleManager.process_patb_charge_val_percent_act_sequence
  461.  
  462. BattleManager.is_patb_charge = function(target) { // v1.03a+; New
  463.     if (this.is_patb_cooldown(target)) { return false; }
  464.     return DoubleX_RMMV["PATB Charge"] && target.is_patb_charge();
  465. }; // BattleManager.is_patb_charge
  466.  
  467. BattleManager.process_patb_cooldown_val_act_sequence = function(targets) {
  468. // v1.03a+; New
  469.     if (!DoubleX_RMMV["PATB Cooldown"]) { return true; }
  470.     var operator = RegExp.$1, val = +RegExp.$2 * 1.0;
  471.     targets.filter(this.is_patb_cooldown, this).forEach(function(target) {
  472.         var cooldown = target.patb_val.cooldown;
  473.         target.patb_val.cooldown =
  474.                 target.operate_patb_notes(cooldown, operator, val);
  475.     }, this);
  476.     return true;
  477. }; // BattleManager.process_patb_cooldown_val_act_sequence
  478.  
  479. BattleManager.process_patb_cooldown_val_percent_act_sequence = function(targets) {
  480. // v1.03a+; New
  481.     if (!DoubleX_RMMV["PATB Cooldown"]) { return true; }
  482.     var operator = RegExp.$1, temp = +RegExp.$2;
  483.     targets.filter(this.is_patb_cooldown, this).forEach(function(target) {
  484.         var val = temp * target.max_patb_val / 100.0;
  485.         var cooldown = target.patb_val.cooldown;
  486.         target.patb_val.cooldown =
  487.                 target.operate_patb_notes(cooldown, operator, val);
  488.     }, this);
  489.     return true;
  490. }; // BattleManager.process_patb_cooldown_val_percent_act_sequence
  491.  
  492. BattleManager.is_patb_cooldown = function(target) { // v1.03a+; New
  493.     return target.is_patb_cooldown();
  494. }; // BattleManager.is_patb_cooldown
  495.  
  496. BattleManager.process_patb_countdown_clock_act_sequence = function(targets) {
  497. // v1.03a+; New
  498.     if (!DoubleX_RMMV["PATB Countdown"]) { return true; }
  499.     var operator = RegExp.$1, val = +RegExp.$2, state_id = +RegExp.$3;
  500.     // Separating the filter function would cause make it too hard for learners
  501.     targets.filter(function(target) {
  502.         return target.isStateAdded(state_id);
  503.     }, this).forEach(function(target) {
  504.         var clock = target.patb_countdown_clock[state_id];
  505.         var new_clock = target.operate_patb_notes(clock, operator, val);;
  506.         target.patb_countdown_clock[state_id] = new_clock;
  507.     }, this);
  508.     //
  509.     return true;
  510. }; // BattleManager.process_patb_countdown_clock_act_sequence
  511.  
  512. BattleManager.process_patb_countdown_freeze_act_sequence = function(targets) {
  513. // v1.03a+; New
  514.     if (!DoubleX_RMMV["PATB Countdown"]) { return true; }
  515.     var is_freeze = RegExp.$1 === "true", state_id = +RegExp.$2;
  516.     // Separating the filter function would cause make it too hard for learners
  517.     targets.filter(function(target) {
  518.         return target.isStateAdded(state_id);
  519.     }, this).forEach(function(target) {
  520.         target.patb_countdown_freeze[state_id] = is_freeze;
  521.     }, this);
  522.     //
  523.     return true;
  524. }; // BattleManager.process_patb_countdown_freeze_act_sequence
  525.  
  526. BattleManager.process_patb_delay_frame_act_sequence = function(targets) {
  527. // v1.03a+; New
  528.     if (!DoubleX_RMMV["PATB Delay"]) { return true; }
  529.     var operator = RegExp.$1, val = +RegExp.$2;
  530.     // Restricting delay to its intended scope would make this sequence useless
  531.     targets.forEach(function(target) {
  532.         var delay = target.patb_delay;
  533.         target.patb_delay = target.operate_patb_notes(delay, operator, val);
  534.     }, this);
  535.     //
  536.     return true;
  537. }; // BattleManager.process_patb_delay_frame_act_sequence
  538.  
  539. BattleManager.process_patb_reset_val_act_sequence = function(targets) {
  540. // v1.03a+; New
  541.     if (!DoubleX_RMMV["PATB Reset"]) { return true; }
  542.     var operator = RegExp.$1, val = +RegExp.$2 * 1.0;
  543.     targets.forEach(function(target) {
  544.         var reset = target.patb_reset_val;
  545.         target.patb_reset_val = target.operate_patb_notes(reset, operator, val);
  546.     }, this);
  547.     return true;
  548. }; // BattleManager.process_patb_reset_val_act_sequence
  549.  
  550. BattleManager.process_patb_reset_val_percent_act_sequence = function(targets) {
  551. // v1.03a+; New
  552.     if (!DoubleX_RMMV["PATB Reset"]) { return true; }
  553.     var operator = RegExp.$1, temp = +RegExp.$2;
  554.     targets.forEach(function(target) {
  555.         var val = temp * target.max_patb_val / 100.0;
  556.         var reset = target.patb_reset_val;
  557.         target.patb_reset_val = target.operate_patb_notes(reset, operator, val);
  558.     }, this);
  559.     return true;
  560. }; // BattleManager.process_patb_reset_val_percent_act_sequence
  561.  
  562. /*----------------------------------------------------------------------------
  563.  *    # Edit class: Game_Battler                                              
  564.  *----------------------------------------------------------------------------*/
  565.  
  566. Game_Battler.prototype.spriteReturnHomeComnpatibility =
  567. Game_Battler.prototype.spriteReturnHome;
  568. Game_Battler.prototype.spriteReturnHome = function() { // v1.03b+
  569.     // Added to stop returning home for the sprite of the currently inpuable one
  570.     if ($gameSystem.is_patb() && BattleManager.actor() === this) return;
  571.     // YEP_BattleEngineCore_StopInputableActorReturnHome
  572.     this.spriteReturnHomeComnpatibility();
  573. }; // Game_Battler.prototype.spriteReturnHome
  574.  
  575. Game_Battler.prototype.on_all_patb_acts_end_comnpatibility =
  576. Game_Battler.prototype.on_all_patb_acts_end;
  577. Game_Battler.prototype.on_all_patb_acts_end = function() {
  578.     // Added to stop resetting the battler's atb when there's still actions
  579.     if (this.currentAction()) { return; }
  580.     // YEP_BattleEngineCore_StopAllActsEnd
  581.     this.on_all_patb_acts_end_comnpatibility();
  582. }; // Game_Battler.prototype.on_all_patb_acts_end
  583.  
  584. if (Imported.YEP_X_SelectionControl) {
  585.  
  586. /*----------------------------------------------------------------------------
  587.  *    # (v1.02b+)Edit class: Window_BattleStatus                              
  588.  *----------------------------------------------------------------------------*/
  589.  
  590. /*----------------------------------------------------------------------------
  591.  *    New public instance variable                                            
  592.  *----------------------------------------------------------------------------*/
  593. // The index without being influenced by YEP_X_SelectionControl
  594. Object.defineProperty(Window_BattleStatus.prototype, "patb_index", {
  595.     get: function() { /* Hotspot */ return this._patb_index; },
  596.     configurable: true
  597. });
  598.  
  599. /*----------------------------------------------------------------------------
  600.  *    Uses a new variable to store the index that are not from target windows
  601.  *----------------------------------------------------------------------------*/
  602. Window_BattleStatus.prototype.select = function(index) { // New
  603.     Window_Selectable.prototype.select.call(this, index);
  604.     if (!$gameTemp.is_patb_selecting_targets) { this._patb_index = index; }
  605. }; // Window_BattleStatus.prototype.select
  606.  
  607. /*----------------------------------------------------------------------------
  608.  *    # (v1.02b+)Edit class: Window_BattleEnemy                              
  609.  *----------------------------------------------------------------------------*/
  610.  
  611. Window_BattleEnemy.prototype.hidePatbCompatibility =
  612. Window_BattleEnemy.prototype.hide;
  613. Window_BattleEnemy.prototype.hide = function() {
  614.     // Added to ensure the new index won't be influenced by selecting targets
  615.     $gameTemp.is_patb_selecting_targets = true;
  616.     // YEP_X_SelectionControl_NewStatusWindowIndex
  617.     Window_BattleEnemy.prototype.hidePatbCompatibility.call(this);
  618.     // Added to ensure the new index will be influenced by everything else
  619.     $gameTemp.is_patb_selecting_targets = false;
  620.     // YEP_X_SelectionControl_NewStatusWindowIndex
  621. }; // Window_BattleEnemy.prototype.hide
  622.  
  623. Window_BattleEnemy.prototype.selectPatbCompatibility =
  624. Window_BattleEnemy.prototype.select;
  625. Window_BattleEnemy.prototype.select = function(index) {
  626.     // Added to ensure the new index won't be influenced by selecting targets
  627.     $gameTemp.is_patb_selecting_targets = true;
  628.     // YEP_X_SelectionControl_NewStatusWindowIndex
  629.     Window_BattleEnemy.prototype.selectPatbCompatibility.call(this, index);
  630.     // Added to ensure the new index will be influenced by everything else
  631.     $gameTemp.is_patb_selecting_targets = false;
  632.     // YEP_X_SelectionControl_NewStatusWindowIndex
  633. }; // Window_BattleEnemy.prototype.select
  634.  
  635. /*----------------------------------------------------------------------------
  636.  *    # (v1.00e+)Edit class: Scene_Battle                                    
  637.  *----------------------------------------------------------------------------*/
  638.  
  639. // actor_indices: The indices of all currently inputable actors
  640. Scene_Battle.prototype.update_patb_actor_selection = function() {
  641. // v1.02b+; Rewrite; Hotspot
  642.     var actor_indices = BattleManager.inputable_patb_actor_indices();
  643.     // Rewritten to use the index that are not changed by YEP_X_SelectionControl
  644.     var index = this._statusWindow.patb_index;
  645.     // YEP_X_SelectionControl_NewStatusWindowIndex
  646.     if (actor_indices.indexOf(index) >= 0) { return; }
  647.     // Deactivates the active input windows that should be no longer active
  648.     if (index >= 0) { return this.close_patb_selection_windows(); }
  649.     if (this._partyCommandWindow.active) {
  650.         if (actor_indices.length <= 0) {
  651.             this.close_patb_window(this._partyCommandWindow);
  652.         }
  653.         return;
  654.     }
  655.     //
  656.     if (actor_indices.length <= 0) { return; }
  657.     BattleManager.changeActor(actor_indices[0], 'waiting');
  658.     this.startActorCommandSelection();
  659. }; // Scene_Battle.prototype.update_patb_actor_selection
  660.  
  661. Scene_Battle.prototype.select_next_patb_command_comnpatibility =
  662. Scene_Battle.prototype.select_next_patb_command;
  663. Scene_Battle.prototype.select_next_patb_command = function() { // v1.00b+
  664.     this.select_next_patb_command_comnpatibility();
  665.     // Added to ensure that subsequent actions won't be marked as all selections
  666.     BattleManager.stopAllSelection();
  667.     // YEP_BattleEngineCore_StopWrongAllSelections
  668. }; // Scene_Battle.prototype.select_next_patb_command
  669.  
  670. Scene_Battle.prototype.close_patb_selection_windows_comnpatibility =
  671. Scene_Battle.prototype.close_patb_selection_windows;
  672. Scene_Battle.prototype.close_patb_selection_windows = function() { // v1.02a+
  673.     // Added to save the last active status before stopping it from being closed
  674.     var is_enemy_window_active = this._enemyWindow.active;
  675.     // YEP_X_SelectionControl_StopUnlockingEnemyWindow
  676.     this.close_patb_selection_windows_comnpatibility();
  677.     // Added to load the last active status after stopping it from being closed
  678.     if (is_enemy_window_active) this._enemyWindow.activate();
  679.     // YEP_X_SelectionControl_StopUnlockingEnemyWindow
  680. }; // Scene_Battle.prototype.close_patb_selection_windows
  681.  
  682. } // if (Imported.YEP_X_SelectionControl)
  683.  
  684. if (DoubleX_RMMV["PATB Hotkey"]) {
  685.  
  686. /*----------------------------------------------------------------------------
  687.  *    # (v1.00b+)Edit class: Window_ActorCommand.                            
  688.  *----------------------------------------------------------------------------*/
  689.  
  690. Window_ActorCommand.prototype.processTouch = function() { // New; Hotspot
  691.     this.process_patb_hotkey_touch();
  692.     Window_Selectable.prototype.processTouch.call(this);
  693. }; // Window_ActorCommand.prototype.processTouch
  694.  
  695. Window_ActorCommand.prototype.process_patb_hotkey_touch = function() {
  696. // New; Hotspot
  697.     if (!this.isOpenAndActive() || !$gameSystem.is_patb()) { return; }
  698.     this.process_patb_hotkey_touch_select();
  699.     this.process_patb_hotkey_touch_trigger();
  700. }; // Window_ActorCommand.prototype.process_patb_hotkey_touch
  701.  
  702. Window_ActorCommand.prototype.process_patb_hotkey_touch_select = function() {
  703. // New; Hotspot
  704.     if (!Yanfly.Param.BECSelectMouseOver) { return; }
  705.     var index = this.getMouseOverActor();
  706.     if (index < 0) { return; }
  707.     var mem = $gameParty.battleMembers()[index];
  708.     if (mem.isSelected()) { return; }
  709.     SoundManager.playCursor();
  710.     $gameParty.select(mem);
  711. }; // Window_ActorCommand.prototype.process_patb_hotkey_touch_select
  712.  
  713. Window_ActorCommand.prototype.process_patb_hotkey_touch_trigger = function() {
  714. // New; Hotspot
  715.     if (!eval(Yanfly.Param.BECActorSelect)) { return; }
  716.     if (!TouchInput.isTriggered() || this.isTouchedInsideFrame()) { return; }
  717.     var i = this.getClickedActor();
  718.     if (i < 0) { return; }
  719.     return this.callHandler($gameSystem.patb["hotkey_actor_" + i.toString()]);
  720. }; // Window_ActorCommand.prototype.process_patb_hotkey_touch_trigger
  721.  
  722. Window_ActorCommand.prototype.getClickedActor =
  723. Window_BattleActor.prototype.getClickedActor;
  724.  
  725. Window_ActorCommand.prototype.isClickedActor =
  726. Window_BattleActor.prototype.isClickedActor;
  727.  
  728. Window_ActorCommand.prototype.getMouseOverActor =
  729. Window_BattleActor.prototype.getMouseOverActor;
  730.  
  731. Window_ActorCommand.prototype.isMouseOverActor =
  732. Window_BattleActor.prototype.isMouseOverActor;
  733.  
  734. } // if (DoubleX_RMMV["PATB Hotkey"])
  735.  
  736. } // if (Imported.YEP_BattleEngineCore)
  737.  
  738. if (Imported.MOG_BattleHud) {
  739.  
  740. /*----------------------------------------------------------------------------
  741.  *    # (v1.01a+)Edit class: Battle_Hud                                      
  742.  *----------------------------------------------------------------------------*/
  743.  
  744. Battle_Hud.prototype.update_at = function() {
  745.     if (this._at_meter) {
  746.         if (!this.at === -1) { return this._at_meter.visible = false; }
  747.         this._at_meter.visible = true;
  748.         if(!this._at_flow[0]) {
  749.             // Rewritten to update the cooldown atb bars as well
  750.             if (this.is_casting()) {
  751.                 if (this.is_max_cast()) {
  752.                     return this.refresh_at_meter(this._at_meter, this.cast_at(), this.cast_max_at(), 3);
  753.                 }
  754.                 return this.refresh_at_meter(this._at_meter, this.cast_at(), this.cast_max_at(), 2);
  755.             } else if (this.is_cooling_down()) {
  756.                 if (this.is_max_cooldown()) {
  757.                     return this.refresh_at_meter(this._at_meter, this.cooldown_at(), this.cooldown_max_at(), 3);
  758.                 }
  759.                 return this.refresh_at_meter(this._at_meter, this.cooldown_at(), this.cooldown_max_at(), 2);
  760.             } else if (this.is_max_at()) {
  761.                 return this.refresh_at_meter(this._at_meter, this.at(), this.max_at(), 1);
  762.             }
  763.             // MOG_BattleHud_PATB_Data
  764.             return this.refresh_at_meter(this._at_meter, this.at(), this.max_at(), 0);
  765.         }
  766.         // Rewritten to update the cooldown atb bars as well
  767.         if (this.is_casting()) {
  768.             if (this.is_max_cast()) {
  769.                 this.refresh_at_meter_flow(this._at_meter, this.cast_at(), this.cast_max_at(), 3, this._at_flow[1]);
  770.             } else {
  771.                 this.refresh_at_meter_flow(this._at_meter, this.cast_at(), this.cast_max_at(), 2, this._at_flow[1]);
  772.             }
  773.         } else if (this.is_cooling_down()) {
  774.             if (this.is_max_cooldown()) {
  775.                 this.refresh_at_meter_flow(this._at_meter, this.cooldown_at(), this.cooldown_max_at(), 3, this._at_flow[1]);
  776.             } else {
  777.                 this.refresh_at_meter_flow(this._at_meter, this.cooldown_at(), this.cooldown_max_at(), 2, this._at_flow[1]);
  778.             }
  779.         } else if (this.is_max_at()) {
  780.             this.refresh_at_meter_flow(this._at_meter, this.at(), this.max_at(), 1, this._at_flow[1]);
  781.         } else {
  782.             this.refresh_at_meter_flow(this._at_meter, this.at(), this.max_at(), 0, this._at_flow[1]);
  783.         }
  784.         // MOG_BattleHud_PATB_Data
  785.         this._at_flow[1] += 1.5;
  786.         if (this._at_flow[1] > this._at_flow[3]) { this._at_flow[1] = 0; }
  787.     }
  788. }; // Battle_Hud.prototype.update_at
  789.  
  790. Battle_Hud.prototype.at_patb_compatibility = Battle_Hud.prototype.at;
  791. Battle_Hud.prototype.at = function() {
  792.     // Added to use the ATB value from PATB only if it's active
  793.     if ($gameSystem.is_patb()) { return this._battler.patb_val.atb; }
  794.     // MOG_BattleHud_PATB_Data
  795.     return this.at_patb_compatibility();
  796. }; // Battle_Hud.prototype.at
  797.  
  798. Battle_Hud.prototype.max_at_patb_compatibility = Battle_Hud.prototype.max_at;
  799. Battle_Hud.prototype.max_at = function() {
  800.     // Added to use the ATB value from PATB only if it's active
  801.     if ($gameSystem.is_patb()) { return this._battler._max_patb_val; }
  802.     // MOG_BattleHud_PATB_Data
  803.     return this.max_at_patb_compatibility();
  804. }; // Battle_Hud.prototype.max_at
  805.  
  806. Battle_Hud.prototype.cast_at_patb_compatibility = Battle_Hud.prototype.cast_at;
  807. Battle_Hud.prototype.cast_at = function() {
  808.     // Added to use the ATB value from PATB only if it's active
  809.     if ($gameSystem.is_patb()) {
  810.         if (!DoubleX_RMMV["PATB Charge"]) { return 0; }
  811.         return this._battler.patb_val.charge;
  812.     }
  813.     // MOG_BattleHud_PATB_Data
  814.     return this.cast_at_patb_compatibility();
  815. }; // Battle_Hud.prototype.cast_at
  816.  
  817. Battle_Hud.prototype.cast_max_at_patb_compatibility =
  818.         Battle_Hud.prototype.cast_max_at;
  819. Battle_Hud.prototype.cast_max_at = function() {
  820.     // Added to use the ATB value from PATB only if it's active
  821.     if ($gameSystem.is_patb()) { return this._battler._max_patb_val; }
  822.     // MOG_BattleHud_PATB_Data
  823.     return this.cast_max_at_patb_compatibility();
  824. }; // Battle_Hud.prototype.cast_max_at
  825.  
  826. Battle_Hud.prototype.is_casting_patb_compatibility =
  827.         Battle_Hud.prototype.is_casting;
  828. Battle_Hud.prototype.is_casting = function() {
  829.     // Added to use the ATB value from PATB only if it's active
  830.     if ($gameSystem.is_patb()) {
  831.         if (!DoubleX_RMMV["PATB Charge"]) { return false; }
  832.         return this._battler.is_patb_charge();
  833.     }
  834.     // MOG_BattleHud_PATB_Data
  835.     return this.is_casting_patb_compatibility();
  836. }; // Battle_Hud.prototype.is_casting
  837.  
  838. Battle_Hud.prototype.cooldown_at = function() { // New; Hotspot
  839.     if (!$gameSystem.is_patb() || !DoubleX_RMMV["PATB Cooldown"]) { return 0; }
  840.     return this._battler.patb_val.cooldown;
  841. }; // Battle_Hud.prototype.cooldown_at
  842.  
  843. Battle_Hud.prototype.cooldown_max_at = function() { // New; Hotspot
  844.     return $gameSystem.is_patb() ? this._battler._max_patb_val : 1;
  845. }; // Battle_Hud.prototype.cooldown_max_at
  846.  
  847. Battle_Hud.prototype.is_cooling_down = function() { // New; Hotspot
  848.     if ($gameSystem.is_patb() && DoubleX_RMMV["PATB Cooldown"]) {
  849.         return this._battler.is_patb_cooldown();
  850.     }
  851.     return false;
  852. }; // Battle_Hud.prototype.is_cooling_down
  853.  
  854. Battle_Hud.prototype.is_max_cooldown = function() { // New; Hotspot
  855.     return this.cooldown_at() >= this.cooldown_max_at();
  856. }; // Battle_Hud.prototype.is_max_cooldown
  857.  
  858. /*----------------------------------------------------------------------------
  859.  *    # (v1.01b+)Edit class: Scene_Battle                                    
  860.  *----------------------------------------------------------------------------*/
  861.  
  862. Scene_Battle.prototype.update_patb_window_positions = function() { // Rewrite
  863.     // Removed to let MOG_BattleHud handle the actor window positions
  864.     // MOG_BattleHud_Actor_Window
  865. }; // Scene_Battle.prototype.update_patb_window_positions
  866.  
  867. Scene_Battle.prototype.close_patb_selection_windows_comnpatibility2 =
  868. Scene_Battle.prototype.close_patb_selection_windows;
  869. Scene_Battle.prototype.close_patb_selection_windows = function() { // v1.02b+
  870.     this.close_patb_selection_windows_comnpatibility2();
  871.     // Added to stop showing the status window
  872.     this._statusWindow.close();
  873.     this._statusWindow.hide();
  874.     // MOG_BattleHud_StopShowingStatusWindow
  875. }; // Scene_Battle.prototype.close_patb_selection_windows
  876.  
  877. } // if (Imported.MOG_BattleHud)
  878.  
  879. /*----------------------------------------------------------------------------*/
  880.  
  881. } else {
  882.     alert("To use PATB Compatibility, place it below all other PATB plugins.");
  883. }
  884.  
  885. /*============================================================================*/
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top