Ultima Forum - JS

Przybliżenie Mapy

Sun, 14 Mar 2021 12:15:14 +0100

~ MBS_MapZoom ~

Krótki opis:
Skrypt pozwala na przybliżanie i oddalanie ekranu (mapy). Dodatkowo, można określić które obrazki z folderu "img/pictures" są tym objęte.

Autor:
Masked

Tłumaczenie:
Yoroiookami

Skrypt:

Spoiler: (Otwórz)

Kod:

//=============================================================================

// MBS - Przybliżenie Mapy / Map Zoom (v1.3.5)

//-----------------------------------------------------------------------------

// por Masked

//=============================================================================

//-----------------------------------------------------------------------------

// Specyfikacje pluginu (Nie modyfikować!)

//

/*:

 *

 * @author Masked

 * @plugindesc Umożliwia przybliżanie i oddalanie ekranu.                      

 * 

 * 

 * @help

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

 * Wstęp

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

 * Ten skrypt pozwala na przybliżanie i oddalanie ekranu na mapie

 *

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

 * Sposób użycia

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

 * Można zmienić przybliżenie za pomocą takiego Plugin Command:

 * 

 * MapZoom set x [y [duration n]]

 * 

 * Wystarczy zamienić 'x' oraz 'y' na wybraną wartość przybliżenia (float).

 * Parametr 'y' jest zupełnie opcjonalny, jeżeli nie zostanie użyty, skrypt 

 * założy że 'y' jest równy 'x'.

 * Opcjonalnie można określić czas przybliżenia jako ilość klatek przez 

 * którą ma to trwać.

 * Jeżeli czas trwania przejścia nie zostanie wpisany, skrypt automatycznie 

 * założy, że ma to być 60 klatek.

 * Wartość '2.0' przybliży ekran dwukrotnie, a '0.5' oddali go dwukrotnie.

 * 

 * Przykład:

 * MapZoom set 0.5

 * MapZoom set 2.0 duration 120

 * MapZoom set 2.0 1.5 duration 20

 *

 * Jeżeli przybliżenie ma być skupione na dokładnym punkcie X i Y 

 * lub na zdarzeniu, należy użyć tej komendy:

 * MapZoom center x y

 * MapZoom center event id

 *

 * Przykład:

 * MapZoom center 5 7

 * MapZoom center event 3

 *

 * Aby skupić się na graczu, wystarczy użyć resetu:

 * MapZoom center reset

 *

 * A żeby zresetować przybliżenie, można użyć:

 * MapZoom reset [d]

 *

 * Wystarczy zamienić [d] na ilość klatek.

 * Przykład:

 * MapZoom reset 30

 *

 * Można też przybliżyć wybrane obrazki razem z resztą mapy, 

 * dodając "[Zoom]" do ich nazwy.

 * Przykład:

 * "img/pictures/PrzykładowyObrazek1 [Zoom].png"

 *

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

 * Kredytki / Credits

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

 * - Masked, za stworzenie skryptu.

 * - Yoroiookami, za tłumaczenie.

 *

 * @param Reset przy zmianie mapy

 * @desc Jeżeli przybliżenie nie ma być resetowane przy zmianie mapy, należy 

 * przestawić ten parametr na "false".

 * @default true

 *

 * @param Domyślne przybliżenie

 * @desc Domyślna wartość przybliżenia obejmująca wszystkie mapy.

 * @default 1.0

 *

 */

/*:pt

 */

var Imported = Imported || {};

var MBS = MBS || {};

MBS.MapZoom = {};

"use strict";

