Notifications System 1.3 + Add-on

Discussion in 'JS Plugin Releases (RMMV)' started by Lecode, Oct 25, 2015.

  1. DarkRafa

    DarkRafa Warper Member

    Messages:
    4
    Likes Received:
    0
    First Language:
    Brazilian
    When a new skill is learned.
    If you may can do it.
     
    #61
  2. bluebooth

    bluebooth Veteran Veteran

    Messages:
    95
    Likes Received:
    115
    First Language:
    English
    Primarily Uses:
    N/A
    I can! Here's the new version of the plugin:
    Code:
    /*
    #=============================================================================
    # Notifications System
    # LeNotifications.js
    # By Lecode (full original script), Michael Morris (fixes, expansion)
    # Version 1.04
    #-----------------------------------------------------------------------------
    # TERMS OF USE
    #-----------------------------------------------------------------------------
    # - Credit required
    # - Keep this header
    # - Contact me for commercial use
    #=============================================================================
    */
    var Imported = Imported || {};
    Imported.Lecode_Notifications = true;
    /*:
     * @plugindesc Show some notifications according to different events in game
     * @author Lecode, Michael Morris (https://www.patreon.com/bluebooth)
     * @version 1.08
     *
     * Expansion and bug-fixes for Lecode's LeNotifications.js plugin.  Maximum
     * limit for currently displayed notifications added, bugfix for notifications
     * showing when enabled was set to false, volume fix for multiple notifs playing
     * sound at once.  Merged with LeNotifsClosedCaptioning.js to get rid of namespace
     * related crashes.  CC now works properly.  Added CC support for ME.  Added Option
     * for CC to Options Menu.  Notifs now cleared between scene changes to avoid some
     * notif issues (items thinking they're visible when they aren't, etc.).  Notifs now
     * shift position to avoid covering message box (and this shift is compatible with
     * move ins and outs).  Added in skill change notifications.
     *
     * @param === CORE SETTINGS ===
     * @param Background Color
     * @desc CSS Format
     * Default: Black ( #000000 )
     * @default #000000
     *
     * @param Text Color
     * @desc CSS Format
     * Default: White ( #FFFFFF )
     * @default #FFFFFF
     *
     * @param Font Size
     * @desc Font size
     * Default: 18
     * @default 18
     *
     * @param Font Italic ?
     * @desc Font italic ?
     * Default: false
     * @default false
     *
     * @param Text Outline Color
     * @desc Text Outline Color
     * Default: None ( # )
     * @default #
     *
     * @param Text Outline Width
     * @desc Text Outline Width
     * Default: 0
     * @default 0
     *
     * @param Opacity
     * @desc Layout's opacity (0-255)
     * Default: 180
     * @default 180
     *
     * @param Position
     * @desc Layout's position. top-left, bottom-left, top-right, bottom-right
     * Default: top-left
     * @default top-left
     *
     * @param Left-Right Padding
     * @desc Horizontal padding
     * Default: 4
     * @default 4
     *
     * @param Up-Down Padding
     * @desc Vertical padding
     * Default: 4
     * @default 4
     *
     * @param Move Speed
     * @desc The move speed
     * Default: 6
     * @default 6
     *
     * @param Fade Speed
     * @desc The fade speed
     * Default: 4
     * @default 4
     *
     * @param Life Time
     * @desc Duration (in frames)
     * Default: 200
     * @default 200
     *
     * @param Life Time Auto ?
     * @desc If true, the life time is based on the length of the text.
     * ( So, the previous param doesn't matter)
     * Default: true
     * @default true
     *
     * @param Sound Filename
     * @desc Sound to play when a notification appears.  Leave empty to play no sound.
     * Default: Book1
     * @default Book1
     *
     * @param Maximum Notifs
     * @desc The maximum number of notifs to display at once on screen.  Prevents notifs taking up too much of the screen.
     * Default: 4
     * @default 4
     *
     * @param === GOLD NOTIFICATION SETTINGS ===
     *
     * @param Notif Gain Gold
     * @desc Set false to disable.
     * Default: Gold: +[value]
     * @default Gold: +[value]
     *
     * @param Notif Lose Gold
     * @desc Set false to disable.
     * Default: Gold: -[value]
     * @default Gold: -[value]
     *
     * @param === ITEM NOTIFICATION SETTINGS ===
     *
     * @param Notif Gain Item
     * @desc Set false to disable.
     * Default: Obtained [name] x[amount]
     * @default Obtained [name] x[amount]
     *
     * @param Notif Lose Item
     * @desc Set false to disable.
     * Default: Lost [name] x[amount]
     * @default Lost [name] x[amount]
     *
     * @param === EXP NOTIFICATION SETTINGS ===
     *
     * @param Notif Gain Exp
     * @desc Set false to disable.
     * Default: [name]: +[value] Exp
     * @default [name]: +[value] Exp
     *
     * @param Notif Lose Exp
     * @desc Set false to disable.
     * Default: [name]: -[value] Exp
     * @default [name]: -[value] Exp
     *
     * @param === LEVEL NOTIFICATION SETTINGS ===
     *
     * @param Notif LevelUp
     * @desc Set false to disable.
     * Default: [name]: level up !
     * @default [name]: level up !
     *
     * @param Notif LevelDown
     * @desc Set false to disable.
     * Default: [name]: level down !
     * @default [name]: level down !
     *
     * @param === SKILL NOTIFICATION SETTINGS ===
     *
     * @param Notif Skill Learnt
     * @desc Set false to disable.
     * Default: [name]: learned '[value]' !
     * @default [name]: learned '[value]' !
     *
     * @param Notif Skill Forgot
     * @desc Set false to disable.
     * Default: [name]: forgot '[value]' !
     * @default [name]: forgot '[value]' !
     *
     * @param === AUDIO NOTIFICATION SETTINGS ===
     *
     * @param Notif BGM
     * @desc Set 'false' to disable
     * Default: Now Playing \C[1]'[name]'\C[0]. [caption]
     * @default Now Playing \C[1]'[name]'\C[0]. [caption]
     *
     * @param Notif BGS
     * @desc Set 'false' to disable
     * Default: Ambient sound:'[name]'. [caption]
     * @default Ambient sound:'[name]'. [caption]
     *
     * @param Notif SE
     * @desc Set 'false' to disable
     * Default: SE:'[name]'. [caption]
     * @default SE:'[name]'. [caption]
     *
     * @param Notif ME
     * @desc Set 'false' to disable
     * Default: Jingle:'[name]'. [caption]
     * @default Jingle:'[name]'. [caption]
     *
     * @param === CLOSED CAPTIONING ===
     *
     * @param Enable Closed Captioning
     * @desc Set to 'true' to enable closed captioning for sounds.  Overridden for any of Notif BGM, BGS, SE being false.
     * Default: false
     * @default false
     *
     * @param === DEBUG SETTINGS ===
     *
     * @param Debug Mode
     * @desc Enable to activate console variable logging.  Use for debugging odd behaviour.
     * true to enable console variable logging.
     * @default false
     *
     * @help
     * Plugin Commands:
     *   -> Notification Clear                  ( Delete all notifications )
     *   -> Notification Enable true/false      ( Enable or disable notifications )
     *   -> Notification Position value         ( Change next notifications position )
     *   -> Notification TextColor value        ( Change text color )
     *   -> Notification FontSize value         ( Change font size )
     *   -> Notification FontItalic true/false  ( Change text italic property )
     *   -> Notification OutlineColor value     ( Change outline color set value to '' to remove )
     *   -> Notification OutlineWidth value     ( Change outline width )
     *   -> Notification ResetParameters        ( Reset all parameters )
     * Script call:
     *   -> this.newNotif(text)                 ( Draw a custom text )
    */
    //#=============================================================================
    
    (function() {
    /*-------------------------------------------------------------------------
    * Get Parameters
    -------------------------------------------------------------------------*/
    var parameters = PluginManager.parameters('LeNotifications');
    var pBgColor = String(parameters['Background Color'] || '#000000');
    var pTextColor = String(parameters['Text Color'] || '#FFFFFF');
    var pFontSize = Number(parameters['Font Size'] || 18);
    var pFontItalic = ((parameters['Font Italic ?'] || 'false') === 'true');
    var pTextOutlineColor = String(parameters['Text Outline Color'] || '#');
    var pTextOutlineWidth = Number(parameters['Text Outline Width'] || 0);
    var pOpacity = Number(parameters['Opacity'] || 180);
    var pPos = String(parameters['Position'] || 'top-left');
    var pXPadding = Number(parameters['Left-Right Padding'] || 4);
    var pYPadding = Number(parameters['Up-Down Padding'] || 4);
    var pMoveSpeed = Number(parameters['Move Speed'] || 6);
    var pFadeSpeed = Number(parameters['Fade Speed'] || 6);
    var pLifeTime = Number(parameters['Life Time'] || 200);
    var pLifeTimeAuto = eval(((parameters['Life Time Auto ?'] || 'true') === 'true'));
    var pSoundFile = String(parameters['Sound Filename'] || 'Book1');
    var pMaxNotifs = Number(parameters['Maximum Notifs'] || 4);
    
    var pNotifGainGold = String(parameters['Notif Gain Gold'] || 'Gold: +[value]');
    var pNotifLoseGold = String(parameters['Notif Lose Gold'] || 'Gold: -[value]');
    
    var pNotifGainItem = String(parameters['Notif Gain Item'] || 'Obtained [name] x[amount]');
    var pNotifLoseItem = String(parameters['Notif Lose Item'] || 'Lost [name] x[amount]');
    
    var pNotifGainExp = String(parameters['Notif Gain Exp'] || '[name]: +[value] Exp');
    var pNotifLoseExp = String(parameters['Notif Lose Exp'] || '[name]: -[value] Exp');
    
    var pNotifLevelUp = String(parameters['Notif LevelUp'] || '[name]: level up !');
    var pNotifLevelDown = String(parameters['Notif LevelDown'] || '[name]: level down !');
    
    var pNotifSkillLearnt = String(parameters['Notif Skill Learnt'] || "[name]: learned '[value]'!");
    var pNotifSkillForgot = String(parameters['Notif Skill Forgot'] || "[name]: forgot '[value]'!");
    
    var pNotifBgm = String(parameters['Notif BGM'] || "Playing '[name].'  [caption]");
    var pNotifBgs = String(parameters['Notif BSE'] || "Playing '[name].'  [caption]");
    var pNotifSe = String(parameters['Notif SE'] || "Playing '[name].'  [caption]");
    var pNotifMe = String(parameters['Notif ME'] || "Playing '[name].'  [caption]");
    
    var pEnableCC = String(parameters['Enable Closed Captioning'] || 'false');
    var pDebugging    = eval(String(parameters['Debug Mode'] || 'false'));
    
    var _ccData = false;
    var request = new XMLHttpRequest();
    request.open('GET', "data/Notif_ClosedCaptions.json");
    request.overrideMimeType('application/json');
    request.onload = function() { _createCC(JSON.parse(request.responseText)); }
    request.onerror = function() { throw new Error('There was an error loading the file ' + url); }
    request.send();
        
    var _createCC = function(data) {
        if (pDebugging) {
            console.log(data);
        }
        _ccData = data;
    };
    
    //=============================================================================
    // Window_Options
    //=============================================================================
    
    var bbs_lenotif_Window_Options_addGeneralOptions =
        Window_Options.prototype.addGeneralOptions;
    Window_Options.prototype.addGeneralOptions = function() {
        bbs_lenotif_Window_Options_addGeneralOptions.call(this);
        this.addCommand('Closed Captioning?', 'closedCaptioning');
    };
    
    //=============================================================================
    // ConfigManager
    //=============================================================================
    
    getDefaultCCOption = function() {
        if (pEnableCC.match(/true/i)) {
          return true;
        } else if (pEnableCC.match(/false/i)) {
          return false;
        } else {
          return Utils.isNwjs();
        }
    };
    
    ConfigManager.closedCaptioning = getDefaultCCOption();
    
    var bbs_lenotif_Configmanager_makeData = ConfigManager.makeData;
    ConfigManager.makeData = function() {
        var config = bbs_lenotif_Configmanager_makeData.call(this);
        config.closedCaptioning = this.closedCaptioning;
        return config;
    };
    
    var bbs_lenotif_Configmanager_applyData = ConfigManager.applyData;
    ConfigManager.applyData = function(config) {
        bbs_lenotif_Configmanager_applyData.call(this, config);
        this.closedCaptioning = this.readConfigCC(config, 'closedCaptioning');
    };
    
    ConfigManager.readConfigCC = function(config, name) {
        var value = config[name];
        if (value !== undefined) {
            return value;
        } else {
            return getDefaultCCOption();
        }
    };
    
    /*-------------------------------------------------------------------------
    * Notification Item Bitmap <- Bitmap
    -------------------------------------------------------------------------*/
    function LeNotifItemBitmap(type,w,h) {
        Bitmap.call(this,w,h);
        //- Set bitmap properties according to type
        this.textColor = pTextColor;
        this.fontSize = pFontSize;
        this.fontItalic = pFontItalic;
        this.outlineColor = pTextOutlineColor;
        this.OutlineWidth = pTextOutlineWidth;
    };
    
    //- Heritage (Bitmap)
    LeNotifItemBitmap.prototype = Object.create(Bitmap.prototype);
    LeNotifItemBitmap.prototype.constructor = LeNotifItemBitmap;
    
    /*-------------------------------------------------------------------------
    * Notification Item <- Sprite
    -------------------------------------------------------------------------*/
    function LeNotifItem(text,type) {
        this.initialize.apply(this, arguments);
    };
    
    //---- Heritage (Sprite)
    LeNotifItem.prototype = Object.create(Sprite.prototype);
    LeNotifItem.prototype.constructor = LeNotifItem;
    
    //---- Initialization
    LeNotifItem.prototype.initialize = function(text,type) {
        Sprite.prototype.initialize.call(this, new LeNotifItemBitmap(type,1,1));
        this.text = text;
        this.type = type;
        this.destX = 0;
        this.destY = 0;
        this.offsetX = 0;
        this.offsetY = 0;
        this.canFade = false;
        this.canDecreaseLifeTime = false;
        this.onScene = false;
        this.dead = false;
        this.msgBoxOffsetOn = false;
        this.lastNodeWindowStatus = false;
        this.setLifeTime();
        this.createBitmap();
        this.iniPosition();
    };
    
    //---- Set Life Time
    LeNotifItem.prototype.setLifeTime = function() {
        if (pLifeTimeAuto) {
            this.lifeTime = this.text.length*12;
        } else {
            this.lifeTime = pLifeTime;
        }
    };
    
    //---- Create Bitmap
    LeNotifItem.prototype.createBitmap = function() {
        var w = this.bitmap.measureTextWidth(this.text);
        w += pXPadding*2;
        var h = this.bitmap.fontSize + pYPadding*2;
        this.bitmap = new LeNotifItemBitmap(this.typpe,w,h);
        this.bitmap.fillAll(pBgColor);
        this.opacity = pOpacity;
        h = this.bitmap.fontSize + 2;
        this.bitmap.drawText(this.text,pXPadding,pYPadding,w,h);
    };
    
    //---- Initialize Position
    LeNotifItem.prototype.iniPosition = function() {
        switch (pPos) {
            case 'top-left':
                this.x = -this.width;
                this.y = 0;
                this.destX = 0;
                this.destY = this.y;
                break;
            case 'bottom-left':
                this.x = -this.width;
                this.y = Graphics.height - this.height;
                this.destX = 0;
                this.destY = this.y;
                break;
            case 'top-right':
                this.x = Graphics.width;
                this.y = 0;
                this.destX = Graphics.width - this.width;
                this.destY = this.y;
                break;
            case 'bottom-right':
                this.x = Graphics.width;
                this.y = Graphics.height - this.height;
                this.destX = Graphics.width - this.width;
                this.destY = this.y;
                break;
        }
    };
    
    //---- Update
    LeNotifItem.prototype.update = function() {
        Sprite.prototype.update.call(this);
        this.updateMove();
        this.updateLifeTime();
        this.updateFade();
    };
    
    //---- Check for offset.
    LeNotifItem.prototype.updateObstacleOffsetXY = function() {
    
        // Only process when a. we have not yet accounted for offset, and b. game message is visible.
        if (this.lastGameMsgStatus != $gameMessage.isBusy() || SceneManager._scene._nodeWindowOpen != this.lastNodeWindowStatus) {
            // Only process when a. we have not yet accounted for offset, and b. game message is visible.       
            if ($gameMessage.isBusy() || SceneManager._scene._nodeWindowOpen === true) {
                
                // Account for different pPos.
                switch (pPos) {
                    case 'top-left':
                        if ($gameMessage.positionType() === 0) {
                            this.offsetY = 200;
                        }
                        break;
                    case 'bottom-left':
                        if ($gameMessage.positionType() === 2) {
                            this.offsetY = -200;
                        }
                        break;
                    case 'top-right':
                        if ($gameMessage.positionType() === 0) {
                            this.offsetY = 200;
                        }
                        break;
                    case 'bottom-right':
                        if ($gameMessage.positionType() === 2) {
                            this.offsetY = -200;
                        }
                        break;
                };
                
                // Cover for Node status window.
                if($gameSwitches.value(742) === true) {
                    this.offsetY = 128;
                }
                
                // Correct Destination values for potential x/y value jump to avoid obscuring dialogue/location window.
                this.x = this.x + this.offsetX;
                this.y = this.y + this.offsetY;
                this.destX = this.destX + this.offsetX;
                this.destY = this.destY + this.offsetY;
                
            }
            else {
                // Correct Destination values for potential x/y value jump to avoid obscuring dialogue/location window.
                this.x = this.x - this.offsetX;
                this.y = this.y - this.offsetY;
                this.destX = this.destX - this.offsetX;
                this.destY = this.destY - this.offsetY;
                this.offsetY = 0;
            }
        }
        
        this.lastNodeWindowStatus = SceneManager._scene._nodeWindowOpen;
        this.lastGameMsgStatus = $gameMessage.isBusy();
    }
    
    
    //---- Update Move
    LeNotifItem.prototype.updateMove = function() {
        
        // Set offset if applicable.
        this.updateObstacleOffsetXY();
        
        if (pDebugging) {
            console.log(this.x);
            console.log(this.y);
            console.log(this.destX);
            console.log(this.destY);
        }
        
        if (this.moveFinished()) {
            return;
        }
        //- Moving x
        if (this.destX > this.x) {
            this.x += pMoveSpeed;
            if (this.x > this.destX) this.x = this.destX;
        } else {
            this.x -= pMoveSpeed;
            if (this.x < this.destX) this.x = this.destX;
        }
        //- Moving y
        if (this.destY > this.y) {
            this.y += pMoveSpeed;
            if (this.y > this.destY) this.y = this.destY;
        } else {
            this.y -= pMoveSpeed;
            if (this.y < this.destY) this.y = this.destY;
        }
        //- Call onMoveFinished
        if (this.moveFinished()) {
            this.onMoveFinished();
        }
    };
    
    //---- Move Finished ?
    LeNotifItem.prototype.moveFinished = function() {
        if (this.x == this.destX && this.y == this.destY) {
            return true;
        } else {
            return false;
        }
    };
    
    //---- When move is finished
    LeNotifItem.prototype.onMoveFinished = function() {
        this.canDecreaseLifeTime = true;
    };
    
    //---- Update life time
    LeNotifItem.prototype.updateLifeTime = function() {
        if (!this.canDecreaseLifeTime) {
            return;
        }
        this.lifeTime -= 1;
        if (this.lifeTime <= 0) {
            this.onDeath();
        }
    };
    
    //---- When dead
    LeNotifItem.prototype.onDeath = function() {
        this.canDecreaseLifeTime = false;
        this.canFade = true;
    };
    
    //---- Update Fade
    LeNotifItem.prototype.updateFade = function() {
        if (!this.canFade) {
            return;
        }
        this.opacity -= pFadeSpeed;
        if (this.opacity <= 0) {
            this.opacity = 0;
            this.canFade = false;
            this.onFadeFinished();
        }
    };
    
    //---- When fade is finished
    LeNotifItem.prototype.onFadeFinished = function() {
        this.visible = false;
        this.dead = true;
    };
    
    //---- Shift Down
    LeNotifItem.prototype.shiftDown = function(y) {
        this.y += y;
        this.destY += y;
    };
    
    
    /*-------------------------------------------------------------------------
    * Notification Manager
    -------------------------------------------------------------------------*/
    function LeNotifManager() {
        throw new Error('This is a static class');
    };
    
    LeNotifManager.allNotifs = new Array();
    LeNotifManager.displayedNotifs = new Array();
    LeNotifManager.enabled = true;
    
    //---- New Notification
    LeNotifManager.add = function(text, type) {
        if (!this.enabled) {
            if (pDebugging) {
                console.log("LeNotif disabled, ignoring add request");
            }
            return;
        }
        
        type = (typeof type !== 'undefined') ? type : "default";
        notif = new LeNotifItem(text,type);
        
        if (this.displayedNotifs.length < pMaxNotifs) {
            this.addDisplayNotif(notif);
        } else {
            this.allNotifs.push(notif);
            this.logNotifs();
        }
    
    };
    
    LeNotifManager.addDisplayNotif = function(notif) {
        // Coordinate positioning only matters for displayed notifs.
        if (pPos == 'top-left' || pPos == 'top-right') {
            this.displayedNotifs.forEach(function(n) {
                n.shiftDown(notif.height);
            });
        } else if (pPos == 'bottom-left' || pPos == 'bottom-right') {
            var y = 0;
            this.displayedNotifs.forEach(function(n) {
                y += n.height;
            });
            notif.shiftDown(-y);
        }
        this.displayedNotifs.push(notif);
        this.logNotifs();
    };
    
    //---- Update
    LeNotifManager.update = function() {
        this.addNotifsToScene();
        this.displayedNotifs.forEach(function(n) {
            n.update;
        });
        this.removeDeadNotifs();
    };
    
    //---- Add notifs to Scene_Map
    LeNotifManager.addNotifsToScene = function() {
        var currNotifs = this.displayedNotifs.length;
        
        this.displayedNotifs.forEach(function(n) {
            if (!n.onScene && SceneManager._scene instanceof Scene_Map) {
                n.onScene = true;
                SceneManager._scene.addChild(n);
                
                //- Play a sound if enabled.
                if (pSoundFile) {
                    var audio = {};
                    audio.name = pSoundFile;
                    audio.pitch = 100;
                    audio.volume = (90 + ConfigManager.seVolume) / 2;
                    audio.pan = 0;
                    
                    // Fix so that LeNotif does not report the sound it plays when adding a notification.
                    var oldNotifStatus = LeNotifManager.enabled;
                    LeNotifManager.enabled = false;
                    
                    // Volume magnification fix when multiple notifs are added at once.
                    audio.volume = audio.volume / currNotifs;
                    AudioManager.playSe(audio);
                    LeNotifManager.enabled = oldNotifStatus;
                }
            }
        });
    };
    
    //---- Remove dead notifs
    LeNotifManager.removeDeadNotifs = function() {
        var toDelete = [];
        this.displayedNotifs.forEach(function(n) {
            if (n.dead) {
                SceneManager._scene.removeChild(n);
                toDelete.push(n);
            }
        });
        
        for(var i = 0; i < toDelete.length; i++){
            var n = toDelete[i];
            var index = this.displayedNotifs.indexOf(n);
            this.compactNotifs(index,n);
            this.displayedNotifs.splice(index,1);
        }
        
        // Push waiting notifs into displayedNotifs while room is available.
        while (this.displayedNotifs.length < pMaxNotifs) {
            if (this.allNotifs.length <= 0) {
                if (pDebugging) {
                    console.log("Nothing to add");
                }
                break;
            }
            
            // Push head to displayed notifs, then pop head.
            var head = this.allNotifs[0];
            this.addDisplayNotif(head);
            this.allNotifs.pop();
        }
        
        this.logNotifs();
    };
    
    //---- Compact notification when some are removed
    LeNotifManager.compactNotifs = function(index,notif) {
        if (pPos == 'top-left' || pPos == 'top-right') {
            this.displayedNotifs.forEach(function(n) {
                if (n.y > notif.y) {
                    n.shiftDown(-notif.height);
                }
            });
        }
        else if (pPos == 'bottom-left' || pPos == 'bottom-right') {
            this.displayedNotifs.forEach(function(n) {
                if (n.y < notif.y) {
                    n.shiftDown(notif.height);
                }
            });
        }
    };
    
    //---- Clear
    LeNotifManager.clear = function() {
        // Only displayedNotifs children of scene.
        this.displayedNotifs.forEach(function(n) {
            SceneManager._scene.removeChild(n);
        });
        
        this.displayedNotifs = [];
        this.allNotifs = [];
    };
    
    //---- Log Notifs
    LeNotifManager.logNotifs = function() {
        if (pDebugging) {
            console.log("Displayed Notifs");
            for (var i=0; i < this.displayedNotifs.length; i++) {
                console.log(this.displayedNotifs[i].text);
            }
                
            console.log("All Notifs");
            for (var j=0; j < this.allNotifs.length; j++) {
                console.log(this.allNotifs[j].text);
            }
        }
    };
    
    /*-------------------------------------------------------------------------
    * Scene_Base
    -------------------------------------------------------------------------*/
    var oldTerminate_SB = Scene_Base.prototype.terminate;
    Scene_Base.prototype.terminate = function() {
        // Prevent array confusion by clearing LeNotifManager during scene changes.
        oldTerminate_SB.call(this);
        LeNotifManager.clear();
    };
    
    /*-------------------------------------------------------------------------
    * Game_Map
    -------------------------------------------------------------------------*/
    //---- Update
    var oldUpdateFunc_GM = Game_Map.prototype.update;
    Game_Map.prototype.update = function(sceneActive) {
        oldUpdateFunc_GM.call(this,sceneActive);
        if (sceneActive) {
            LeNotifManager.update();
        }
    };
    
    
    /*-------------------------------------------------------------------------
    * Game_Interpreter
    -------------------------------------------------------------------------*/
    //---- Plugin Command
    var old_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        old_pluginCommand.call(this, command, args);
        if (command === 'Notification') {
            switch (args[0]) {
            case 'Clear':
                LeNotifManager.clear();
                break;
            case 'Enable':
                LeNotifManager.enabled = eval(String(args[1]).toLowerCase());
                if (pDebugging) {
                    console.log("LeNotifManager: set enabled = " + LeNotifManager.enabled);
                }
                break;
            case 'Position':
                pPos = String(args[1]);
                break;
            case 'TextColor':
                pTextColor = String(args[1]);
                break;
            case 'FontSize':
                pFontSize = Number(args[1]);
                break;
            case 'FontItalic':
                pFontItalic = eval(String(args[1]).toLowerCase());
                break;
            case 'OutlineColor':
                pTextOutlineColor = String(args[1]);
                break;
            case 'OutlineWidth':
                pTextOutlineWidth = Number(args[1]);
                break;
            case 'ResetParameters':
                pPos = String(parameters['Position'] || 'top-left');
                pTextColor = String(parameters['Text Color'] || '#FFFFFF');
                pFontSize = Number(parameters['Font Size'] || 18);
                pFontItalic = eval(parameters['Font Italic ?'] || 'false');
                pTextOutlineColor = String(parameters['Text Outline Color'] || '#');
                pTextOutlineWidth = Number(parameters['Text Outline Width'] || 0);
                break;
            }
        }
    };
    
    //---- Script Call
    Game_Interpreter.prototype.newNotif = function(text,type) {
        LeNotifManager.add(text,type);
    };
    
    /*-------------------------------------------------------------------------
    * Game_Party
    -------------------------------------------------------------------------*/
    //---- Gain/Lose Gold
    var oldGainGold_method = Game_Party.prototype.gainGold;
    Game_Party.prototype.gainGold = function(amount) {
        oldGainGold_method.call(this,amount);
        
        if (!LeNotifManager.enabled) { return; }
        
        var text = '';
        if (amount > 0) {
            if (pNotifGainGold === 'false') { return; }
            text = pNotifGainGold.replace('[value]',String(amount));
        } else if (amount < 0) {
            if (pNotifLoseGold === 'false') { return; }
            text = pNotifLoseGold.replace('[value]',String(-amount));
        }
        LeNotifManager.add(text,"gold");
    };
    
    //---- Gain/Lose Item
    var oldGainItem_method = Game_Party.prototype.gainItem;
    Game_Party.prototype.gainItem = function(item, amount, includeEquip) {
        oldGainItem_method.call(this,item,amount,includeEquip);
        
        if (!LeNotifManager.enabled) { return; }
        if ( item == undefined || item.name == undefined) {
            return;
        }
        
        var text = '';
        if (amount > 0) {
            if (pNotifGainItem === 'false') { return; }
            text = pNotifGainItem.replace('[amount]',String(amount));
        } else if (amount < 0) {
            if (pNotifLoseItem === 'false') { return; }
            text = pNotifLoseItem.replace('[amount]',String(-amount));
        }
        
        text = text.replace('[name]',item.name);
        LeNotifManager.add(text,"item");
    };
    
    
    /*-------------------------------------------------------------------------
    * Game_Interpreter
    -------------------------------------------------------------------------*/
    //---- Change EXP
    var oldCommand315_method = Game_Interpreter.prototype.command315;
    Game_Interpreter.prototype.command315 = function() {
        oldCommand315_method.call(this);
        var value = this.operateValue(this._params[2], this._params[3], this._params[4]);
        
        if (!LeNotifManager.enabled) { return; }
        
        var text = '';
        if (value > 0) {
            if (pNotifGainExp === 'false') { return true; }
            text = pNotifGainExp.replace('[value]',String(value));
        } else if (value < 0) {
            if (pNotifLoseExp === 'false') { return true; }
            text = pNotifLoseExp.replace('[value]',String(-value));
        }
        
        if(this._params[0] === 0 && this._params[1] === 0) {
            text = text.replace('[name]','Party');
            LeNotifManager.add(text,"exp");
        } else {
            this.iterateActorEx(this._params[0], this._params[1], function(actor) {
                var text_i = text.replace('[name]',actor.name());
                LeNotifManager.add(text_i,"exp");
            }.bind(this));
        }
        return true;
    };
    
    /*-------------------------------------------------------------------------
    * Game_Actor
    -------------------------------------------------------------------------*/
    //---- Level Up
    var oldLevelUp_method = Game_Actor.prototype.levelUp;
    Game_Actor.prototype.levelUp = function() {
        oldLevelUp_method.call(this);
        
        if (!LeNotifManager.enabled) { return; }
        if (pNotifLevelUp === 'false') {
            return;
        }
        
        var text = pNotifLevelUp.replace('[name]',this.name());
        LeNotifManager.add(text,"levelup");
    };
    
    //---- Level Down
    var oldLevelDown_method = Game_Actor.prototype.levelDown;
    Game_Actor.prototype.levelDown = function() {
        oldLevelDown_method.call(this);
        
        if (!LeNotifManager.enabled) { return; }
        if (pNotifLevelDown === 'false') {
            return;
        }
        
        var text = pNotifLevelDown.replace('[name]',this.name());
        LeNotifManager.add(text,"leveldown");
    };
    
    
    //---- Learn Skill
    var oldLearnSkill_method = Game_Actor.prototype.learnSkill;
    Game_Actor.prototype.learnSkill = function(skillId) {
        oldLearnSkill_method.call(this, skillId);
        
        if (!LeNotifManager.enabled) { return; }
        if (pNotifSkillLearnt === 'false') {
            return;
        }
        
        var text = pNotifSkillLearnt.replace('[name]', this.name());
        var text = text.replace('[value]', $dataSkills[skillId].name);
        LeNotifManager.add(text,"skill");
    };
    
    //---- Forget skill
    var oldForgetSkill_method = Game_Actor.prototype.forgetSkill;
    Game_Actor.prototype.forgetSkill = function(skillId) {
        oldForgetSkill_method.call(this, skillId);
        
        if (!LeNotifManager.enabled) { return; }
        if (pNotifSkillForgot === 'false') {
            return;
        }
        
        var text = pNotifSkillForgot.replace('[name]', this.name());
        var text = text.replace('[value]', $dataSkills[skillId].name);
        LeNotifManager.add(text,"skill");
    };
    
    /*-------------------------------------------------------------------------
    * AudioManager
    -------------------------------------------------------------------------*/
    //---- Play BGM
    var oldPlayBgm_method = AudioManager.playBgm;
    AudioManager.playBgm = function(bgm, pos) {
        oldPlayBgm_method.call(this, bgm, pos);
        if (pNotifBgm === 'false' || bgm == undefined || bgm.name == undefined) {
            return;
        }
        
        if (SceneManager._scene instanceof Scene_Map) {
            if (!ConfigManager.closedCaptioning) {
                var text = pNotifBgm.replace('[name]', bgm.name);
                text = text.replace('[caption]', '');
                LeNotifManager.add(text,"bgm");
            }
            else {
                var caption = _ccData[bgm.name];
                if(caption == undefined || caption == null) return;
                var text = pNotifBgm.replace('[name]', bgm.name);
                text = text.replace('[caption]', caption);
                LeNotifManager.add(text,"bgm");
            }
        }
    };
    
    //---- Play BGS
    var oldPlayBgs_method = AudioManager.playBgs;
    AudioManager.playBgs = function(bgs, pos) {
        oldPlayBgs_method.call(this, bgs, pos);
        if (pNotifBgs === 'false' || bgs == undefined || bgs.name == undefined) {
            return;
        }
        
        if (SceneManager._scene instanceof Scene_Map) {
            if (!ConfigManager.closedCaptioning) {
                var text = pNotifBgs.replace('[name]', bgs.name);
                text = text.replace('[caption]', '');
                LeNotifManager.add(text, "bgs");
            }
            else {
                var caption = _ccData[bgs.name];
                if(caption == undefined || caption == null) return;
                var text = pNotifBgs.replace('[name]', bgs.name);
                text = text.replace('[caption]', caption);
                LeNotifManager.add(text,"bgs");
            }
        }
    };
    
    //---- Play ME
    var oldPlayMe_method = AudioManager.playMe;
    AudioManager.playMe = function(me) {
        oldPlayMe_method.call(this, me);
        if (pNotifMe === 'false' || me == undefined || me.name == undefined) {
            return;
        }
        
        if (SceneManager._scene instanceof Scene_Map) {
            if (!ConfigManager.closedCaptioning) {
                var text = pNotifMe.replace('[name]', me.name);
                text = text.replace('[caption]', '');
                LeNotifManager.add(text, "me");
            }
            else {
                var caption = _ccData[me.name];
                if(caption == undefined || caption == null) return;
                var text = pNotifMe.replace('[name]', me.name);
                text = text.replace('[caption]', caption);
                LeNotifManager.add(text, "me");
            }
        }
    };
    
    //---- Play SE
    var oldPlaySe_method = AudioManager.playSe;
    AudioManager.playSe = function(se) {
        oldPlaySe_method.call(this, se);
        if (pNotifSe === 'false' || se == undefined || se.name == undefined) {
            return;
        }
        
        if (SceneManager._scene instanceof Scene_Map) {
            if (!ConfigManager.closedCaptioning) {
                var text = pNotifBgm.replace('[name]', se.name);
                text = text.replace('[caption]', '');
                LeNotifManager.add(text, "se");
            }
            else {
                var caption = _ccData[se.name];
                if(caption == undefined || caption == null) return;
                var text = pNotifSe.replace('[name]', se.name);
                text = text.replace('[caption]', caption);
                LeNotifManager.add(text, "se");
            }
        }
    };
    
    /*-------------------------------------------------------------------------
    * Game_Actor
    -------------------------------------------------------------------------*/
    //---- Change Equipment
    var oldChangeEquip_method = Game_Actor.prototype.changeEquip;
    Game_Actor.prototype.changeEquip = function(slotId, item) {
        var oldNotifStatus = LeNotifManager.enabled;
        
        LeNotifManager.enabled = false;
        oldChangeEquip_method.call(this,slotId,item);
        LeNotifManager.enabled = oldNotifStatus;
    };
    
    //---- Force Change Equipment
    var oldForceChangeEquip_method = Game_Actor.prototype.forceChangeEquip;
    Game_Actor.prototype.forceChangeEquip = function(slotId, item) {
        var oldNotifStatus = LeNotifManager.enabled;
        
        LeNotifManager.enabled = false;
        oldForceChangeEquip_method.call(this,slotId,item);
        LeNotifManager.enabled = oldNotifStatus;
    };
    
    //---- Trade Item with Party
    var oldTradewithParty_method = Game_Actor.prototype.tradeItemWithParty;
    Game_Actor.prototype.tradeItemWithParty = function(newItem, oldItem) {
        var oldNotifStatus = LeNotifManager.enabled;
        
        LeNotifManager.enabled = false;
        var bool = oldTradewithParty_method.call(this,newItem,oldItem);
        LeNotifManager.enabled = oldNotifStatus;
        return bool;
    };
    
    //---- Handle Yanfly's methods
    
    if (Imported.YEP_ItemCore === true) {
    
        var oldInitIndepenEquips_method = Game_Actor.prototype.initIndependentEquips;
        Game_Actor.prototype.initIndependentEquips = function(equips) {
            var oldNotifStatus = LeNotifManager.enabled;
            
            LeNotifManager.enabled = false;
            oldInitIndepenEquips_method.call(this,equips);
            LeNotifManager.enabled = oldNotifStatus;
        };
    
        var oldChangeEquipById_method = Game_Actor.prototype.changeEquipById;
        Game_Actor.prototype.changeEquipById = function(etypeId, itemId) {
            var oldNotifStatus = LeNotifManager.enabled;
            
            LeNotifManager.enabled = false;
            oldChangeEquipById_method.call(this,etypeId,itemId);
            LeNotifManager.enabled = oldNotifStatus;
        };
    
    } //-Yanfly check
    
    })();
    
     
    #62
  3. kako05

    kako05 Veteran Veteran

    Messages:
    96
    Likes Received:
    4
    First Language:
    Australian
    Primarily Uses:
    RMMV
    Notification for equipment not possible?
     
    #63
  4. SoftCloud

    SoftCloud Possibly dead Member

    Messages:
    10
    Likes Received:
    1
    Location:
    U.S.
    First Language:
    English
    Primarily Uses:
    RMMV
    Sorry, quick question. By what means might I set 'no sound'? 'false' (as used with Notif BGM) does not accomplish this.

    Side Note: I used a proximity event to cause state induction via triggering a common event, but until I used this.newNotif("Text"); rather than this.newNotif(text); as indicated in the help file no notification would appear. Not sure if this is a quirk of Common Events but I thought it might be good to bring up.

    This is a brilliant tool and has so many applications. Much appreciated.
     
    #64

Share This Page