//=============================================================================
// SilvStamina.js
// Version: 1.04
//=============================================================================
/*:
 * @plugindesc v1.04 Basic dashing stamina script.
   <SilverStamina>
 * @author Silver
 *
 * @param -- General --
 *
 * @param Show Stamina Window
 * @desc true/false
 * @default true
 *
 * @param -- Positioning & Size --
 *
 * @param Window X
 * @desc X-location of stamina window. If window-alignment is set to Right, this will act as an offset value instead
 * @default 10
 *
 * @param Window Y
 * @desc Y-location of stamina window. If window-alignment is set to Top, this will act as an offset value instead
 * @default 10
 *
 * @param Window Width
 * @desc width of the stamina window
 * @default 170
 *
 * @param Window Height
 * @desc height of the stamina window
 * @default 72
 *
 * @param Window Horizontal Alignment
 * @desc Left/Right
 * @default Left
 *
 * @param Window Vertical Alignment
 * @desc Top/Bottom
 * @default Top
 *
 * @param Stamina Gauge Rectangle
 * @desc The gauge rectangle. Format: x y width height
 * @default 0 -20 132 24
 *
 * @param -- Stamina Pool --
 *
 * @param Stamina Decrease
 * @desc Amount of stamina subtracted per update (use a positive number)
 * @default 1
 *
 * @param Stamina Max
 * @desc Maximum amount of stamina
 * @default 300
 *
 * @param Stamina Recovery Delay
 * @desc delay in update-calls before recovering stamina when not dashing
 * @default 180
 *
 * @param Stamina Recovery Rate
 * @desc How fast stamina is recovered (only when recovering)
 * @default 0.3
 *
 * @param Stamina AutoDash Threshold
 * @desc Do not automatically dash again before stamina is above this threshold (%) when recovering stamina. (0-100)
 * @default 40
 *
 * @param Stamina Regen Formula
 * @desc The formula for how fast to regenerate stamina over longer period of time. "Base" is the recovery rate. Case sensitive!
 * @default base + Math.sqrt(x/50);
 *
 * @param -- Visuals --
 *
 * @param Stamina Gauge Color 1
 * @desc Bar gradient color1 (start of bar) in hex
 * @default #009900
 *
 * @param Stamina Gauge Color 2
 * @desc Bar gradient color2 (end of bar) in hex
 * @default #CC0000
 *
 * @param Draw Stamina Value
 * @desc Draw text in stamina bar? Accepted values: absolute/percentage/both/none
 * @default percentage
 *
 * @param Font Size
 * @desc Size for stamina value
 * @default 20
 *
 * @param Auto Hide Stamina Window
 * @desc Automatically hide the stamina window if it's at max stamina for a specific period of time? true/false
 * @default true
 *
 * @param -- Window Prefix Text--
 *
 * @param Window Text
 * @desc Use :none to disable this
 * @default :none
 *
 * @param Window Text Offset Y
 * @desc y-coordinate for the text
 * @default 19
 *
 * @param Window Text Spacing X
 * @desc amount of room in coordinates between text and gauge
 * @default 4
 *
 * @param -- Window --
 *
 * @param Hide Stamina Window Delay
 * @desc After how many updates the stamina window should hide itself (if it remains at max stamina)
 * @default 160
 *
 * @param Stamina Window Opacity
 * @desc Stamina window opacity. Set to 0 to hide the window (will still show the bar)
 * @default 255
 *
 * @param Window Slideout Direction
 * @desc What direction to slide the stamina window out to. NoSlide/Left/Top/Right/Bottom
 * @default Left
 *
 * @param Window Slideout Speed
 * @desc How fast the window slides in&out
 * @default 2
 *
 * @param -- Advanced --
 *
 * @param Disable Stamina Consumption GameSwitch
 * @desc The gameswitch to use to disable stamina consumption (or -1 to use none). ON = disabled
 * @default -1
 *
 * @param Window Z-Index
 * @desc Window Z-Index. Value must be > 0.
 * @default 1
 *
 * @param Plugin Command Identifier
 * @desc Do not change if you do not know what this is!
 * @default stamina
 *
 * @help
 * -------------------------------------
 * Plugin Commands (not case sensitive):
 * -------------------------------------
 *
 * Stamina Refill
 * Instantly refills all of your stamina.
 *
 * Stamina Set <value>
 * Instantly sets your stamina to the specified percentage (0-100).
 * Example to set your stamina bar to 64: Stamina Set 64
 *
 * Stamina Deplete
 * Instantly sets your stamina to 0.
 *
 * Stamina ShowWindow
 * Shows the stamina window. Does not work if you disabled the stamina window.
 *
 * Stamina HideWindow
 * Hides the stamina window. Does not work if you disabled the stamina window.
 * Also does not work if the stamina is currently regenerating.
 *
 * Stamina RefillHide
 * Instantly refills all of your stamina and also hides the stamina window.
 *
 * Stamina SetMax <value>
 * Sets a new max-stamina value.
 *
 * Stamina IncreaseMax <value>
 * Increases max stamina by the specified value. You can also use negative values.
 *
 * Stamina EnableDashing <true/false>
 * Allows or prohibits dashing on the map.
 * -------------------------------------
 * Map Notetags
 * -------------------------------------
 * <dstam_disable>
 * Prevents stamina consumption on this map. Not that if the "Disable Stamina Consumption GameSwitch"
 * is turned ON then you consume no stamina anyway.
 *
 * <disable_dashing>
 * Prevents dashing on the map (with or without stamina).
 *
 * -------------------------------------
 * Item Notetags (not case sensitive)
 * -------------------------------------
 * <dash_stamina:command (value)>
 * Available commands:
 *  - Add (may have a negative value)
 *  - Refill
 *  - Deplete
 *  - IncreaseMax (may have a negative value)
 * Examples:
 * <dash_stamina:Add 10>
 * <dash_stamina:Add -10>
 * <dash_stamina:Refill>
 * <dash_stamina:Deplete>
 * <dash_stamina:IncreaseMax 1500>
 * Note that those only work from the menu, not from battle
 *
 *--------------------------------------
 * Version History:
 *--------------------------------------
 * v1.04 (03 February 2016)
 * - Fixed a crash when transferring between maps using an autorun event with manual fading in or out (autorun stops execution of other events and some scripts like this one, which caused the crash).
 *
 * v1.03 (01 January 2016)
 * - Used my new coding standards & refactored.
 * - Switched to the Imported variable.
 * - Fixed an accidental duplicate alias.
 * - Fixed a bug in Scene_Map.prototype.updateMain() (which just so happened to cause no side-effects).
 *
 * v1.02 (12 December 2015)
 * - Dashing for the current map can now be entirely disabled with a map-notetag and switched with a plugin command at any time.
 * - Created a simple plugin addon to store the player-stamina in a global game-variable.
 * - Enabled custom text to be drawn in front of the Stamina Window.
 * - New feature: items can replenish, lower, refill and deplete stamina (only in the menu, not in battle).
 *
 * v1.01 (1 December 2015)
 * - Removed strict-mode because... Possible bug in RPG Maker...
 * - Refactored and fixed semicolons and missing var-keywords.
 *
 * v1.00 (26 November 2015)
 * - First release.
 * Alpha (November 2015)
 * - First alpha release.
 *
 */