(function ($) {

  $.Parameters = $plugins.filter(function(p) {return p.description.contains('');})[0].parameters;

  $.Param = $.Param || {};

  //-----------------------------------------------------------------------------

  // Settings

  //

  // Flag to enable/disable resetting the zoom on map change

  $.Param.resetOnMapChange = ($.Parameters["Reset przy zmianie mapy"].toLowerCase() === "true");

  // Default zoom ratio

  $.Param.defaultZoom = Number($.Parameters["Domyślne przybliżenie"]);

  //-----------------------------------------------------------------------------

  // Game_Map

  //

  // The game map object. Here the main changes for controlling the map zoom were

  // made.

  // Aliases

  var _GameMap_initialize = Game_Map.prototype.initialize;

  var _GameMap_setup = Game_Map.prototype.setup;

  var _GameMap_update = Game_Map.prototype.update;

  // Object initialization. Here the zoom-related variables are created.

  Game_Map.prototype.initialize = function() {

    _GameMap_initialize.call(this);

    this._destZoom = this._destZoom || new PIXI.Point(0, 0);

    this._zoomTime = 0;

    this._zoomDuration = this._zoomDuration || 0;

    this._zoom = this._zoom || new PIXI.Point($.Param.defaultZoom, $.Param.defaultZoom);

    this._zoomCenter = null;

  };

  // Map setup. This will reset the map zoom if 'Reset on map change' is true.

  Game_Map.prototype.setup = function(mapId) {

    _GameMap_setup.call(this, mapId);

    if ($.Param.resetOnMapChange)

        this._zoom = new PIXI.Point($.Param.defaultZoom, $.Param.defaultZoom);

  };

  // Map update. This method controls the gradual zoom when a duration 

  // is specified.

  Game_Map.prototype.update = function () {

      _GameMap_update.apply(this, arguments);

      if (this._zoomDuration > this._zoomTime) {

        this.zoom.x += this._spdZoom.x;

        this.zoom.y += this._spdZoom.y;

        this._zoomTime++;

        this.onZoomChange();

    } else if (this._zoomTime > 0) {

        this._zoomTime = 0;

        this._zoomDuration = 0;

        this._spdZoom = new Point(0, 0);

    }

  };

  /**

   * Sets the game map zoom ratio.

   * @param {Number} x The horizontal zoom ratio

   * @param {Number} y The vertical zoom ratio

   */

  Game_Map.prototype.setZoom = function(x, y, duration) {

      duration = duration || 60;

      duration = Math.round(duration <= 0 ? 1 : duration) * 1.0;

      this._destZoom.x = this._destZoom.y = x;

      if (y) {

          this._destZoom.y = y;

      }

      this._spdZoom = new PIXI.Point((this._destZoom.x - this._zoom.x) / duration, (this._destZoom.y - this._zoom.y) / duration);

      this._zoomDuration = duration;

    this._zoomTime = 0;

  };

  /**

   * Sets the game map zoom origin.

   * @param {mixed} a Either a X coordinate or a Game_Character to center the zoom.

   * @param {Number} (Optional) A Y coordinate to center the zoom.

   */

  Game_Map.prototype.setZoomCenter = function(a, b) {

      if (b) {

          this._zoomCenter = new PIXI.Point(a, b);

      } else if (a) {

          this._zoomCenter = a;

      } else {

          this._zoomCenter = null;

      }

  };

  /**

   * Function called when the map zoom changes.

   */

  Game_Map.prototype.onZoomChange = function() {

    $gamePlayer.center((this._zoomCenter || $gamePlayer)._realX, (this._zoomCenter || $gamePlayer)._realY);

  };

  /**

   * Gets a map coordinate from a screen coordinate.

   * @param {Number} x The screen coordinate

   * @return The X position of the tile below the screen X given.

   */

  Game_Map.prototype.canvasToMapX = function(x) {

    var tileWidth = this.tileWidth() * this.zoom.x;

    var originX = this.displayX() * tileWidth;

    var mapX = Math.floor((originX + x) / tileWidth);

    return this.roundX(mapX);

  };

  /**

   * Gets a map coordinate from a screen coordinate.

   * @param {Number} y The screen coordinate

   * @return The Y position of the tile below the screen Y given.

   */

  Game_Map.prototype.canvasToMapY = function(y) {

    var tileHeight = this.tileHeight() * this.zoom.y;

    var originY = this.displayY() * tileHeight;

    var mapY = Math.floor((originY + y) / tileHeight);

    return this.roundY(mapY);

  };

  // Zoom property

  Game_Map.prototype.__defineGetter__('zoom', function() { return this._zoom; });

  //-----------------------------------------------------------------------------

  // Game_Player

  //

  // Player character class. Changed to fix the screen center/scroll while 

  // zoomming.

  // Alias

  var _GamePlayer_centerX = Game_Player.prototype.centerX;

  var _GamePlayer_centerY = Game_Player.prototype.centerY;

  var _GamePlayer_updateScroll = Game_Player.prototype.updateScroll;

  Game_Player.prototype.centerX = function() {

    return _GamePlayer_centerX.call(this) / $gameMap.zoom.x;

  };

  Game_Player.prototype.centerY = function() {

    return _GamePlayer_centerY.call(this) / $gameMap.zoom.y;

  };

  Game_Player.prototype.updateScroll = function(lastScrolledX, lastScrolledY) {

    if (!$gameMap._zoomCenter || $gameMap._zoomCenter === this) 

        _GamePlayer_updateScroll.apply(this, arguments);

  };

  //-----------------------------------------------------------------------------

  // Game_Event

  //

  // Game events class. Changed it to center the screen into the event when it's 

  // given as the zoomCenter for $gameMap.

  var Game_Event_update = Game_Event.prototype.update;

  // Copies the Game_Player scroll update function into the event class

  Game_Event.prototype.centerX = Game_Player.prototype.centerX;

  Game_Event.prototype.centerY = Game_Player.prototype.centerY;

  Game_Event.prototype.updateScroll = Game_Player.prototype.updateScroll;

  Game_Event.prototype.update = function() {

    var lastScrolledX = this.scrolledX();

    var lastScrolledY = this.scrolledY();

    Game_Event_update.apply(this, arguments);

    if (this === $gameMap._zoomCenter)

        this.updateScroll(lastScrolledX, lastScrolledY);

  };

  //-----------------------------------------------------------------------------

  // Spriteset_Map

  //

  // Map spriteset. This is where the real zooming happens.

  // Alias

  var _SpritesetMap_createLowLayer = Spriteset_Map.prototype.createLowerLayer;

  var _SpritesetMap_update = Spriteset_Map.prototype.update;

  Spriteset_Map.prototype.createLowerLayer = function() {

    _SpritesetMap_createLowLayer.apply(this, arguments);

    $gameMap.setZoom($gameMap.zoom.x, $gameMap.zoom.y, 1);

  };

  Spriteset_Map.prototype.updatePosition = function() {

    var scale = $gameMap.zoom;

    var screen = $gameScreen;

    this.x = Math.round(-$gameMap.zoom.x * (scale.x - 1));

    this.y = Math.round(-$gameMap.zoom.y * (scale.x - 1));

    this.x += Math.round(screen.shake());

    if (this.scale.x !== scale.x || this.scale.y !== scale.y) {

        var destScale = $gameMap._destZoom;

        var sw = Graphics.width / destScale.x + this._tilemap._margin * 2;

        var sh = Graphics.height / destScale.y + this._tilemap._margin * 2;

        if ((this.scale.x > destScale.x || this.scale.y > destScale.y) && !(this.width === sw && this.height === sh)) {

            //var w = $gameMap.width() * $gameMap.tileWidth() + this._tilemap._margin * 2;

            //var h = $gameMap.height() * $gameMap.tileHeight() + this._tilemap._margin * 2;

            var r = sw > this._tilemap.width || sh > this._tilemap.height;

            if (r) {

                this._tilemap.width = sw;//Math.max(w, sw);

                this._tilemap.height = sh;//Math.max(h, sh);

                this._tilemap.refresh();

            }

        }

        this.scale = new PIXI.Point(scale.x, scale.y);

        this._pictureContainer.scale = new PIXI.Point(1.0 / scale.x,  1.0 / scale.y);

        this._weather.scale = new PIXI.Point(1.0 / scale.x,  1.0 / scale.y);

        this._parallax.move(this._parallax.x, this._parallax.y, Graphics.width / scale.x, Graphics.height / scale.y);

    }

  };

  //-----------------------------------------------------------------------------

  // Tilemap

  //

  Tilemap.prototype._createLayers = function() {

    var width = this._width;

    var height = this._height;

    var margin = this._margin;

    var tileCols = Math.ceil(width / this._tileWidth) + 1;

    var tileRows = Math.ceil(height / this._tileHeight) + 1;

    var layerWidth = tileCols * this._tileWidth;

    var layerHeight = tileRows * this._tileHeight;

    if (this._lowerBitmap) {

        this._lowerBitmap.clear();

        this._lowerBitmap.resize(layerWidth, layerHeight);

    } else

        this._lowerBitmap = new Bitmap(layerWidth, layerHeight);

    if (this._upperBitmap) {

        this._upperBitmap.clear();

        this._upperBitmap.resize(layerWidth, layerHeight);

    }

    else

        this._upperBitmap = new Bitmap(layerWidth, layerHeight);

    this._layerWidth = layerWidth;

    this._layerHeight = layerHeight;

    this._lowerLayer = this._lowerLayer || new Sprite();

    this._lowerLayer.removeChildren();

    this._lowerLayer.move(-margin, -margin, width, height);

    this._lowerLayer.z = 0;

    this._upperLayer = this._upperLayer || new Sprite();

    this._upperLayer.removeChildren();

    this._upperLayer.move(-margin, -margin, width, height);

    this._upperLayer.z = 4;

    for (var i = 0; i < 4; i++) {

        this._lowerLayer.addChild(new Sprite(this._lowerBitmap));

        this._upperLayer.addChild(new Sprite(this._upperBitmap));

    }

    this.addChild(this._lowerLayer);

    this.addChild(this._upperLayer);

  };

  //-----------------------------------------------------------------------------

  // Game_Picture

  //

  // Game pictures object. Changed to apply zoom on images marked with [Zoom].

  var _GamePicture_update = Game_Picture.prototype.update;

  Game_Picture.prototype.update = function() {

      _GamePicture_update.apply(this, arguments)

      if (this.mapZoom()) this.updateZoom();

  };

  Game_Picture.prototype.updateZoom = function() {

    if (this._duration > 0) {

      var d = this._duration;

      this._scaleX = (this._scaleX  * (d - 1) + this._targetScaleX)  / d * $gameMap.zoom.x;

      this._scaleY = (this._scaleX  * (d - 1) + this._targetScaleX)  / d * $gameMap.zoom.y;

    } else {

        this._scaleX = this._targetScaleX * $gameMap.zoom.x;

        this._scaleY = this._targetScaleY * $gameMap.zoom.y;

    }

  };

  Game_Picture.prototype.mapZoom = function() {

    return !!this.name().match(/\[zoom\]/i);

  };

  //-----------------------------------------------------------------------------

  // Game_Map

  //

  Game_Map.prototype.screenTileX = function() {

    return Graphics.width / this.tileWidth() / $gameMap.zoom.x;

  };

  Game_Map.prototype.screenTileY = function() {

    return Graphics.height / this.tileHeight() / $gameMap.zoom.y;

  };

  //-----------------------------------------------------------------------------

  // Plugin command

  //

  // Alias

  var _GameInterpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;

  Game_Interpreter.prototype.pluginCommand = function (command, args) {

      _GameInterpreter_pluginCommand.call(this, command, args);

      if (command == "MapZoom") {

        if (args[0] == "set") {

            if (args[1]) {

              if (args[2]) {

                  if (args[2] == "duration") {

                      if (args[3]) {

                          $gameMap.setZoom(Number(args[1]) * $.Param.defaultZoom, Number(args[1]) * $.Param.defaultZoom, Number(args[3]));

                      }

                  } else {

                      if (args[3] == "duration") {

                          if (args[4]) {

                              $gameMap.setZoom(Number(args[1]) * $.Param.defaultZoom, Number(args[2]) * $.Param.defaultZoom, Number(args[4]));

                          }

                      } else {

                          $gameMap.setZoom(Number(args[1]) * $.Param.defaultZoom, Number(args[2]) * $.Param.defaultZoom);

                      }

                  }

              } else {

                  $gameMap.setZoom(Number(args[1]));

              }

            }

        } else if (args[0] == "reset") {

            if (args[1]) {

                $gameMap.setZoom($.Param.defaultZoom, $.Param.defaultZoom, Number(args[1]));

            } else {

                $gameMap.setZoom($.Param.defaultZoom);

            }

        $gameMap.setZoomCenter();

        } else if (args[0] == "center") {

            if (args[1] == "event") {

                var ev = $gameMap.event(Number(args[2]));

                if (ev)

                    $gameMap.setZoomCenter(ev);

            } else if (args[1] == "reset") {

                $gameMap.setZoomCenter();

            } else {

                $gameMap.setZoomCenter(Number(args[1]), Number(args[2]));

            }

        $gameMap.setZoom($gameMap._destZoom.x, $gameMap._destZoom.y, $gameMap._zoomDuration - $gameMap._spdZoom);

        }

      }

  };

})(MBS.MapZoom);

if (Imported["MVCommons"]) {

  PluginManager.register("MBS_MapZoom", 1.3, "Makes it possible to zoom in and out the game map whenever you want", {  

      email: "masked.rpg@gmail.com",

      name: "Masked", 

      website: "N/A"

    }, "2016-07-26");

}

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w postaci pliku .js należy umieścić w folderze gry js/plugins.

MBS_MapZoom.js (Rozmiar: 15.82 KB / Pobrań: 1)

Niezależna Zmiana Rozdzielczości i Rozmiaru Okna Gry

Mon, 24 Aug 2020 20:57:30 +0200

~ Resolution Changer by B.N.F ~

Krótki opis:
Względnie prosty skrypt na zmianę rozdzielczości jak i rozmiaru okna gry, niezależnie od siebie. Oznacza to że pozwala na przeskalowanie rozdzielczości gry, tak by pasowała do rozmiaru okna. Możliwe jest zarówno przeskalowanie w dół jak i górę, na co niestety nie pozwala domyślna zmiana rozdzielczości w ustawieniach RM MZ.
Najkrócej rzecz ujmując, skrypt pozwala na stworzenie gry w okienku o rozmiarach np Full HD (1920x1080), ale np o rozdzielczości gry 896x504. dzięki czemu postacie są nadal duże i widoczny jest tylko nieznaczna część mapy. Kiedy przy domyślnych ustawieniach rozdzielczości na np 1920x1080 w samym programie, uzyskuje się maluteńkie postaci i ogromną przestrzeń mapy widoczną przez cały czas. Ciekawe porównanie w screenach poniżej.

Autor:
B.N.F

Tłumaczenie:
(B.N.F ?) Plugin domyślnie jest po polsku

Skrypt:

Spoiler: (Otwórz)

Kod:

//=============================================================================

// RPG Maker MZ - Resolution Changer by B.N.F

//=============================================================================

/*:

 * @target MZ

 * @plugindesc Możliwość zmiany rozdzielczości i okna gry

 * @author B.N.F

 *

 * @param OknoX

 * @desc Wpisz dowolną szerokość okna gry w pixelach

 * @default 816

 *

 * @param OknoY

 * @desc Wpisz dowolną wysokość okna gry w pixelach

 * @default 624

 *

 * @param RozdzielczoscX

 * @desc Wpisz dowolną szerokość rozdzielczości gry w pixelach

 * @default 816

 *

 * @param RozdzielczoscY

 * @desc Wpisz dowolną wysokość rozdzielczości gry w pixelach

 * @default 624

 *

 * @help --------------------------------------------

 * INFORMACJA

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

 * 

 * Ten prosty plugin pozwala zmienić rozmiar okna oraz rozdzielczość gry.

 *

 * Nie zapewnia żadnych komend do użytku.

 */

 (function () {

    var parameters = PluginManager.parameters('BNF-Resolution');

    var SzerokoscOkna = Number(parameters['OknoX']);

    var WysokoscOkna = Number(parameters['OknoY']);

    var SzerokoscGry = Number(parameters['RozdzielczoscX']);

    var WysokoscGry = Number(parameters['RozdzielczoscY']);

        Scene_Boot.prototype.adjustWindow = function() {

            if (Utils.isNwjs()) {

            const xDelta = SzerokoscOkna - window.innerWidth;

            const yDelta = WysokoscOkna - window.innerHeight;

            window.moveBy(-xDelta / 2, -yDelta / 2);

            window.resizeBy(xDelta, yDelta);

        }};

        Scene_Boot.prototype.resizeScreen = function() {

            const screenWidth = SzerokoscGry;

            const screenHeight = WysokoscGry;

            Graphics.resize(screenWidth, screenHeight);

            this.adjustBoxSize();

            this.adjustWindow();

        };

 })();

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt nie będzie kompatybilny z żadnym innym skryptem na zmianę rozdzielczości czy wielkości okna gry (W chwili pisania tego postu, o ile mi wiadomo żaden taki skrypt nie istnieje) w celu prawidłowego działania zalecane jest ustawienie skryptu jako pierwszego w kolejności.

Skrypt nie jest kompatybilny z RM MV

BNF-Resolution.js (Rozmiar: 1.89 KB / Pobrań: 0)

Niewstrzymanie Ruchu

Tue, 14 Jul 2020 23:54:32 +0200

~ KeepMoving ~

Krótki opis:
Skrypt umożliwia interakcję ze zdarzeniami podczas ich poruszania się. Takie zdarzenia nie przestaną się poruszać i nie obrócą się w naszym kierunku, tylko będą szły dalej.

Można ten skrypt wykorzystać do ustawienia zachowania zdarzenia zależnie od tego w którym kierunku jest obrócone przy interakcji. To idealne rozwiązanie do gier ze skradaniem, gdzie chcemy np. uderzyć przeciwnika od tyłu żeby stracił przytomność.

Autor:
Shaz

Tłumaczenie:
Yoroiookami

Skrypt:

Spoiler: (Otwórz)

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w postaci pliku .js należy umieścić w folderze gry js/plugins.

KeepMoving.js (Rozmiar: 1.67 KB / Pobrań: 0)

Progresywne kondycje

Wed, 04 Jul 2018 21:02:48 +0200

~ Progresywne kondycje / Progressive states ~

Krótki opis:
Skrypt pozwala na wywołanie kondycji (stanu) po zakończeniu się poprzedniej.
Przykładowo, można ustawić że po przebudzeniu z uśpienia (sleep), bohater odczuwa gniew (rage).
W okienku Note w States należy wstawić:

Kod:

Gdzie ID jest ID stanu, który zostanie wywołany.

Autor:
HimeWorks

Skrypt:

Spoiler: (Otwórz)

Kod:

/*:

-------------------------------------------------------------------------

@title Progressive States

@author Hime --> HimeWorks (http://himeworks.com)

@date Nov 20, 2015

@filename HIME_ProgressiveStates.js

@url http://himeworks.com/2015/11/progressive-states-mv/

If you enjoy my work, consider supporting me on Patreon!

https://www.patreon.com/himeworks

If you have any questions or concerns, you can contact me at any of

the following sites:

Main Website: http://himeworks.com

Facebook: https://www.facebook.com/himeworkscom/

Twitter: https://twitter.com/HimeWorks

Youtube: https://www.youtube.com/c/HimeWorks

Tumblr: http://himeworks.tumblr.com/

-------------------------------------------------------------------------

@plugindesc Allows you to create states where whenever the state is

removed due to expiry, a new state will be added afterwards.

@help 

-------------------------------------------------------------------------

== Description ==

Video: https://www.youtube.com/watch?v=9vjzhg36GqU

Do you have states that automatically change into other states after

a certain amount of turns or actions have elapsed?

For example, you have a Doom state that counts down every turn,

and when the countdown reaches 0, the battler will automatically die.

Or perhaps you have a Poison state that will worsen if it's not

treated, and after walking around for 50 steps, the poison state

automatically turns into a deadlier poison state.

Or perhaps you have a Frozen state that prevents the battler from

moving, but if it gets hit by any damage, it will immediately die.

This plugin allows you to set up your states so that when the state is

removed automatically, new states will be added.

== Terms of Use ==

- Free for use in non-commercial projects with credits

- Contact me for commercial use

== Change Log ==

Nov 20, 2015 - refactored code to make it easier to check states

Nov 19, 2015 - initial release

== Usage ==

To specify what states will be added when a state is automatically

removed, add the note-tag

Where the ID is the ID of the state that will be added. You can add

multiple states by adding additional notetags.

-------------------------------------------------------------------------

 */ 

var Imported = Imported || {} ;

var TH = TH || {};

Imported.ProgressiveStates = 1;

TH.ProgressiveStates = TH.ProgressiveStates || {};