// Imported
var Imported = Imported || {};
Imported.Silv_DashStamina = 1.04;

// #Parameters
var Silv = Silv || {};
Silv.Parameters = $plugins.filter(function(p) { return p.description.contains('<SilverStamina>'); })[0].parameters;
Silv.DashStamina = Silv.DashStamina || {};
// Non-parameters
Silv.DashStamina.Window = null;
Silv.DashStamina.ScreenIsFading = false;
Silv.DashStamina.DashingDisabled = false;
// General
Silv.DashStamina.ShowWindow = Silv.Parameters['Show Stamina Window'].toLowerCase() === 'true';
// Positioning & Size
Silv.DashStamina.Window_X = parseInt(Silv.Parameters['Window X']);
Silv.DashStamina.Window_Y = parseInt(Silv.Parameters['Window Y']);
Silv.DashStamina.WindowWidth = parseInt(Silv.Parameters['Window Width']);
Silv.DashStamina.WindowHeight = parseInt(Silv.Parameters['Window Height']);
Silv.DashStamina.WindowHorizontalAlignment = (Silv.Parameters['Window Horizontal Alignment']).toLowerCase();
Silv.DashStamina.WindowVerticalAlignment = (Silv.Parameters['Window Vertical Alignment']).toLowerCase();
Silv.DashStamina.StaminaGaugeRectangle = {x: parseInt(Silv.Parameters['Stamina Gauge Rectangle'].split(' ')[0]), y: parseInt(Silv.Parameters['Stamina Gauge Rectangle'].split(' ')[1]), width: parseInt(Silv.Parameters['Stamina Gauge Rectangle'].split(' ')[2]), height: parseInt(Silv.Parameters['Stamina Gauge Rectangle'].split(' ')[3])};
// Stamina Pool
Silv.DashStamina.StaminaDecrease = parseInt(Silv.Parameters['Stamina Decrease']);
Silv.DashStamina.StaminaMax = parseInt(Silv.Parameters['Stamina Max']);
Silv.DashStamina.StaminaRecoveryDelay = parseInt(Silv.Parameters['Stamina Recovery Delay']);
Silv.DashStamina.StaminaRecoveryRate = parseInt(Silv.Parameters['Stamina Recovery Rate']);
Silv.DashStamina.StaminaAutoDashThreshold = parseInt(Silv.Parameters['Stamina AutoDash Threshold']);
Silv.DashStamina.RegenFormula = Silv.Parameters['Stamina Regen Formula'];
// Visuals
Silv.DashStamina.StaminaGaugeColor1 = (Silv.Parameters['Stamina Gauge Color 1']).toUpperCase();
Silv.DashStamina.StaminaGaugeColor2 = (Silv.Parameters['Stamina Gauge Color 2']).toUpperCase();
Silv.DashStamina.DrawStaminaValue = Silv.Parameters['Draw Stamina Value'].toLowerCase();
Silv.DashStamina.FontSize = parseInt(Silv.Parameters['Font Size']);
// Window Prefix Text
Silv.DashStamina.WindowText = Silv.Parameters['Window Text'];
Silv.DashStamina.WindowTextOffsetY = parseInt(Silv.Parameters['Window Text Offset Y']);
Silv.DashStamina.WindowTextGaugeSpacingX = parseInt(Silv.Parameters['Window Text Spacing X']);
// Window
Silv.DashStamina.AutoHideStaminaWindow = Silv.Parameters['Auto Hide Stamina Window'].toLowerCase() === 'true';
Silv.DashStamina.HideStaminaWindowDelay = parseInt(Silv.Parameters['Hide Stamina Window Delay']);
Silv.DashStamina.WindowOpacity = parseInt(Silv.Parameters['Stamina Window Opacity']);
Silv.DashStamina.WindowSlideOutDir = Silv.Parameters['Window Slideout Direction'].toLowerCase();
Silv.DashStamina.WindowSlideOutSpeed = parseFloat(Silv.Parameters['Window Slideout Speed']);
// Advanced
Silv.DashStamina.DisableGameSwitch = parseInt(Silv.Parameters['Disable Stamina Consumption GameSwitch']);
Silv.DashStamina.Window_Z = parseInt(Silv.Parameters['Window Z-Index']);
Silv.DashStamina.PluginCmdId = Silv.Parameters['Plugin Command Identifier'];