(function ($) {

  $.Regex = //img

  $.getProgressiveStates = function(state) {

    if (state.progressiveStates !== undefined) {

      return state.progressiveStates;

    }

    state.progressiveStates = [];

    var res;    

    while (res = $.Regex.exec(state.note)) {

      var id = Math.floor(res[1]);

      state.progressiveStates.push(id);

    }

    return state.progressiveStates;

  };

  /* Remove by walking */

  var TH_ProgressiveStates_GameBattler_updateStateSteps = Game_Actor.prototype.updateStateSteps;

  Game_Actor.prototype.updateStateSteps = function(state) {

    TH_ProgressiveStates_GameBattler_updateStateSteps.call(this, state);

    if (!this.isStateAffected(state.id)) {

      this.addProgressiveStates(state);

    }

  };

  /* Remove by damage */

  var TH_ProgressiveStates_GameBattler_removeStatesByDamage = Game_Battler.prototype.removeStatesByDamage;

  Game_Battler.prototype.removeStatesByDamage = function() {

    var oldStates = this._states.clone();

    TH_ProgressiveStates_GameBattler_removeStatesByDamage.call(this);

    var newStates = this._states;

    this.checkProgressiveStates(oldStates, newStates);

  };

  /* Remove by turn end and action end */

  var TH_ProgressiveStates_GameBattler_removeStatesAuto = Game_Battler.prototype.removeStatesAuto;

  Game_Battler.prototype.removeStatesAuto = function(timing) {

    var oldStates = this._states.clone();

    TH_ProgressiveStates_GameBattler_removeStatesAuto.call(this, timing);

    var newStates = this._states;    

    this.checkProgressiveStates(oldStates, newStates);

  };

  Game_Battler.prototype.checkProgressiveStates = function(oldStates, newStates) {

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

      var stateId = oldStates[i];

      var state = $dataStates[stateId];

      if (!newStates.contains(stateId)) {

        this.addProgressiveStates(state);

      }

    }

  };

  Game_Battler.prototype.addProgressiveStates = function(state) {

    var progStates = $.getProgressiveStates(state);

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

      this.addState(progStates[i]);

    }

  };

})(TH.ProgressiveStates);

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w postaci pliku .js należy umieścić w folderze gry js/plugins.

HIME_ProgressiveStates.js (Rozmiar: 4.59 KB / Pobrań: 0)

Rozmowa z towarzyszem

Wed, 04 Jul 2018 20:49:32 +0200

~ Rozmowa z towarzyszem / Talk to follower ~

Krótki opis:
Skrypt pozwala na rozmowę z towarzyszem, pod warunkiem że w party są tylko dwie osoby. Okienka rozmów można ustawić w wybranym Common Event. Do poprawnego działania skryptu, wymagany jest Obrót w miejscu.

Autor:
mjshi

Skrypt:

Spoiler: (Otwórz)

Kod:

//==============================================================================

// TalkToFollower.js

//==============================================================================

var Imported = Imported || {};

Imported.TalkToFollower = true;

var TTF = {};

/*:

* @plugindesc Allows the player to talk to a follower, specifically, the one party member right behind them.

* @author mjshi

* 

* @param Common Event ID

* @desc ID of the common event to be called when the player attempts to talk to a follower

* @default 1

* 

* @help 

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

*   Talk To Follower v1.01 by mjshi

*   Free for both commercial and non-commercial use, with credit.

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

* > Requires Turn In Place: http://mjshi.weebly.com/mv-turn-in-place.html

* > Only works when the player has exactly 1 follower.

*

* > Update v1.01: Fixed a bug that occurs if there are no followers

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

*   Built-in functions for conditional branches. Case Sensitive!

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

*   TTF.fIs(ID)       checks if the follower's ID is ID 

*   TTF.mapIs(ID)     checks if player/follower are in map ID

*   TTF.regionIs(ID)  checks if player is in region ID

*   TTF.fregionIs(ID) checks if follower is in region ID

*   

*   Use && and || to connect these statements! For example,

*

*   TTF.regionIs(ID) || TTF.fregionIs(ID)

*   checks if follower OR player are in region ID

*

*   TTF.regionIs(ID) && TTF.fregionIs(ID)

*   checks if follower AND player are in region ID

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

*

* > Is something broken? Go to http://mjshi.weebly.com/contact.html and I'll

*   try my best to help you!

*/

TTF.Parameters = PluginManager.parameters('TalkToFollower');

TTF.eventID = Number(TTF.Parameters['Common Event ID']);

if (Imported.TurnInPlace) {

TTF.mapIs = function (ID) {return ($gameMap._mapId == ID)}

TTF.fIs = function (ID) {return ($gameParty._actors[1] == ID)}

TTF.regionIs = function (ID) {return ($gameMap.regionId($gamePlayer._x, $gamePlayer._y) == ID)}

TTF.fregionIs = function (ID) {return ($gameMap.regionId($gamePlayer._followers.visibleFollowers()[0]._x, $gamePlayer._followers.visibleFollowers()[0]._y) == ID)}

ttf_alias_Scene_Map_updateScene = Scene_Map.prototype.updateScene;

Scene_Map.prototype.updateScene = function() {

    ttf_alias_Scene_Map_updateScene.call(this);

    if (SceneManager.isSceneChanging()) {return}

    if ($gameMap.isEventRunning()) {return}

    if (Input.isTriggered('ok') || (TouchInput.isTriggered() && TouchInput.clickedOnFollower())) {this.checkTalking()};

};

TouchInput.clickedOnFollower = function() {

    var x = Math.floor(this._x / 48);

    var y = Math.floor(this._y / 48);

    var f = $gamePlayer._followers.visibleFollowers()[0];

    if (f === undefined) return;

    return (x == f._x && y == f._y);

};

Scene_Map.prototype.checkTalking = function() {    

    var f = $gamePlayer._followers.visibleFollowers()[0];

    if (!f) {return}

    var p = $gamePlayer;

    var pd = p._direction;

    var fd = f._direction;

    if ((pd == 8 && fd == 2 && p._y - f._y == 1) || (pd == 2 && fd == 8 && p._y - f._y == -1) || 

        (pd == 4 && fd == 6 && p._x - f._x == 1) || (pd == 6 && fd == 4 && p._x - f._x == -1))

        {$gameTemp.reserveCommonEvent(TTF.eventID)}

};

}

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w postaci pliku .js należy umieścić w folderze gry js/plugins.

TalkToFollower.js (Rozmiar: 3.51 KB / Pobrań: 0)

Obrót w miejscu

Wed, 04 Jul 2018 20:46:37 +0200

~ Obrót w miejscu / Turn in place ~

Krótki opis:
Skrypt pozwala na obrócenie postaci w miejscu przy zmianie kierunku chodzenia na przeciwny. Skrypt ten jest potrzebny do poprawnego działania skryptu Rozmowa z towarzyszem.

Autor:
mjshi

Skrypt:

Spoiler: (Otwórz)

Kod:

[code]//==============================================================================

// TurnInPlace.js

//==============================================================================

var Imported = Imported || {};

Imported.TurnInPlace = true;

var TurnInPlace = {};

/*:

* @plugindesc Allows the player to turn in place before moving.

* @author mjshi

* 

* @param Wait Count

* @desc Wait count in frames. 60 frames = 1 second

* @default 8

* 

* @help 

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

*   Turn In Place v1.0 by mjshi

*   Free for both commercial and non-commercial use, with credit.

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

* > Inspired by "Player Turn & Move" by SirBilly (silentkingdom.com)

*   (but the way things are handled differ completely)

*

* > Is something broken? Go to http://mjshi.weebly.com/contact.html and I'll

*   try my best to help you!

*/

TurnInPlace.Parameters = PluginManager.parameters('TurnInPlace');

TurnInPlace.waitCount = Number(TurnInPlace.Parameters['Wait Count']);

var turn_in_place_alias_game_player_initialize = Game_Player.prototype.initialize;

Game_Player.prototype.initialize = function() {

    turn_in_place_alias_game_player_initialize.call(this);

    this._waitCount = TurnInPlace.waitCount;

};

var turn_in_place_alias_game_player_update = Game_Player.prototype.update;

Game_Player.prototype.update = function(sceneActive) {

    if ($gameMap.isEventRunning()) {this._waitCount = 0}

    turn_in_place_alias_game_player_update.call(this, sceneActive);

    if (!(Input.isPressed("up") || Input.isPressed("down") || 

        Input.isPressed("left") || Input.isPressed("right") || 

        TouchInput.isPressed())) {

            this._waitCount = TurnInPlace.waitCount}

    if (this._waitCount > 0) {this._waitCount -= 1}

};

Game_Player.prototype.moveByInput = function() {

    if (!this.isMoving() && this.canMove()) {

        var direction = this.getInputDirection();

        if (direction > 0) {

            $gameTemp.clearDestination();

        } else if ($gameTemp.isDestinationValid()){

            var x = $gameTemp.destinationX();

            var y = $gameTemp.destinationY();

            direction = this.findDirectionTo(x, y);

        }

        if ((direction > 0 || TouchInput.isTriggered()) && this._waitCount == 0) {

            this.executeMove(direction);

        } else {

            this.setDirection(direction);

            this._followers._data[0].turnTowardPlayer();

        }

    }

};

[/code]

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w postaci pliku .js należy umieścić w folderze gry js/plugins.

TurnInPlace.js (Rozmiar: 2.46 KB / Pobrań: 0)

Paski HP przeciwników

Sat, 16 Jun 2018 12:34:17 +0200

~ Paski HP przeciwników / Pretty Sleek Gauges ~

Krótki opis:
Skrypt wyświetla animowane paski HP przeciwników podczas walki. Ich kształt można dowolnie modyfikować, zmieniając ustawienia wtyczki.

Kompatybilny z innymi systemami walki.

Autor:
Vlue, Rocketmancer, mjshi

Skrypt:

Spoiler: (Otwórz)

Kod:

//=============================================================================

// PrettySleekGauges.js

//=============================================================================

var Imported = Imported || {};

Imported.PrettySleekGauges = true;

/*:

 * @plugindesc Sleek Gauges! Look at them go, so shiny, so cool. And they're even better when you can change what they look like and use them in battles!

 * @author Vlue Au'Vier (sleek), Rocketmancer​ (pretty), mjshi (pretty sleek)

 *

 * @param Bar Shape

 * @desc Use any combination of | / . < > ( ) \ Ex. // (> or /|

 * @default //

 *

 * @param HP Bar Shape

 * @parent Bar Shape

 * @desc Leave blank to use default. Use any combination of | / . < > ( ) \ Ex. // (> or /|

 * @default 

 *

 * @param MP Bar Shape

 * @parent Bar Shape

 * @desc Leave blank to use default. Use any combination of | / . < > ( ) \ Ex. // (> or /|

 * @default 

 *

 * @param TP Bar Shape

 * @parent Bar Shape

 * @desc Leave blank to use default. Use any combination of | / . < > ( ) \ Ex. // (> or /|

 * @default 

 *

 * @param EXP Bar Shape

 * @parent Bar Shape

 * @desc Leave blank to use default. Use any combination of | / . < > ( ) \ Ex. // (> or /|

 * @default ||

 *

 * @param Gauge Height

 * @desc Default height of the gauges

 * @type number

 * @default 8

 *

 * @param Outline Color

 * @desc Hex color.

 * @default #FFFFFF

 *

 * @param Enemy Gauges

 *

 * @param Enemy HP Gauge

 * @parent Enemy Gauges

 *

 * @param Enemy MP Gauge

 * @parent Enemy Gauges

 *

 * @param Show Enemy HP Gauges

 * @parent Enemy HP Gauge

 * @type select

 * @default show over

 * @desc Shows the enemy hp bar over/under animations. 

 * (show under/show over/don't show)

 * @option show over

 * @option show under

 * @option don't show

 *

 * @param Show Enemy HP Text

 * @parent Enemy HP Gauge

 * @desc Show the word "HP"?

 * (true/false)

 * @default false

 * @type boolean

 *

 * @param HP Text Y Offset

 * @parent Enemy HP Gauge

 * @desc Y offset of the enemy hp gauges

 * @type number

 * @min -100000000000000000000000

 * @default 0

 *

 * @param Show Enemy HP Value

 * @parent Enemy HP Gauge

 * @desc Show how much HP the enemy has left?

 * (true/false)

 * @default true

 * @type boolean

 *

 * @param Show Up Top

 * @parent Enemy HP Gauge

 * @desc Show the enemy hp gauges above the enemy?

 * (true/false)

 * @type boolean

 * @default true

 *

 * @param Bar Width

 * @parent Enemy HP Gauge

 * @desc Width of the Enemy HP gauge

 * @type number

 * @default 120

 *

 * @param HP Gauge X Offset

 * @parent Enemy HP Gauge

 * @desc X offset of the enemy hp gauges

 * @type number

 * @min -100000000000000000000000

 * @default 0

 *

 * @param HP Gauge Y Offset

 * @parent Enemy HP Gauge

 * @desc Y offset of the enemy hp gauges

 * @type number

 * @min -100000000000000000000000

 * @default 0

 *

 * @param Image Height Multiplier

 * @parent Enemy HP Gauge

 * @desc How far up the image to place the HP bar, in a decimal percentage.

 * @type number

 * @decimals 2

 * @default 0.9

 *

 * @param State Positioning

 * @parent Enemy Gauges

 * @desc Since our HP gauge covers parts of it.

 *

 * @param State X Offset

 * @parent State Positioning

 * @desc X offset of the enemy states

 * @type number

 * @min -100000000000000000000000

 * @default 0

 *

 * @param State Y Offset

 * @parent State Positioning

 * @desc Y offset of the enemy states

 * @type number

 * @min -100000000000000000000000

 * @default 30

 *

 * @param State Height Multiplier

 * @parent State Positioning

 * @desc How far up the image to place the state icons, in a decimal percentage.

 * @type number

 * @decimals 2

 * @default 0.9

 *

 * @param Show Enemy MP

 * @parent Enemy MP Gauge

 * @type boolean

 * @desc Show a tiny MP gauge?

 * (true/false)

 * @default true

 *

 * @param Show MP Bar When MMP is 0

 * @parent Enemy MP Gauge

 * @type boolean

 * @desc Show the MP bar when the enemy's max mp is 0?

 * (true/false)

 * @default false

 *

 * @param Tiny Gauge Height

 * @parent Enemy MP Gauge

 * @type number

 * @desc Height of the tiny gauge

 * @default 2

 *

 * @param Tiny Gauge X Offset

 * @parent Enemy MP Gauge

 * @type number

 * @min -100000000000000000000000

 * @desc X Offset of the tiny gauge

 * @default 0

 *

 * @param Tiny Gauge Y Offset

 * @parent Enemy MP Gauge

 * @type number

 * @min -100000000000000000000000

 * @desc Y Offset of the tiny gauge

 * @default 0

 *

 * @param Tiny Gauge Width Adjust

 * @parent Enemy MP Gauge

 * @type number

 * @min -100000000000000000000000

 * @desc Adjust the width of the tiny gauge

 * @default 0

 *

 * @param Animated Numbers

 * @desc Whether or not numbers count down/up

 * (true/false)

 * @type boolean

 * @default true

 *

 * @param Animated Gauge

 * @desc Whether or not the gauge is animated

 * (true/false)

 * @type boolean

 * @default true

 *

 * @param Extras

 *

 * @param Critical HP Change

 * @desc HP text becomes red when HP is critically low

 * (true/false)

 * @type boolean

 * @parent Extras

 * @default true

 *

 * @param Critical MP Change

 * @desc MP text becomes red when MP is critically low

 * (true/false)

 * @type boolean

 * @parent Extras

 * @default true

 *

 * @param Critical TP Change

 * @desc TP text becomes red when TP is critically low

 * (true/false)

 * @type boolean

 * @parent Extras

 * @default false

 *

 * @param Show EXP Bar

 * @parent Extras

 * @desc Show the EXP bar?

 * (true/false)

 * @default true

 * @type boolean

 *

 * @param Status Icon XY Offset

 * @parent Extras

 * @desc Manually control where status icons are placed. Leave blank if you don't have out of battle statuses. Format: X, Y

 * @default 

 *

 * @param

 * @help 

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

 *   Pretty Sleek Gauges v1.02b

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

 *   Free to use in any project with credit to:

 *     Vlue         (original plugin)

 *     Rocketmancer (Prettier Gauges)

 *     mjshi        (merging, edits, and enemy HP bars)

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

 *  Extra Notetags:

 *    If there's just that ONE enemy (looking at you, Slime) that has its

 *    face covered up by the HP bar, you can use these notetags:

 *

 *  

 *  

 * 

 *    to manually put it in its place.

 *    The # can be positive or negative. So in that slime example, with the

 *    default settings, having a  there fixes the issue.

 *

 *  Also, for bosses, you can hide the HP or MP bar via these:

 *    

 *    

 *

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

 *  Original Plugin By Vlue

 *

 *  Facebook: https://www.facebook.com/DaimoniousTailsGames/

 *  Website: http://daimonioustails.weebly.com/

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

 *  Merged with Prettier Gauges/Custom Gauges by Rocketmancer​

 *    https://forums.rpgmakerweb.com/index.php?threads/prettier-gauges.47077/

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

 *  Changes from the forum version:

 *  - merged a couple functions

 *  - added support for \ style gauges

 *  - fixed issue with overfilling the gauge

 *  - added support for enemy HP gauges

 *  - added support for individual HP gauge offsets

 *  - added support for EXP gauges and individual bar styles

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

 * > Is something broken? Go to http://mjshi.weebly.com/contact.html and I'll

 *   try my best to help you!

 * 

 */