// Alias
Silv.Alias = Silv.Alias || {};
if (!Silv.AddAlias)
{
    Silv.AddAlias = function(alias, original_method)
    {
        if (Silv.Alias[alias]) { throw new Error('Alias already exists: ' + alias); }
        Silv.Alias[alias] = original_method;
    };
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(function()
{
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Utilities
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Usage: alert( hexToRgb("#0033ff").g ); // "51";
function hexToRgb(hex)
{
    var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
    return result ? {
        r: parseInt(result[1], 16),
        g: parseInt(result[2], 16),
        b: parseInt(result[3], 16)
    } : null;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Game Player
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Game_Player.prototype.hasStaminaConsumption = function()
{
    if ($gameSwitches.value(Silv.DashStamina.DisableGameSwitch)) { return false; }
    if (!this.mapConsumeStamina) { return false; }
    return true;
};

// #Update stamina amount
Game_Player.prototype.updateStamina = function()
{
    this.isConsumingStamina = (this.isDashing() && this.isMoving() && this.hasStaminaConsumption());
    if (this.isConsumingStamina)
    {
        this.dashStamina -= Silv.DashStamina.StaminaDecrease;
        if (this.dashStamina < 0) { this.dashStamina = 0; }
        this.isRecoveringStamina = false;
        if (Silv.DashStamina.ShowWindow && !Silv.DashStamina.ScreenIsFading) { Silv.DashStamina.Window.showMe(); }
    }
    else // not currently consuming stamina
    {
        if (this.isRecoveringStamina)
        {
            this.staminaRecoveryTimeCnt++;
            if (this.dashStamina < this.dashStaminaMax) // Recover the stamina
            {
                // Recover stamina
                this.dashStamina += this.calculateStaminaRegen(Silv.DashStamina.StaminaRecoveryRate);
                if (this.dashStamina > this.dashStaminaMax) { this.dashStamina = this.dashStaminaMax; }

                if (Silv.DashStamina.ShowWindow && !Silv.DashStamina.ScreenIsFading) { Silv.DashStamina.Window.showMe(); }
            }
            else // Already at max stamina, find out when to hide the window if applicable and do so if possible
            {
                // If the stamina window is used, attempt to autohide it if applicable
                if (Silv.DashStamina.ShowWindow && Silv.DashStamina.AutoHideStaminaWindow)
                {
                    this.hideStaminaWindowDelayCnt += 1;
                    if (this.hideStaminaWindowDelayCnt >= Silv.DashStamina.HideStaminaWindowDelay)
                    {
                        Silv.DashStamina.Window.hideMe();
                        this.hideStaminaWindowDelayCnt = 0;
                    }
                }

            }
        }
        else // not currently recovering stamina, so find out when to start recovering it and do so if required
        {
            this.staminaRecoveryTimeCnt = 0;
            this.staminaRecoveryDelayCnt += 1;
            if (this.staminaRecoveryDelayCnt >= Silv.DashStamina.StaminaRecoveryDelay)
            {
                this.staminaRecoveryDelayCnt = 0;
                this.isRecoveringStamina = true;
            }
        }
    }

    // Stamina Percentage
    this.dashStaminaPerc = this.dashStamina / parseFloat(this.dashStaminaMax);

    // Threshold
    if (!this.isConsumingStamina)
    {
        this.requiresThresholdAmount = this.dashStaminaPerc * 100 < Silv.DashStamina.StaminaAutoDashThreshold;
    }
};

Game_Player.prototype.calculateStaminaRegen = function()
{
    var base = Silv.DashStamina.StaminaRecoveryRate;
    var x = this.staminaRecoveryTimeCnt;
    return eval(Silv.DashStamina.RegenFormula);
};

// #Initialize
Silv.AddAlias('dashStamina_Game_Player_initialize', Game_Player.prototype.initialize);
Game_Player.prototype.initialize = function()
{
    Silv.Alias.dashStamina_Game_Player_initialize.apply(this, arguments);

    this.dashStamina = this.dashStaminaMax = Silv.DashStamina.StaminaMax;
    this.staminaRecoveryDelayCnt = 0; // counter for when to start recovering stamina
    this.staminaRecoveryTimeCnt = 0; // counter for how long the player has been recovering stamina (in frames)
    this.isRecoveringStamina = false;
    this.dashStaminaPerc = 1.0;
    this.hideStaminaWindowDelayCnt = 0;
    this.isConsumingStamina = false;
    this.requiresThresholdAmount = false;
    this.wasDashing = false;
};

Game_Player.prototype.dashingAllowed = function()
{
    if (this.dashStamina === 0 ||
       (!this.wasDashing && this.requiresThresholdAmount)) // Do not allow to dash if the player was not dashing the previous frame AND if the threshold was passed.
    {
        return false;
    }

    return true;
};

Silv.AddAlias('dashStamina_Game_Player_updateDashing', Game_Player.prototype.updateDashing);
Game_Player.prototype.updateDashing = function()
{
    Silv.Alias.dashStamina_Game_Player_updateDashing.apply(this, arguments);

    if (Silv.DashStamina.DashingDisabled)
    {
        this._dashing = false;
        return;
    }

    if (!this.dashingAllowed()) { this._dashing = false; }
    this.wasDashing = this._dashing;
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Game Screen
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Do not just show the minimap on top of a faded-out screen.
Silv.AddAlias('dashStamina_Game_Screen_updateFadeOut', Game_Screen.prototype.updateFadeOut);
Game_Screen.prototype.updateFadeOut = function()
{
    Silv.Alias.dashStamina_Game_Screen_updateFadeOut.apply(this, arguments);

    if (this._brightness < 255) // (this._fadeOutDuration > 0)
    {
        if (Silv.DashStamina.Window !== null) { Silv.DashStamina.Window.visible = false; }
        Silv.DashStamina.ScreenIsFading = true;
    }
    else
    {
        Silv.DashStamina.ScreenIsFading = false;
    }
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Scene Base
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Silv.AddAlias('dashStamina_Scene_Base_startFadeIn', Scene_Base.prototype.startFadeIn);
Scene_Base.prototype.startFadeIn = function()
{
    Silv.Alias.dashStamina_Scene_Base_startFadeIn.apply(this, arguments);
    if (Silv.DashStamina.Window !== null) { Silv.DashStamina.Window.visible = false; }
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Scene Map
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Hook into the main loop
Silv.AddAlias('dashStamina_Scene_Map_updateMain', Scene_Map.prototype.updateMain);
Scene_Map.prototype.updateMain = function()
{
    Silv.Alias.dashStamina_Scene_Map_updateMain.apply(this, arguments);
    $gamePlayer.updateStamina();
    if (Silv.DashStamina.ShowWindow) { Silv.DashStamina.Window.update(); }
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Game Map
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Disable Dashing?
Silv.AddAlias('dashStamina_Game_Map_setup', Game_Map.prototype.setup);
Game_Map.prototype.setup = function(mapId)
{
    Silv.Alias.dashStamina_Game_Map_setup.apply(this, arguments);
    Silv.DashStamina.DashingDisabled = ('disable_dashing' in $dataMap.meta);
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Stamina Regen/Deplete #Items
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Silv.AddAlias('dashStamina_Scene_ItemBase_useItem', Scene_ItemBase.prototype.useItem);
Scene_ItemBase.prototype.useItem = function()
{
    var item = this.item();
    if ('dash_stamina' in item.meta)
    {
        var args = item.meta.dash_stamina.split(' ');
        switch(args[0].toLowerCase())
        {
            case 'add':
                if (args.length < 2) { throw 'Item-add-command is missing the value-argument.'; }
                $gamePlayer.dashStamina += parseInt(args[1]);
                if ($gamePlayer.dashStamina > $gamePlayer.dashStaminaMax) { $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax; }
                else if ($gamePlayer.dashStamina < 0) { $gamePlayer.dashStamina = 0; }
                break;
            case 'refill':
                $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax;
                break;
            case 'deplete':
                $gamePlayer.dashStamina = 0;
                break;
            case 'increasemax':
                if (args.length < 2) { throw 'Item-increasemax-command is missing the value-argument.'; }
                $gamePlayer.dashStaminaMax += parseInt(args[1]);
                if ($gamePlayer.dashStaminaMax < 1 ) { $gamePlayer.dashStaminaMax = 1; }
                break;
            default:
                throw 'Unknown dash_stamina itemnotetag: ' + item.meta;
        }

    }

    Silv.Alias.dashStamina_Scene_ItemBase_useItem.apply(this, arguments);
};

Silv.AddAlias('dashStamina_Game_Action_testApply', Game_Action.prototype.testApply);
Game_Action.prototype.testApply = function(target)
{
    if ('dash_stamina' in this.item().meta)
    {
        return true;
    }
    else
    {
        return Silv.Alias.dashStamina_Game_Action_testApply.apply(this, arguments);
    }
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DashStamina #Window
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function Window_DashStamina() { this.initialize.apply(this, arguments); }
Window_DashStamina.prototype = Object.create(Window_Base.prototype);
Window_DashStamina.prototype.constructor = Window_DashStamina;
// Font Size
Window_DashStamina.prototype.standardFontSize = function() { return Silv.DashStamina.FontSize; };

// #Initialize
Window_DashStamina.prototype.initialize = function(x, y, width, height)
{
    Window_Base.prototype.initialize.call(this, x, y, width, height);
    this._helpWindow = null;
    this._handlers = {};
    this._touching = false;
    this.deactivate();

    this.opacity = Silv.DashStamina.WindowOpacity;
    this.slideDirection = {x: 0, y: 0 };
    this.originalWinLoc = {x: 0, y: 0 };
    this.sliding = 'none';
    this.isFullySlidedOut = false;
    this.isFullySlidedIn = true;
    this.originalWinLoc.x = x; // for some reason "this." is not allowed here
    this.originalWinLoc.y = y; // for some reason "this." is not allowed here

    if (Silv.DashStamina.WindowText != ':none')
    {
        this.windowText = Silv.DashStamina.WindowText;
        this.windowTextWidth = this.contents.measureTextWidth(this.windowText);
        this.windowTextGaugeSpacingX = Silv.DashStamina.WindowTextGaugeSpacingX;
    }
    else
    {
        this.windowText = null;
        this.windowTextWidth = 0;
        this.windowTextGaugeSpacingX = Silv.DashStamina.WindowTextGaugeSpacingX;
    }

    this.update();
};

// Update
Window_DashStamina.prototype.update = function()
{
    if (Silv.DashStamina.ScreenIsFading)
    {
        this.visible = false;
    }
    else
    {
        Window_Base.prototype.update.call(this);
        this.drawStaminaWindow(0, 0, Silv.DashStamina.StaminaGaugeRectangle.width);
        this.updateSliding();
    }
};

//----------------------------------------------------------------------------------------------------
// #Drawing
//----------------------------------------------------------------------------------------------------
Window_DashStamina.prototype.drawStaminaGauge = function(x, y, width, height, rate)
{
    var fillW = Math.floor(width * rate);
    var gaugeY = y + this.lineHeight() - 8;
    this.contents.fillRect(x, gaugeY, width, height, this.gaugeBackColor());
    this.contents.fillRect(x, gaugeY, fillW, height, this.CalculateBarColour());
};

Window_DashStamina.prototype.drawStaminaWindow = function(x, y, width)
{
    this.contents.clear();

    // Draw text before the gauge
    if (this.windowText !== null)
    {
        this.contents.drawText(this.windowText, 0, Silv.DashStamina.WindowTextOffsetY, this.windowTextWidth, 0);
    }

    // Draw gauge
    this.drawStaminaGauge(Silv.DashStamina.StaminaGaugeRectangle.x + this.windowTextWidth + this.windowTextGaugeSpacingX, Silv.DashStamina.StaminaGaugeRectangle.y, Silv.DashStamina.StaminaGaugeRectangle.width, Silv.DashStamina.StaminaGaugeRectangle.height, $gamePlayer.dashStaminaPerc);
    // Draw text on top of the gauge
    var text;
    switch(Silv.DashStamina.DrawStaminaValue) // allowed values: absolute/percentage/both/none
    {
        case 'absolute':
            text = parseInt($gamePlayer.dashStamina) + '/' + parseInt($gamePlayer.dashStaminaMax);
            break;
        case 'percentage':
            text = Math.round($gamePlayer.dashStaminaPerc * 100) + '%';
            break;
        case 'both':
            text = parseInt($gamePlayer.dashStamina) + '/' + parseInt($gamePlayer.dashStaminaMax) + ' (' + Math.round($gamePlayer.dashStaminaPerc * 100) + '%)';
            break;
        case 'none':
            return;
        default:
            throw 'ERROR: drawStaminaWindow missing case-statement or incorrect Silv.DashStamina.DrawStaminaValue value. Value: ' + Silv.DashStamina.DrawStaminaValue;
    }

    this.resetTextColor();
    this.drawText(text, x + this.windowTextWidth + this.windowTextGaugeSpacingX, y + 1, width, 'center');
};

// Calculate what colour the gauge should be between the two colors depending on the percentage value of the current-stamina value.
Window_DashStamina.prototype.CalculateBarColour = function()
{
    var c1 = hexToRgb(Silv.DashStamina.StaminaGaugeColor1);
    var c2 = hexToRgb(Silv.DashStamina.StaminaGaugeColor2);

    var ratio = $gamePlayer.dashStaminaPerc;
    var hex = function(x) {
        x = x.toString(16);
        return (x.length === 1) ? '0' + x : x;
    };

    var r = Math.ceil(c1.r * ratio + c2.r * (1-ratio));
    var g = Math.ceil(c1.g * ratio + c2.g * (1-ratio));
    var b = Math.ceil(c1.b * ratio + c2.b * (1-ratio));

    var middle = '#' + hex(r) + hex(g) + hex(b);
    return middle;
};

//----------------------------------------------------------------------------------------------------
// #Show & #Hide
//----------------------------------------------------------------------------------------------------
Window_DashStamina.prototype.showMe = function()
{
    //if (this.visible) { return; };
    if (this.isFullySlidedIn)
    {
        this.visible = true;
        return;
    }

    if (Silv.DashStamina.WindowSlideOutDir === 'noslide' || this.visible === false) { this.visible = true; }
    else
    {
        this.sliding = 'in';
        switch (Silv.DashStamina.WindowSlideOutDir)
        {
            case 'top':
                this.slideDirection.x = 0;
                this.slideDirection.y = 1;
                break;
            case 'left':
                this.slideDirection.x = 1;
                this.slideDirection.y = 0;
                break;
            case 'right':
                this.slideDirection.x = -1;
                this.slideDirection.y = 0;
                break;
            case 'bottom':
                this.slideDirection.x = 0;
                this.slideDirection.y = -1;
                break;
            default:
                throw 'Window_DashStamina.prototype.HideMe: Unknown switch value: ' + Silv.DashStamina.WindowSlideOutDir;
        }
    }
};

Window_DashStamina.prototype.hideMe = function()
{
    if (!this.visible || this.isFullySlidedOut) { return; }

    if (Silv.DashStamina.WindowSlideOutDir === 'noslide') { this.visible = false; }
    else
    {
        this.sliding = 'out';
        switch (Silv.DashStamina.WindowSlideOutDir)
        {
            case 'top':
                this.slideDirection.x = 0;
                this.slideDirection.y = -1;
                break;
            case 'left':
                this.slideDirection.x = -1;
                this.slideDirection.y = 0;
                break;
            case 'right':
                this.slideDirection.x = 1;
                this.slideDirection.y = 0;
                break;
            case 'bottom':
                this.slideDirection.x = 0;
                this.slideDirection.y = 1;
                break;
            default:
                throw 'Window_DashStamina.prototype.HideMe: Unknown switch value: ' + Silv.DashStamina.WindowSlideOutDir;
        }
    }
};

//----------------------------------------------------------------------------------------------------
// #Sliding of the Window
//----------------------------------------------------------------------------------------------------
Window_DashStamina.prototype.handleSlidingEnd = function()
{
    if (this.sliding === 'in')
    {
        // Stop sliding in
        if (this.slideDirection.x  === 1 && this.x > this.originalWinLoc.x ||
            this.slideDirection.x  === -1 && this.x < this.originalWinLoc.x ||
            this.slideDirection.y  === 1 && this.y > this.originalWinLoc.y ||
            this.slideDirection.y  === -1 && this.y < this.originalWinLoc.y)
        {
            this.sliding = 'none';
            this.isFullySlidedIn = true;
        }
    }
    else
    {
        // Stop sliding out
        if (this.x < -this.width || this.x > Graphics._width + this.width ||
            this.y < -this.height || this.x > Graphics._height + this.height)
        {
            this.sliding = 'none';
            this.isFullySlidedOut = true;
        }
    }
};

Window_DashStamina.prototype.updateSliding = function()
{
    if (this.sliding === 'none') { return; }
    this.x += this.slideDirection.x * Silv.DashStamina.WindowSlideOutSpeed;
    this.y += this.slideDirection.y * Silv.DashStamina.WindowSlideOutSpeed;

    this.isFullySlidedOut = false;
    this.isFullySlidedIn = false;

    this.handleSlidingEnd();
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// #Create Stamina Window
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Scene_Map.prototype.createDashWindow = function()
{
    // Dispose the old window, if any
    if (Silv.DashStamina.Window !== null) { this.removeWindow(Silv.DashStamina.Window); }

    // Does the map consume stamina?
    $gamePlayer.mapConsumeStamina = !('dstam_disable' in $dataMap.meta);
    if(Silv.DashStamina.ShowWindow)
    {
        var x = 0;
        if (Silv.DashStamina.WindowHorizontalAlignment === 'right') { x = Graphics.width - Silv.DashStamina.WindowWidth; }
        var y = 0;
        if (Silv.DashStamina.WindowVerticalAlignment === 'bottom') { y = Graphics.height - Silv.DashStamina.WindowHeight; }

        Silv.DashStamina.Window = new Window_DashStamina(x + Silv.DashStamina.Window_X, y + Silv.DashStamina.Window_Y, Silv.DashStamina.WindowWidth, Silv.DashStamina.WindowHeight);

        this.addChild(Silv.DashStamina.Window, Silv.DashStamina.Window_Z);
        if (Silv.DashStamina.AutoHideStaminaWindow) { Silv.DashStamina.Window.visible = false; }
    }
};

// Omg why does RPG Maker not have this method by default...
Scene_Base.prototype.removeWindow = function(window)
{
    var index = this.children.indexOf(window);
    if (index > -1) { this.children.splice(index, 1); }
};

Silv.AddAlias('dashStamina_Scene_Map_createDisplayObjects', Scene_Map.prototype.createDisplayObjects);
Scene_Map.prototype.createDisplayObjects = function()
{
    Silv.Alias.dashStamina_Scene_Map_createDisplayObjects.apply(this, arguments);
    this.createDashWindow();
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Saving & Loading
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Silv.AddAlias('dashStamina_DataManager_makeSaveContents', DataManager.makeSaveContents);
DataManager.makeSaveContents = function()
{
    contents = Silv.Alias.dashStamina_DataManager_makeSaveContents.apply(this, arguments);
    contents.dashStamina = $gamePlayer.dashStamina;
    contents.dashStaminaMax = $gamePlayer.dashStaminaMax;
    return contents;
};

Silv.AddAlias('dashStamina_DataManager_extractSaveContents', DataManager.extractSaveContents);
DataManager.extractSaveContents = function(contents)
{
    Silv.Alias.dashStamina_DataManager_extractSaveContents.apply(this, arguments);
    $gamePlayer.dashStamina = contents.dashStamina;
    $gamePlayer.dashStaminaMax = contents.dashStaminaMax;
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Plugin Command
// Note: The items are separated by spaces. The command is the first word and any following words are args. args is an array.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Silv.AddAlias('dashStamina_Game_Interpreter_pluginCommand', Game_Interpreter.prototype.pluginCommand);
Game_Interpreter.prototype.pluginCommand = function(command, args)
{
    Silv.Alias.dashStamina_Game_Interpreter_pluginCommand.apply(this, arguments);
    if (command.toLowerCase() === Silv.DashStamina.PluginCmdId) { Silv.DashStamina.PluginCommand(command, args); }
};

Silv.DashStamina.PluginCommand = function(cmd, args)
{
    switch(args[0].toLowerCase())
    {
        case 'refill':
            $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax;
            break;
        case 'deplete':
            $gamePlayer.dashStamina = 0;
            break;
        case 'set':
            var perc = parseInt(args[1]);
            perc = Math.max(0, Math.min(100, perc)); // clamp value between 0-100
            $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax * (perc / 100.0);
        break;
        case 'showwindow':
            if (Silv.DashStamina.Window !== null)
            {
                $gamePlayer.hideStaminaWindowDelayCnt = 0;
                Silv.DashStamina.Window.visible = true;
            }
            break;
        case 'refillhide':
            $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax;
            // NO break-statement here! We want to hide the window as well!
        case 'hidewindow':
            if (Silv.DashStamina.Window !== null)
            {
                $gamePlayer.hideStaminaWindowDelayCnt = Silv.DashStamina.HideStaminaWindowDelay;
                Silv.DashStamina.Window.visible = false;
            }
            break;
        case 'setmax':
            $gamePlayer.dashStaminaMax = Math.max(1, parseInt(args[1]));
            if ($gamePlayer.dashStamina > $gamePlayer.dashStaminaMax) { $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax; }
            break;
        case 'increasemax':
            $gamePlayer.dashStaminaMax += parseInt(args[1]);
            if ($gamePlayer.dashStaminaMax < 1) { $gamePlayer.dashStaminaMax = 1; }
            if ($gamePlayer.dashStamina > $gamePlayer.dashStaminaMax) { $gamePlayer.dashStamina = $gamePlayer.dashStaminaMax; }
            break;
        case 'enabledashing':
            Silv.DashStamina.DashingDisabled = (args[1].toLowerCase() === 'true');
            break;
        default:
            throw 'Stamina PluginCommand invalid command: ' + args[0];
    }
};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
})();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This is the end of this awesome script!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////