function Special_Gauge() {

    this.initialize.apply(this, arguments);

}

(function() {

var parameters = PluginManager.parameters('PrettySleekGauges');

var defaultHeight = Number(parameters['Gauge Height'] || 8);

var defaultTinyHeight = Number(parameters['Tiny Gauge Height'] || 2);

var animatedNumbers = (parameters['Animated Numbers'] || "true") === "true";

var animatedGauges = (parameters['Animated Gauges'] || "true") === "true";

var gaugeOutColor = parameters['Outline Color'] || "#FFFFFF";

var barTypeLeft = String(parameters['Bar Shape']).substring(0,1);

var barTypeRight = String(parameters['Bar Shape']).substring(1,2);

var saveBarTypeLeft = barTypeLeft;

var saveBarTypeRight = barTypeRight;

var hpBarTypeLeft = (parameters['HP Bar Shape'].length === 2) ? String(parameters['HP Bar Shape']).substring(0,1) : false;

var hpBarTypeRight = (parameters['HP Bar Shape'].length === 2) ? String(parameters['HP Bar Shape']).substring(1,2) : false;

var mpBarTypeLeft = (parameters['MP Bar Shape'].length === 2) ? String(parameters['MP Bar Shape']).substring(0,1) : false;

var mpBarTypeRight = (parameters['MP Bar Shape'].length === 2) ? String(parameters['MP Bar Shape']).substring(1,2) : false;

var tpBarTypeLeft = (parameters['TP Bar Shape'].length === 2) ? String(parameters['TP Bar Shape']).substring(0,1) : false;

var tpBarTypeRight = (parameters['TP Bar Shape'].length === 2) ? String(parameters['TP Bar Shape']).substring(1,2) : false;

var expBarTypeLeft = (parameters['EXP Bar Shape'].length === 2) ? String(parameters['EXP Bar Shape']).substring(0,1) : false;

var expBarTypeRight = (parameters['EXP Bar Shape'].length === 2) ? String(parameters['EXP Bar Shape']).substring(1,2) : false;

var showEnemyHP = (parameters['Show Enemy HP Gauges']).startsWith("show");

var showOver = (parameters['Show Enemy HP Gauges']).endsWith("over");

var showUpTop = (parameters['Show Up Top'] || "true") === "true";

var EHPXOffset = parseInt(parameters['HP Gauge X Offset']) || 0;

var EHPYOffset = parseInt(parameters['HP Gauge Y Offset']) || 0;

var EHPbarWidth = parseInt(parameters['Bar Width']) || 120;

var showEHPHP = (parameters['Show Enemy HP Text'] || "false") === "true";

var textYOffset = parseInt(parameters['HP Text Y Offset']) || 0;

var showEHPText = (parameters['Show Enemy HP Value'] || "true") === "true";

var EHPYMultiplier = parseInt(parameters['Image Height Multiplier']) || 0.9;

var EHPStateXOffset = parseInt(parameters['State X Offset']) || 0;

var EHPStateYOffset = parseInt(parameters['State Y Offset']) || 30;

var shouldDrawEnemyMP = (parameters['Show Enemy MP'] || "true") === "true";

var drawEnemyMPWhenNoMP = (parameters['Show MP Bar When MMP is 0'] || "true") === "true";

var defaultTinyHeight = parseInt(parameters['Tiny Gauge Height']) || 2;

var tinyWidthAdjust = parseInt(parameters['Tiny Gauge Width Adjust']) || 0;

var tinyGaugeXOffset = parseInt(parameters['Tiny Gauge X Offset']) || 0;

var tinyGaugeYOffset = parseInt(parameters['Tiny Gauge Y Offset']) || 0;

// var shouldDrawEnemyTP = (parameters['Show Enemy TP'] || "true") === "true";

var criticalHP = (parameters['Critical HP Change'] || "true") === "true";

var criticalMP = (parameters['Critical MP Change'] || "true") === "true";

var criticalTP = (parameters['Critical TP Change'] || "false") === "true";

var showEXP = (parameters['Show EXP Bar'] || "true") === "true";

var statusXY = (parameters['Status Icon XY Offset'] || "true").split(", ").map(Number);

//=============================================================================

// Sleek Gauges

//=============================================================================

Window_Base.prototype.drawAnimatedGauge = function(x, y, width, rate, c1, c2, criticalColor) {

    if (this._gauges == null) this._gauges = {};

    var gkey = this.makeGaugeKey(x, y)

    if (this._gauges[gkey]) {

        this._gauges[gkey].setRate(rate);

    } else {

        this._gauges[gkey] = new Special_Gauge(x, y, width, rate, c1, c2, this, defaultHeight, criticalColor);

    }

}

var windowBaseUpdate = Window_Base.prototype.update;

Window_Base.prototype.update = function() {

    windowBaseUpdate.call(this);

    if (this._gauges) for(var bar in this._gauges) this._gauges[bar].update();

}

Window_Base.prototype.makeGaugeKey = function(x, y) {

    return "k" + x + "-" + y;

}

Window_Base.prototype.drawActorHp = function(actor, x, y, width) {

    width = width || 186;

    this.drawAnimatedGauge(x, y, width, actor.hpRate(), this.hpGaugeColor1(), this.hpGaugeColor2(), criticalHP);

    this._gauges[this.makeGaugeKey(x, y)].setExtra(TextManager.hpA, actor.hp, actor.mhp);

    this._gauges[this.makeGaugeKey(x, y)].update();

}

Window_Base.prototype.drawActorMp = function(actor, x, y, width) {

    width = width || 186;

    this.drawAnimatedGauge(x, y, width, actor.mpRate(), this.mpGaugeColor1(), this.mpGaugeColor2(), criticalMP);

    this._gauges[this.makeGaugeKey(x, y)].setExtra(TextManager.mpA, actor.mp, actor.mmp);

    this._gauges[this.makeGaugeKey(x, y)].update();

}

Window_Base.prototype.drawActorTp = function(actor, x, y, width) {

    width = width || 186;

    this.drawAnimatedGauge(x, y, width, actor.tpRate(), this.tpGaugeColor1(), this.tpGaugeColor2(), criticalTP);

    this._gauges[this.makeGaugeKey(x, y)].setExtra(TextManager.tpA, actor.tp, 100);

    this._gauges[this.makeGaugeKey(x, y)].update();

}

Window_MenuStatus.prototype.drawActorEXP = function(actor, x, y, width) {

    if (!showEXP) return;

    var rate = (actor.currentExp() - actor.currentLevelExp()) / (actor.nextLevelExp() - actor.currentLevelExp());

    if (actor.level === actor.maxLevel()) rate = 1;

    this.drawExpGauge(x, y, width, rate, this.textColor(0), this.textColor(8));

    this.changeTextColor(this.systemColor());

    this.drawText(TextManager.expA, x, y, 44);

    this.changeTextColor(this.normalColor());

    this.drawText((Math.floor(rate * 10000) / 100) + "%", x, y, width,"right");

};

Window_Base.prototype.drawExpGauge = function(x, y, width, rate, c1, c2) {

    barTypeLeft = expBarTypeLeft || barTypeLeft;

    barTypeRight = expBarTypeRight || barTypeRight;

    var height = defaultHeight;

    var fill_w = width * rate;

    var gy = y + this.lineHeight() - height - 1;

    this.contents.drawTrap(x, gy, width - 2, height, this.gaugeBackColor(), true);

    this.contents.drawTrap(x, gy, fill_w, height, c1, c2, "atop");

    this.contents.drawTrap(x, gy, width - 2, height, gaugeOutColor);

    barTypeLeft = saveBarTypeLeft;

    barTypeRight = saveBarTypeRight;

};

Window_MenuStatus.prototype.drawActorSimpleStatus = function(actor, x, y, width) {

    if (statusXY.length === 2) {

        var lineHeight = this.lineHeight();

        var x2 = x + 180;

        var width2 = Math.min(200, width - 180 - this.textPadding());

        this.drawActorName(actor, x, y);

        this.drawActorLevel(actor, x, y + lineHeight * 1);

        this.drawActorIcons(actor, x + statusXY[0], y + lineHeight * 2 + statusXY[1]);

        this.drawActorClass(actor, x2, y);

        this.drawActorHp(actor, x2, y + lineHeight * 1, width2);

        this.drawActorMp(actor, x2, y + lineHeight * 2, width2);

    } else {

        Window_Base.prototype.drawActorSimpleStatus.call(this, actor, x, y, width);

    }

    if (Imported.YEP_CoreEngine) {

        this.drawActorEXP(actor, x, y + this.lineHeight()*2, 145);

    } else {

        this.drawActorEXP(actor, x, y + this.lineHeight()*2, Math.min(200, width - 200 - this.textPadding()));

    }

};

// cede to Yanfly for level drawing

if (!Imported.YEP_CoreEngine) {

Window_MenuStatus.prototype.drawActorLevel = function(actor, x, y) {

    this.changeTextColor(this.systemColor());

    this.drawText(TextManager.levelA, x, y, 48);

    this.resetTextColor();

    this.drawText(actor.level, x + 130, y, 36, 'right');

};

}

Special_Gauge.prototype.constructor = Special_Gauge;

Special_Gauge.prototype.initialize = function(x, y, w, r, c1, c2, basewindow, h, critText) {

    this._x = x;

    this._y = y;

    this._width = w;

    this._curRate = this._maxRate = r;

    this._vocab = false;

    this._color = [c1, c2];

    this._window = basewindow;

    this._speed = 0;

    this._speedRate = 0;

    this._height = h;

    this._fallSprites = [];

    this._showEHPHP = true;

    this._showEHPText = true;

    this._critTextColor = critText;

    this.refresh();

}

Special_Gauge.prototype.setTextVisibility = function(hpText, hpNum) {

    this._showEHPHP = hpText;

    this._showEHPText = hpNum;

}

Special_Gauge.prototype.doneUpdating = function() {

    return this._curRate === this._maxRate && this._curVal === this._setVal;

};

Special_Gauge.prototype.update = function() {

    if (this.doneUpdating()) return;

    if (this._curRate > this._maxRate) this._curRate -= this._speedRate;

    if (this._curVal > this._setVal) this._curVal -= this._speed;

    if (this._curRate < this._maxRate) this._curRate += this._speedRate;

    if (this._curVal < this._setVal) this._curVal += this._speed;

    if (Math.abs(this._curRate - this._maxRate) < this._speedRate) this._curRate = this._maxRate;

    if (Math.abs(this._curVal - this._setVal) < this._speed) this._curVal = this._setVal;

    if (!animatedNumbers) this._curVal = this._setVal;

    if (!animatedGauges) this._curRate = this._maxRate;

    this.refresh();

}

Special_Gauge.prototype.refresh = function() {

    if (this._vocab) {

        this._window.contents.clearRect(this._x-1, this._y, this._width+2, this._window.lineHeight());        

    } else {

        var gy = this._y + this._window.lineHeight() - this._height - 1;

        this._window.contents.clearRect(this._x, gy, this._width, this._height);

    }

    this.drawGauge();

    this.drawText();

}

Special_Gauge.prototype.setRate = function(rate) {

    if (rate != this._maxRate) {

        this._maxRate = rate;

        this._speedRate = Math.abs(this._curRate - this._maxRate) / 60;

        //TODO: More Falling Sprite Stuff

    }

}

Special_Gauge.prototype.setExtra = function(text, val, max, yOffset) {

    this._vocab = true;

    this._text = text;

    this._maxVal = max;

    if (val != this._setVal) {

        this._speed = Math.max(0, Math.abs(this._curVal - val) / 60);

    }

    this._setVal = val;

    if (this._curVal == null) {

        this._curVal = val;

    }

    this._yOffset = yOffset ? yOffset : 0;

    this.refresh();

}

Special_Gauge.prototype.drawGauge = function() {

    var fill_w = Math.round((this._width - 2) * this._curRate);

    var fill_ww = Math.round((this._width - 2) * this._maxRate);

    var gy = this._y + this._window.lineHeight() - this._height - 1;

    switch (this._text) {

        case TextManager.hpA:

            barTypeLeft = hpBarTypeLeft || barTypeLeft;

            barTypeRight = hpBarTypeRight || barTypeRight;

            break;

        case TextManager.mpA:

            barTypeLeft = mpBarTypeLeft || barTypeLeft;

            barTypeRight = mpBarTypeRight || barTypeRight;

            break;

        case TextManager.tpA:

            barTypeLeft = tpBarTypeLeft || barTypeLeft;

            barTypeRight = tpBarTypeRight || barTypeRight;

            break;

    }

    this._window.contents.drawTrap(this._x, gy, this._width - 2, this._height, this._window.gaugeBackColor(), true);

    this._window.contents.drawTrap(this._x, gy, fill_w, this._height, this._color[0], this._color[1], "atop");

    this._window.contents.drawTrap(this._x, gy, this._width - 2, this._height, gaugeOutColor);

    barTypeLeft = saveBarTypeLeft;

    barTypeRight = saveBarTypeRight;

}

Special_Gauge.prototype.fontSize = function() {

    return 28;

}

Special_Gauge.prototype.drawText = function() {

    if (this._vocab) {

        this._window.fontSize = this.fontSize();

        if (this._showEHPHP) {

            this._window.changeTextColor(this._window.systemColor());

            this._window.drawText(this._text, this._x + 1, this._y + this._yOffset, 30);

        }

        if (this._showEHPText) {

            this._window.changeTextColor(this._window.normalColor());

            if (this._critTextColor) {

                if (this._curVal < this._maxVal / 10) {

                    this._window.changeTextColor(this._window.deathColor());

                } else if (this._curVal < this._maxVal / 4) {

                    this._window.changeTextColor(this._window.crisisColor());

                }

            }

            var xr = this._x + this._width;

            if (this._width < 186) {

                this._window.drawText(Math.round(this._curVal), xr - 40, this._y + this._yOffset, 40, "right");

            } else {

                this._window.drawText(Math.round(this._curVal), xr - 92, this._y + this._yOffset, 42, "right");

                this._window.changeTextColor(this._window.normalColor());

                this._window.drawText("/", xr - 52, this._y + this._yOffset, 12, "right");

                this._window.drawText(this._maxVal, xr - 42, this._y + this._yOffset, 40, "right");

            }

        }

    }

}

//=============================================================================

// Pretty Gauges

//=============================================================================

Bitmap.prototype.drawTrap = function(x, y, width, height, color1, color2, shouldFill) {

    var context = this._context;

    var grad = context.createLinearGradient(x, y, x + width, y);

    var startCoords = [];

    if (typeof color2 === 'boolean') {

        shouldFill = color2;

        color2 = undefined;

    }

    if (color2 === undefined) color2 = color1;

    if (shouldFill === "atop") {

        context.globalCompositeOperation = 'source-atop';

    } else {

        context.globalCompositeOperation = 'source-over';

    }

    grad.addColorStop(0, color1);

    grad.addColorStop(1, color2);

    context.save();

    context.beginPath();

    switch (barTypeLeft) {

        case "|":

            startCoords = [x, y + height]

            context.moveTo(x, y + height)

            context.lineTo(x, y)

            break;

        case "/":

            startCoords = [x, y + height]

            context.moveTo(x, y + height)

            context.lineTo(x + height, y)

            break;

        case "<":

            startCoords = [x + height/2, y + height]

            context.moveTo(x + height/2, y + height)

            context.lineTo(x, y + height/2)

            context.lineTo(x + height/2, y)

            break;

        case "(":

            startCoords = [x + height, y + height]

            context.moveTo(x + height, y + height);

            context.bezierCurveTo(x, y + height, x, y, x + height, y);

            break;

        case ".":

            startCoords = [x, y + height]

            context.moveTo(x, y + height)

            break;

        case "\\":

            startCoords = [x + height, y + height]

            context.moveTo(x + height, y + height)

            context.lineTo(x, y)

            break;

    }

    switch (barTypeRight) {

        case "|":

            context.lineTo(x + width, y)

            context.lineTo(x + width, y + height)

            break;

        case "/":

            context.lineTo(x + width, y)

            context.lineTo(x + width - height, y + height)

            break;

        case ">":

            context.lineTo(x + width - height/2, y)

            context.lineTo(x + width, y + height/2)

            context.lineTo(x + width - height/2, y + height)

            break;

        case ")":

            context.lineTo(x + width - height, y);

            context.bezierCurveTo(x + width, y, x + width, y + height, x + width - height, y + height);

            break;

        case ".":

            context.lineTo(x + width, y + height)

            break;

        case "\\":

            context.lineTo(x + width - height, y)

            context.lineTo(x + width, y + height)

            break;

    }

    context.lineTo(startCoords[0], startCoords[1])

    if (shouldFill) {

        context.fillStyle = grad;

        context.fill();

    } else {

        context.strokeStyle = grad;

        context.stroke();

    }

    context.restore();

    this._setDirty();

}

//=============================================================================

// EnemyGauges

//=============================================================================

if (showEnemyHP) {

function Window_EnemyHPBars() {

    this.initialize.apply(this, arguments);

};

Window_EnemyHPBars.prototype = Object.create(Window_Base.prototype);

Window_EnemyHPBars.prototype.constructor = Window_EnemyHPBars;

Window_EnemyHPBars.prototype.initialize = function(sprites) {

    Window_Base.prototype.initialize.call(this, 0, 0, Graphics.boxWidth, Graphics.boxHeight);

    this.opacity = 0;

    this._enemySprites = sprites.slice().reverse();

};

Window_EnemyHPBars.prototype.standardPadding = function() {

   return 0;

};

Window_EnemyHPBars.prototype.drawActorHp = function(actor, x, y, width) {

    width = width || 186;

    if (this._gauges && this._gauges[this.makeGaugeKey(x, y)] && this._gauges[this.makeGaugeKey(x, y)]._curVal === 0) {

        this.contents.clearRect(x - defaultHeight, y, width + defaultHeight, this.lineHeight() + defaultHeight);

        return;

    }

    if (!$dataEnemies[actor.enemyId()].meta.HideEnemyHPBar) {

        barTypeLeft = $dataEnemies[actor.enemyId()].meta.BarTypeLeft || hpBarTypeLeft || barTypeLeft;

        barTypeRight = $dataEnemies[actor.enemyId()].meta.BarTypeRight || hpBarTypeRight || barTypeRight;

        this.drawAnimatedGauge(x, y, width, actor.hpRate(), this.hpGaugeColor1(), this.hpGaugeColor2());

        this._gauges[this.makeGaugeKey(x, y)].setExtra(TextManager.hpA, actor.hp, actor.mhp, textYOffset);

        this._gauges[this.makeGaugeKey(x, y)].setTextVisibility(showEHPHP, showEHPText);

        barTypeLeft = saveBarTypeLeft;

        barTypeRight = saveBarTypeRight;

    }

    if (shouldDrawEnemyMP && (drawEnemyMPWhenNoMP || actor.mmp > 0) && !$dataEnemies[actor.enemyId()].meta.HideEnemyMPBar) {

        this.drawTinyGauge(x + tinyGaugeXOffset, y + 1 + tinyGaugeYOffset, width + tinyWidthAdjust, actor.mpRate(), this.mpGaugeColor1(), this.mpGaugeColor2());

        this._gauges[this.makeTGaugeKey(x + tinyGaugeXOffset, y + 1 + tinyGaugeYOffset)].setExtra(TextManager.mpA, actor.mp, actor.mmp);

    }

    // Maybe this'll be useful someday

    // y += defaultTinyHeight;

    // if (shouldDrawEnemyTP && actor.mtp > 0) {

    //     this.drawTinyGauge(x + tinyGaugeXOffset, y + 1 + defaultTinyHeight, width, actor.tpRate(), this.tpGaugeColor1(), this.tpGaugeColor2());

    //     this._gauges[this.makeTGaugeKey(x + tinyGaugeXOffset, y + 1 + defaultTinyHeight)].setExtra(TextManager.tpA, actor.tp, actor.mtp);

    // }

}

Window_EnemyHPBars.prototype.makeTGaugeKey = function(x, y) {

    return "tk" + x + "-" + y;

}

Window_EnemyHPBars.prototype.drawTinyGauge = function(x, y, width, rate, c1, c2) {

    if (this._gauges == null) { this._gauges = {} };

    var gkey = this.makeTGaugeKey(x, y)

    if (this._gauges[gkey]) {

        this._gauges[gkey].setRate(rate);

    } else {

        this._gauges[gkey] = new Line_Gauge(x, y, width, rate, c1, c2, this, defaultTinyHeight);

    }

}

Window_EnemyHPBars.prototype.update = function() {

    Window_Base.prototype.update.call(this);

    var width = EHPbarWidth, x, y;

    for (var i = 0; i < $gameTroop._enemies.length; i++) {

        if (!this._enemySprites[i].height || !this._enemySprites[i].width) continue;

        x = $gameTroop._enemies[i].screenX() - (width + this.textPadding())/2 + EHPXOffset + (parseInt($dataEnemies[$gameTroop._enemies[i].enemyId()].meta.HPBarXOffset) || 0);

        y = $gameTroop._enemies[i].screenY() - this.lineHeight() + EHPYOffset + (parseInt($dataEnemies[$gameTroop._enemies[i].enemyId()].meta.HPBarYOffset) || 0);

        if (showUpTop) y -= this._enemySprites[i].height * EHPYMultiplier;

        this.drawActorHp($gameTroop._enemies[i], x, y, width);

    }

}

function Line_Gauge() {

    this.initialize.apply(this, arguments);

}

Line_Gauge.prototype = Object.create(Special_Gauge.prototype);

Line_Gauge.prototype.constructor = Line_Gauge;

Line_Gauge.prototype.refresh = function() {

    this._window.contents.clearRect(this._x, this.y, this._width, this._height);

    this.drawGauge();

}

Line_Gauge.prototype.drawGauge = function() {

    var fill_w = Math.round((this._width - 2 - defaultHeight) * this._curRate);

    var fill_ww = Math.round((this._width - 2) * this._maxRate);

    var gy = this._y + this._window.lineHeight() - this._height;

    this._window.contents.fillRect(this._x - 1, gy, this._width - defaultHeight, this._height + 2, gaugeOutColor);

    this._window.contents.fillRect(this._x, gy + 1, this._width - 2 - defaultHeight, this._height, this._window.gaugeBackColor());

    this._window.contents.gradientFillRect(this._x, gy + 1, fill_w, this._height, this._color[0], this._color[1]);

}

Line_Gauge.prototype.drawText = function() {};

if (showOver) {

var alias_Scene_Battle_createSpriteset = Scene_Battle.prototype.createSpriteset;

Scene_Battle.prototype.createSpriteset = function() {

    alias_Scene_Battle_createSpriteset.call(this);

    this._enemyHPBarWindow = new Window_EnemyHPBars(this._spriteset._enemySprites);

    this.addChild(this._enemyHPBarWindow);

};

} else {

var alias_Spriteset_Battle_createEnemies = Spriteset_Battle.prototype.createEnemies;

Spriteset_Battle.prototype.createEnemies = function() {

    alias_Spriteset_Battle_createEnemies.call(this);

    this._enemyHPBarWindow = new Window_EnemyHPBars(this._enemySprites);

    this._enemyHPBarWindow.z = 2;

    this._battleField.addChild(this._enemyHPBarWindow);

};

}

Sprite_Enemy.prototype.updateStateSprite = function() {

   this._stateIconSprite.y = -Math.round((this.bitmap.height + EHPStateYOffset) * 0.9);

   if (this._stateIconSprite.y < 20 - this.y) {

       this._stateIconSprite.y = 20 - this.y;

   }

   this._stateIconSprite.y += (parseInt($dataEnemies[this._enemy.enemyId()].meta.HPBarYOffset) || 0);

   this._stateIconSprite.x = EHPStateXOffset + (parseInt($dataEnemies[this._enemy.enemyId()].meta.HPBarXOffset) || 0);

};

} // End Enemy HP bars

})();

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w postaci pliku .js należy umieścić w folderze gry js/plugins

PrettySleekGauges.js (Rozmiar: 28.21 KB / Pobrań: 10)