Texte vergleichen

Finden Sie den Unterschied zwischen zwei Textdateien

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Onlinewerkzeuge

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 8 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

665 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

682 lines

/*:

* @plugindesc v1.10 Plugin supports Tiled Map Editor maps with some additional

* @plugindesc v1.20 Plugin supports Tiled Map Editor maps with some additional

* features.

* @author Dr.Yami

* @param Z - Player

* @desc Z Index for Same as Characters events and Players.

* Default: 3

* @default 3

* @param Z - Below Player

* @desc Z Index for Below Characters events.

* Default: 1

* @default 1

* @param Z - Above Player

* @desc Z Index for Above Characters events.

* Default: 5

* @default 5

* @param Half-tile movement

* @desc Moving and collision checking by half a tile.

* Can be true or false

* @default true

* @param Priority Tiles Limit

* @desc Limit for priority tile sprites.

* Should not be too large.

* @default 256

* @param Map Level Variable

* @desc Get and set map level by variable

* @default 0

* @help

* Use these properties in Tiled Map's layer:

* zIndex

* The layer will have z-index == property's value

* collision

* The layer will be collision mask layer. Use one of these value:

* full - Normal collision (1 full-tile)

* arrow - Arrow collision

* up-left - Half-tile collision up-left quarter

* up-right - Half-tile collision up-right quarter

* down-left - Half-tile collision down-left quarter

* down-right - Half-tile collision down-right quarter

* arrowImpassable

* If the layer is an arraw collision mask layer, it will make one direction be impassable

* Value can be up, down, left, right

* regionId

* Mark the layer as region layer, the layer ID will be the value of property

* priority

* Mark the layer as priority layer, allows it goes above player when player is behind,

* below player when player is in front of. Value should be > 0, zIndex should be

* the same as player z-index.

* level

* Mark the layer on different level, use for multiple levels map (for example a bridge).

* Default level is 0. Use this for collision and regionId.

* hideOnLevel

* Hide the layer when on a certain level.

* toLevel

* The tiles on this layer will transfer player to another level.

/******/ (function(modules) { // webpackBootstrap

/******/ // The module cache

/******/ var installedModules = {};

/******/ // The require function

/******/ function __webpack_require__(moduleId) {

/******/ // Check if module is in cache

/******/ if(installedModules[moduleId])

/******/ return installedModules[moduleId].exports;

/******/ // Create a new module (and put it into the cache)

/******/ var module = installedModules[moduleId] = {

/******/ exports: {},

/******/ id: moduleId,

/******/ loaded: false

/******/ };

/******/ // Execute the module function

/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ // Flag the module as loaded

/******/ module.loaded = true;

/******/ // Return the exports of the module

/******/ return module.exports;

/******/ }

/******/ // expose the modules object (__webpack_modules__)

/******/ __webpack_require__.m = modules;

/******/ // expose the module cache

/******/ __webpack_require__.c = installedModules;

/******/ // __webpack_public_path__

/******/ __webpack_require__.p = "";

/******/ // Load entry module and return exports

/******/ return __webpack_require__(0);

/******/ })

/************************************************************************/

/******/ ({

/***/ 0:

/***/ function(module, exports, __webpack_require__) {

"use strict";

__webpack_require__(73);

__webpack_require__(74);

var _TiledTilemap = __webpack_require__(75);

__webpack_require__(76);

__webpack_require__(77);

__webpack_require__(78);

__webpack_require__(79);

/***/ },

/***/ 73:

/***/ function(module, exports) {

"use strict";

DataManager._tempTiledData = null;

DataManager._tiledLoaded = false;

DataManager._tilesetToLoad = 0;

var _loadMapData = DataManager.loadMapData;

DataManager.loadMapData = function (mapId) {

_loadMapData.call(this, mapId);

if (mapId > 0) {

this.loadTiledMapData(mapId);

} else {

this.unloadTiledMapData();

}

};

DataManager.loadTiledMapData = function (mapId) {

var xhr = new XMLHttpRequest();

xhr.open('GET', "./maps/Map" + mapId + ".json");

xhr.overrideMimeType('application/json');

// on success callback

xhr.onreadystatechange = function () {

if (xhr.readyState === 4) {

if (xhr.status === 200 || xhr.responseText !== "") {

DataManager._tempTiledData = JSON.parse(xhr.responseText);

}

DataManager.loadTilesetData();

DataManager._tiledLoaded = true;

}

};

// set data to null and send request

this.unloadTiledMapData();

xhr.send();

};

DataManager.loadTilesetData = function () {

var _iteratorNormalCompletion = true;

var _didIteratorError = false;

var _iteratorError = undefined;

try {

var _loop = function _loop() {

var tileset = _step.value;

if (!tileset.source) {

return "continue";

}

DataManager._tilesetToLoad++;

var filename = tileset.source.replace(/^.*[\\\/]/, '');

var xhr = new XMLHttpRequest();

xhr.open('GET', "./maps/" + filename);

xhr.overrideMimeType('application/json');

xhr.onreadystatechange = function () {

if (xhr.readyState === 4) {

if (xhr.status === 200 || xhr.responseText !== "") {

Object.assign(tileset, JSON.parse(xhr.responseText));

}

DataManager._tilesetToLoad--;

}

};

xhr.send();

};

for (var _iterator = DataManager._tempTiledData.tilesets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {

var _ret = _loop();

if (_ret === "continue") continue;

}

} catch (err) {

_didIteratorError = true;

_iteratorError = err;

} finally {

try {

if (!_iteratorNormalCompletion && _iterator.return) {

_iterator.return();

}

} finally {

if (_didIteratorError) {

throw _iteratorError;

}

};

DataManager.unloadTiledMapData = function () {

DataManager._tempTiledData = null;

DataManager._tiledLoaded = false;

DataManager._tilesetToLoad = 0;

};

var _isMapLoaded = DataManager.isMapLoaded;

DataManager.isMapLoaded = function () {

var defaultLoaded = _isMapLoaded.call(this);

var tiledLoaded = DataManager._tiledLoaded;

var tilesetLoaded = DataManager._tilesetToLoad <= 0;

return defaultLoaded && tiledLoaded;

return defaultLoaded && tiledLoaded && tilesetLoaded;

};

/***/ },

/***/ 74:

/***/ function(module, exports) {

"use strict";

ImageManager.loadParserTileset = function (path, hue) {

if (!path) {

return this.loadEmptyBitmap();

}

var paths = path.split("/");

var filename = paths[paths.length - 1];

var realPath = "img/tilesets/" + filename;

return this.loadNormalBitmap(realPath, hue);

};

ImageManager.loadParserParallax = function (path, hue) {

if (!path) {

return this.loadEmptyBitmap();

}

var paths = path.split("/");

var filename = paths[paths.length - 1];

var realPath = "img/parallaxes/" + filename;

return this.loadNormalBitmap(realPath, hue);

};

/***/ },

/***/ 75:

/***/ function(module, exports) {

'use strict';

Object.defineProperty(exports, "__esModule", {

value: true

});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

var TiledTilemap = exports.TiledTilemap = function (_ShaderTilemap) {

_inherits(TiledTilemap, _ShaderTilemap);

function TiledTilemap() {

_classCallCheck(this, TiledTilemap);

return _possibleConstructorReturn(this, (TiledTilemap.__proto__ || Object.getPrototypeOf(TiledTilemap)).apply(this, arguments));

}

_createClass(TiledTilemap, [{

key: 'initialize',

value: function initialize(tiledData) {

this._tiledData = {};

this._layers = [];

this._priorityTiles = [];

this._priorityTilesCount = 0;

this.tiledData = tiledData;

_get(TiledTilemap.prototype.__proto__ || Object.getPrototypeOf(TiledTilemap.prototype), 'initialize', this).call(this);

this.setupTiled();

}

}, {

key: 'setupTiled',

value: function setupTiled() {

this._setupSize();

this._setupAnim();

}

}, {

key: '_setupSize',

value: function _setupSize() {

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;

this._tileWidth = this.tiledData.tilewidth;

this._tileHeight = this.tiledData.tileheight;

this._layerWidth = tileCols * this._tileWidth;

this._layerHeight = tileRows * this._tileHeight;

this._mapWidth = this.tiledData.width;

this._mapHeight = this.tiledData.height;

}

}, {

key: '_setupAnim',

value: function _setupAnim() {

this._animFrame = {};

this._animDuration = {};

}

}, {

key: '_createLayers',

value: function _createLayers() {

var id = 0;

this._needsRepaint = true;

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

var useSquareShader = Number(parameters.hasOwnProperty('squareShader') ? parameters['squareShader'] : 1);

var _iteratorNormalCompletion = true;

var _didIteratorError = false;

var _iteratorError = undefined;

try {

for (var _iterator = this.tiledData.layers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {

var layerData = _step.value;

var zIndex = 0;

if (layerData.type != "tilelayer") {

id++;

continue;

}

if (!!layerData.properties && !!layerData.properties.zIndex) {

zIndex = parseInt(layerData.properties.zIndex);

}

if (!!layerData.properties && !!layerData.properties.collision) {

id++;

continue;

}

if (!!layerData.properties && !!layerData.properties.toLevel) {

id++;

continue;

}

if (!!layerData.properties && !!layerData.properties.regionId) {

id++;

continue;

}

var layer = new PIXI.tilemap.CompositeRectTileLayer(zIndex, [], useSquareShader);

layer.layerId = id; // @dryami: hack layer index

layer.spriteId = Sprite._counter++;

this._layers.push(layer);

this.addChild(layer);

id++;

}

} catch (err) {

_didIteratorError = true;

_iteratorError = err;

} finally {

try {

if (!_iteratorNormalCompletion && _iterator.return) {

_iterator.return();

}

} finally {

if (_didIteratorError) {

throw _iteratorError;

}

this._createPriorityTiles();

}

}, {

key: '_createPriorityTiles',

value: function _createPriorityTiles() {

var pluginParams = PluginManager.parameters("YED_Tiled");

var size = parseInt(pluginParams["Priority Tiles Limit"]);

var zIndex = parseInt(pluginParams["Z - Player"]);

var _iteratorNormalCompletion2 = true;

var _didIteratorError2 = false;

var _iteratorError2 = undefined;

try {

for (var _iterator2 = Array(size).keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {

var x = _step2.value;

var sprite = new Sprite_Base();

sprite.z = sprite.zIndex = zIndex;

sprite.layerId = -1;

sprite.hide();

this.addChild(sprite);

this._priorityTiles.push(sprite);

}

} catch (err) {

_didIteratorError2 = true;

_iteratorError2 = err;

} finally {

try {

if (!_iteratorNormalCompletion2 && _iterator2.return) {

_iterator2.return();

}

} finally {

if (_didIteratorError2) {

throw _iteratorError2;

}

}, {

key: '_hackRenderer',

value: function _hackRenderer(renderer) {

return renderer;

}

}, {

key: 'refreshTileset',

value: function refreshTileset() {

var bitmaps = this.bitmaps.map(function (x) {

return x._baseTexture ? new PIXI.Texture(x._baseTexture) : x;

});

var _iteratorNormalCompletion3 = true;

var _didIteratorError3 = false;

var _iteratorError3 = undefined;

try {

for (var _iterator3 = this._layers[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {

var layer = _step3.value;

layer.setBitmaps(bitmaps);

}

} catch (err) {

_didIteratorError3 = true;

_iteratorError3 = err;

} finally {

try {

if (!_iteratorNormalCompletion3 && _iterator3.return) {

_iterator3.return();

}

} finally {

if (_didIteratorError3) {

throw _iteratorError3;

}

}, {

key: 'update',

value: function update() {

_get(TiledTilemap.prototype.__proto__ || Object.getPrototypeOf(TiledTilemap.prototype), 'update', this).call(this);

this._updateAnim();

}

}, {

key: '_updateAnim',

value: function _updateAnim() {

var needRefresh = false;

for (var key in this._animDuration) {

this._animDuration[key] -= 1;

if (this._animDuration[key] <= 0) {

this._animFrame[key] += 1;

needRefresh = true;

}

if (needRefresh) {

this.refresh();

}

}, {

key: '_updateLayerPositions',

value: function _updateLayerPositions(startX, startY) {

var ox = 0;

var oy = 0;

if (this.roundPixels) {

ox = Math.floor(this.origin.x);

oy = Math.floor(this.origin.y);

} else {

ox = this.origin.x;

oy = this.origin.y;

}

var _iteratorNormalCompletion4 = true;

var _didIteratorError4 = false;

var _iteratorError4 = undefined;

try {

for (var _iterator4 = this._layers[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {

var layer = _step4.value;

var layerData = this.tiledData.layers[layer.layerId];

var offsetX = layerData.offsetx || 0;

var offsetY = layerData.offsety || 0;

layer.position.x = startX * this._tileWidth - ox + offsetX;

layer.position.y = startY * this._tileHeight - oy + offsetY;

}

} catch (err) {

_didIteratorError4 = true;

_iteratorError4 = err;

} finally {

try {

if (!_iteratorNormalCompletion4 && _iterator4.return) {

_iterator4.return();

}

} finally {

if (_didIteratorError4) {

throw _iteratorError4;

}

var _iteratorNormalCompletion5 = true;

var _didIteratorError5 = false;

var _iteratorError5 = undefined;

try {

for (var _iterator5 = this._priorityTiles[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {

var sprite = _step5.value;

var _layerData = this.tiledData.layers[sprite.layerId];

var _offsetX = _layerData ? _layerData.offsetx || 0 : 0;

var _offsetY = _layerData ? _layerData.offsety || 0 : 0;

sprite.x = sprite.origX + startX * this._tileWidth - ox + _offsetX + sprite.width / 2;

sprite.y = sprite.origY + startY * this._tileHeight - oy + _offsetY + sprite.height;

}

} catch (err) {

_didIteratorError5 = true;

_iteratorError5 = err;

} finally {

try {

if (!_iteratorNormalCompletion5 && _iterator5.return) {

_iterator5.return();

}

} finally {

if (_didIteratorError5) {

throw _iteratorError5;

}

}, {

key: '_paintAllTiles',

value: function _paintAllTiles(startX, startY) {

this._priorityTilesCount = 0;

var _iteratorNormalCompletion6 = true;

var _didIteratorError6 = false;

var _iteratorError6 = undefined;

try {

for (var _iterator6 = this._layers[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {

var layer = _step6.value;

layer.clear();

this._paintTiles(layer, startX, startY);

}

} catch (err) {

_didIteratorError6 = true;

_iteratorError6 = err;

} finally {

try {

if (!_iteratorNormalCompletion6 && _iterator6.return) {

_iterator6.return();

}

} finally {

if (_didIteratorError6) {

throw _iteratorError6;

}

var id = 0;

var _iteratorNormalCompletion7 = true;

var _didIteratorError7 = false;

var _iteratorError7 = undefined;

try {

for (var _iterator7 = this.tiledData.layers[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {

var layerData = _step7.value;

if (layerData.type != "objectgroup") {

id++;

continue;

}

this._paintObjectLayers(id, startX, startY);

id++;

}

} catch (err) {

_didIteratorError7 = true;

_iteratorError7 = err;

} finally {

try {

if (!_iteratorNormalCompletion7 && _iterator7.return) {

_iterator7.return();

}

} finally {

if (_didIteratorError7) {

throw _iteratorError7;

}

while (this._priorityTilesCount < this._priorityTiles.length) {

var sprite = this._priorityTiles[this._priorityTilesCount];

sprite.hide();

sprite.layerId = -1;

this._priorityTilesCount++;

}

}, {

key: '_paintTiles',

value: function _paintTiles(layer, startX, startY) {

var layerData = this.tiledData.layers[layer.layerId];

if (!layerData.visible) {

return;

}

if (layerData.type == "tilelayer") {

this._paintTilesLayer(layer, startX, startY);

}

}, {

key: '_paintObjectLayers',

value: function _paintObjectLayers(layerId, startX, startY) {

var layerData = this.tiledData.layers[layerId];

var objects = layerData.objects || [];

var _iteratorNormalCompletion8 = true;

var _didIteratorError8 = false;

var _iteratorError8 = undefined;

try {

for (var _iterator8 = objects[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {

var obj = _step8.value;

if (!obj.gid) {

continue;

}

if (!obj.visible) {

continue;

}

var tileId = obj.gid;

var textureId = this._getTextureId(tileId);

var dx = obj.x - startX * this._tileWidth;

var dy = obj.y - startY * this._tileHeight - obj.height;

this._paintPriorityTile(layerId, textureId, tileId, startX, startY, dx, dy);

}

} catch (err) {

_didIteratorError8 = true;

_iteratorError8 = err;

} finally {

} finall

try {

if (!_iteratorNormalCompletion8 && _iterator8.return) {

_iterator8.return();

}

} finally {

if (_didIteratorError8) {

throw _iteratorError8;

}

}, {

key: '_paintTilesLayer',

value: function _paintTilesLayer(layer, startX, startY) {

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

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

var _iteratorNormalCompletion9 = true;

var _didIteratorError9 = false;

var _iteratorError9 = undefined;

try {

for (var _iterator9 = Array(tileRows).keys()[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {

var y = _step9.value;

var _iteratorNormalCompletion10 = true;

var _didIteratorError10 = false;

var _iteratorError10 = undefined;

try {

for (var _iterator10 = Array(tileCols).keys()[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {

var x = _step10.value;

this._paintTile(layer, startX, startY, x, y);

}

} catch (err) {

_didIteratorError10 = true;

_iteratorError10 = err;

} finally {

try {

if (!_iteratorNormalCompletion10 &&

Gespeicherten Diffs

Original text

Datei öffnen

/*:
 * @plugindesc v1.10 Plugin supports Tiled Map Editor maps with some additional
 * features.
 * @author Dr.Yami
 *
 * @param Z - Player
 * @desc Z Index for Same as Characters events and Players.
 * Default: 3
 * @default 3
 *
 * @param Z - Below Player
 * @desc Z Index for Below Characters events.
 * Default: 1
 * @default 1
 *
 * @param Z - Above Player
 * @desc Z Index for Above Characters events.
 * Default: 5
 * @default 5
 *
 * @param Half-tile movement
 * @desc Moving and collision checking by half a tile.
 * Can be true or false
 * @default true
 *
 * @param Priority Tiles Limit
 * @desc Limit for priority tile sprites.
 * Should not be too large.
 * @default 256
 *
 * @param Map Level Variable
 * @desc Get and set map level by variable
 * @default 0
 *
 * @help
 * Use these properties in Tiled Map's layer:
 *   zIndex
 *   The layer will have z-index == property's value
 *
 *   collision
 *   The layer will be collision mask layer. Use one of these value:
 *     full - Normal collision (1 full-tile)
 *     arrow - Arrow collision
 *     up-left - Half-tile collision up-left quarter
 *     up-right - Half-tile collision up-right quarter
 *     down-left - Half-tile collision down-left quarter
 *     down-right - Half-tile collision down-right quarter
 *
 *   arrowImpassable
 *   If the layer is an arraw collision mask layer, it will make one direction be impassable
 *   Value can be up, down, left, right
 *
 *   regionId
 *   Mark the layer as region layer, the layer ID will be the value of property
 *
 *   priority
 *   Mark the layer as priority layer, allows it goes above player when player is behind,
 *   below player when player is in front of. Value should be > 0, zIndex should be
 *   the same as player z-index.
 *
 *   level
 *   Mark the layer on different level, use for multiple levels map (for example a bridge).
 *   Default level is 0. Use this for collision and regionId.
 *
 *   hideOnLevel
 *   Hide the layer when on a certain level.
 *
 *   toLevel
 *   The tiles on this layer will transfer player to another level.
 */
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

"use strict";

__webpack_require__(73);

__webpack_require__(74);

var _TiledTilemap = __webpack_require__(75);

__webpack_require__(76);

__webpack_require__(77);

__webpack_require__(78);

__webpack_require__(79);

/***/ },

/***/ 73:
/***/ function(module, exports) {

"use strict";

DataManager._tempTiledData = null;
	DataManager._tiledLoaded = false;

DataManager.loadTiledMapData = function (mapId) {
	    var xhr = new XMLHttpRequest();
	    xhr.open('GET', "./maps/Map" + mapId + ".json");
	    xhr.overrideMimeType('application/json');

// on success callback
	    xhr.onreadystatechange = function () {
	        if (xhr.readyState === 4) {
	            if (xhr.status === 200 || xhr.responseText !== "") {
	                DataManager._tempTiledData = JSON.parse(xhr.responseText);
	            }
	            DataManager._tiledLoaded = true;
	        }
	    };

// set data to null and send request
	    this.unloadTiledMapData();
	    xhr.send();
	};

DataManager.unloadTiledMapData = function () {
	    DataManager._tempTiledData = null;
	    DataManager._tiledLoaded = false;
	};

var _isMapLoaded = DataManager.isMapLoaded;
	DataManager.isMapLoaded = function () {
	    var defaultLoaded = _isMapLoaded.call(this);
	    var tiledLoaded = DataManager._tiledLoaded;

return defaultLoaded && tiledLoaded;
	};

/***/ },

/***/ 74:
/***/ function(module, exports) {

"use strict";

ImageManager.loadParserTileset = function (path, hue) {
	    if (!path) {
	        return this.loadEmptyBitmap();
	    }
	    var paths = path.split("/");
	    var filename = paths[paths.length - 1];
	    var realPath = "img/tilesets/" + filename;

return this.loadNormalBitmap(realPath, hue);
	};

ImageManager.loadParserParallax = function (path, hue) {
	    if (!path) {
	        return this.loadEmptyBitmap();
	    }
	    var paths = path.split("/");
	    var filename = paths[paths.length - 1];
	    var realPath = "img/parallaxes/" + filename;

return this.loadNormalBitmap(realPath, hue);
	};

/***/ },

/***/ 75:
/***/ function(module, exports) {

'use strict';

Object.defineProperty(exports, "__esModule", {
	    value: true
	});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var TiledTilemap = exports.TiledTilemap = function (_ShaderTilemap) {
	    _inherits(TiledTilemap, _ShaderTilemap);

function TiledTilemap() {
	        _classCallCheck(this, TiledTilemap);

return _possibleConstructorReturn(this, (TiledTilemap.__proto__ || Object.getPrototypeOf(TiledTilemap)).apply(this, arguments));
	    }

_createClass(TiledTilemap, [{
	        key: 'initialize',
	        value: function initialize(tiledData) {
	            this._tiledData = {};
	            this._layers = [];
	            this._priorityTiles = [];
	            this._priorityTilesCount = 0;
	            this.tiledData = tiledData;
	            _get(TiledTilemap.prototype.__proto__ || Object.getPrototypeOf(TiledTilemap.prototype), 'initialize', this).call(this);
	            this.setupTiled();
	        }
	    }, {
	        key: 'setupTiled',
	        value: function setupTiled() {
	            this._setupSize();
	            this._setupAnim();
	        }
	    }, {
	        key: '_setupSize',
	        value: function _setupSize() {
	            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;
	            this._tileWidth = this.tiledData.tilewidth;
	            this._tileHeight = this.tiledData.tileheight;
	            this._layerWidth = tileCols * this._tileWidth;
	            this._layerHeight = tileRows * this._tileHeight;
	            this._mapWidth = this.tiledData.width;
	            this._mapHeight = this.tiledData.height;
	        }
	    }, {
	        key: '_setupAnim',
	        value: function _setupAnim() {
	            this._animFrame = {};
	            this._animDuration = {};
	        }
	    }, {
	        key: '_createLayers',
	        value: function _createLayers() {
	            var id = 0;
	            this._needsRepaint = true;

var parameters = PluginManager.parameters('ShaderTilemap');
	            var useSquareShader = Number(parameters.hasOwnProperty('squareShader') ? parameters['squareShader'] : 1);

var _iteratorNormalCompletion = true;
	            var _didIteratorError = false;
	            var _iteratorError = undefined;

try {
	                for (var _iterator = this.tiledData.layers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
	                    var layerData = _step.value;

var zIndex = 0;
	                    if (layerData.type != "tilelayer") {
	                        id++;
	                        continue;
	                    }

if (!!layerData.properties && !!layerData.properties.zIndex) {
	                        zIndex = parseInt(layerData.properties.zIndex);
	                    }

if (!!layerData.properties && !!layerData.properties.collision) {
	                        id++;
	                        continue;
	                    }

if (!!layerData.properties && !!layerData.properties.toLevel) {
	                        id++;
	                        continue;
	                    }

if (!!layerData.properties && !!layerData.properties.regionId) {
	                        id++;
	                        continue;
	                    }

this._createPriorityTiles();
	        }
	    }, {
	        key: '_createPriorityTiles',
	        value: function _createPriorityTiles() {
	            var pluginParams = PluginManager.parameters("YED_Tiled");
	            var size = parseInt(pluginParams["Priority Tiles Limit"]);
	            var zIndex = parseInt(pluginParams["Z - Player"]);
	            var _iteratorNormalCompletion2 = true;
	            var _didIteratorError2 = false;
	            var _iteratorError2 = undefined;

try {
	                for (var _iterator2 = Array(size).keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
	                    var x = _step2.value;

try {
	                for (var _iterator3 = this._layers[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
	                    var layer = _step3.value;

layer.setBitmaps(bitmaps);
	                }
	            } catch (err) {
	                _didIteratorError3 = true;
	                _iteratorError3 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
	                        _iterator3.return();
	                    }
	                } finally {
	                    if (_didIteratorError3) {
	                        throw _iteratorError3;
	                    }
	                }
	            }
	        }
	    }, {
	        key: 'update',
	        value: function update() {
	            _get(TiledTilemap.prototype.__proto__ || Object.getPrototypeOf(TiledTilemap.prototype), 'update', this).call(this);
	            this._updateAnim();
	        }
	    }, {
	        key: '_updateAnim',
	        value: function _updateAnim() {
	            var needRefresh = false;
	            for (var key in this._animDuration) {
	                this._animDuration[key] -= 1;
	                if (this._animDuration[key] <= 0) {
	                    this._animFrame[key] += 1;
	                    needRefresh = true;
	                }
	            }

if (needRefresh) {
	                this.refresh();
	            }
	        }
	    }, {
	        key: '_updateLayerPositions',
	        value: function _updateLayerPositions(startX, startY) {
	            var ox = 0;
	            var oy = 0;
	            if (this.roundPixels) {
	                ox = Math.floor(this.origin.x);
	                oy = Math.floor(this.origin.y);
	            } else {
	                ox = this.origin.x;
	                oy = this.origin.y;
	            }

var _iteratorNormalCompletion4 = true;
	            var _didIteratorError4 = false;
	            var _iteratorError4 = undefined;

try {
	                for (var _iterator4 = this._layers[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
	                    var layer = _step4.value;

var _iteratorNormalCompletion5 = true;
	            var _didIteratorError5 = false;
	            var _iteratorError5 = undefined;

try {
	                for (var _iterator5 = this._priorityTiles[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
	                    var sprite = _step5.value;

try {
	                for (var _iterator6 = this._layers[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
	                    var layer = _step6.value;

layer.clear();
	                    this._paintTiles(layer, startX, startY);
	                }
	            } catch (err) {
	                _didIteratorError6 = true;
	                _iteratorError6 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
	                        _iterator6.return();
	                    }
	                } finally {
	                    if (_didIteratorError6) {
	                        throw _iteratorError6;
	                    }
	                }
	            }

var id = 0;
	            var _iteratorNormalCompletion7 = true;
	            var _didIteratorError7 = false;
	            var _iteratorError7 = undefined;

try {
	                for (var _iterator7 = this.tiledData.layers[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
	                    var layerData = _step7.value;

if (layerData.type != "objectgroup") {
	                        id++;
	                        continue;
	                    }
	                    this._paintObjectLayers(id, startX, startY);
	                    id++;
	                }
	            } catch (err) {
	                _didIteratorError7 = true;
	                _iteratorError7 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion7 && _iterator7.return) {
	                        _iterator7.return();
	                    }
	                } finally {
	                    if (_didIteratorError7) {
	                        throw _iteratorError7;
	                    }
	                }
	            }

while (this._priorityTilesCount < this._priorityTiles.length) {
	                var sprite = this._priorityTiles[this._priorityTilesCount];
	                sprite.hide();
	                sprite.layerId = -1;
	                this._priorityTilesCount++;
	            }
	        }
	    }, {
	        key: '_paintTiles',
	        value: function _paintTiles(layer, startX, startY) {
	            var layerData = this.tiledData.layers[layer.layerId];

if (!layerData.visible) {
	                return;
	            }

if (layerData.type == "tilelayer") {
	                this._paintTilesLayer(layer, startX, startY);
	            }
	        }
	    }, {
	        key: '_paintObjectLayers',
	        value: function _paintObjectLayers(layerId, startX, startY) {
	            var layerData = this.tiledData.layers[layerId];
	            var objects = layerData.objects || [];

var _iteratorNormalCompletion8 = true;
	            var _didIteratorError8 = false;
	            var _iteratorError8 = undefined;

try {
	                for (var _iterator8 = objects[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
	                    var obj = _step8.value;

if (!obj.gid) {
	                        continue;
	                    }
	                    if (!obj.visible) {
	                        continue;
	                    }
	                    var tileId = obj.gid;
	                    var textureId = this._getTextureId(tileId);
	                    var dx = obj.x - startX * this._tileWidth;
	                    var dy = obj.y - startY * this._tileHeight - obj.height;
	                    this._paintPriorityTile(layerId, textureId, tileId, startX, startY, dx, dy);
	                }
	            } catch (err) {
	                _didIteratorError8 = true;
	                _iteratorError8 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion8 && _iterator8.return) {
	                        _iterator8.return();
	                    }
	                } finally {
	                    if (_didIteratorError8) {
	                        throw _iteratorError8;
	                    }
	                }
	            }
	        }
	    }, {
	        key: '_paintTilesLayer',
	        value: function _paintTilesLayer(layer, startX, startY) {
	            var tileCols = Math.ceil(this._width / this._tileWidth) + 1;
	            var tileRows = Math.ceil(this._height / this._tileHeight) + 1;

var _iteratorNormalCompletion9 = true;
	            var _didIteratorError9 = false;
	            var _iteratorError9 = undefined;

try {
	                for (var _iterator9 = Array(tileRows).keys()[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
	                    var y = _step9.value;
	                    var _iteratorNormalCompletion10 = true;
	                    var _didIteratorError10 = false;
	                    var _iteratorError10 = undefined;

try {
	                        for (var _iterator10 = Array(tileCols).keys()[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
	                            var x = _step10.value;

this._paintTile(layer, startX, startY, x, y);
	                        }
	                    } catch (err) {
	                        _didIteratorError10 = true;
	                        _iteratorError10 = err;
	                    } finally {
	                        try {
	                            if (!_iteratorNormalCompletion10 && _iterator10.return) {
	                                _iterator10.return();
	                            }
	                        } finally {
	                            if (_didIteratorError10) {
	                                throw _iteratorError10;
	                            }
	                        }
	                    }
	                }
	            } catch (err) {
	                _didIteratorError9 = true;
	                _iteratorError9 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion9 && _iterator9.return) {
	                        _iterator9.return();
	                    }
	                } finally {
	                    if (_didIteratorError9) {
	                        throw _iteratorError9;
	                    }
	                }
	            }
	        }
	    }, {
	        key: '_paintTile',
	        value: function _paintTile(layer, startX, startY, x, y) {
	            var mx = x + startX;
	            var my = y + startY;
	            if (this.horizontalWrap) {
	                mx = mx.mod(this._mapWidth);
	            }
	            if (this.verticalWrap) {
	                my = my.mod(this._mapHeight);
	            }
	            var tilePosition = mx + my * this._mapWidth;
	            var tileId = this.tiledData.layers[layer.layerId].data[tilePosition];
	            var rectLayer = layer.children[0];
	            var textureId = 0;

if (!tileId) {
	                return;
	            }

// TODO: Problem with offsets
	            if (mx < 0 || mx >= this._mapWidth || my < 0 || my >= this._mapHeight) {
	                return;
	            }

textureId = this._getTextureId(tileId);

var tileset = this.tiledData.tilesets[textureId];
	            var dx = x * this._tileWidth;
	            var dy = y * this._tileHeight;
	            var w = tileset.tilewidth;
	            var h = tileset.tileheight;
	            var tileCols = tileset.columns;
	            var rId = this._getAnimTileId(textureId, tileId - tileset.firstgid);
	            var ux = rId % tileCols * w;
	            var uy = Math.floor(rId / tileCols) * h;

if (this._isPriorityTile(layer.layerId)) {
	                this._paintPriorityTile(layer.layerId, textureId, tileId, startX, startY, dx, dy);
	                return;
	            }

rectLayer.addRect(textureId, ux, uy, dx, dy, w, h);
	        }
	    }, {
	        key: '_paintPriorityTile',
	        value: function _paintPriorityTile(layerId, textureId, tileId, startX, startY, dx, dy) {
	            var tileset = this.tiledData.tilesets[textureId];
	            var w = tileset.tilewidth;
	            var h = tileset.tileheight;
	            var tileCols = tileset.columns;
	            var rId = this._getAnimTileId(textureId, tileId - tileset.firstgid);
	            var ux = rId % tileCols * w;
	            var uy = Math.floor(rId / tileCols) * h;
	            var sprite = this._priorityTiles[this._priorityTilesCount];
	            var layerData = this.tiledData.layers[layerId];
	            var offsetX = layerData ? layerData.offsetx || 0 : 0;
	            var offsetY = layerData ? layerData.offsety || 0 : 0;
	            var ox = 0;
	            var oy = 0;
	            if (this.roundPixels) {
	                ox = Math.floor(this.origin.x);
	                oy = Math.floor(this.origin.y);
	            } else {
	                ox = this.origin.x;
	                oy = this.origin.y;
	            }

if (this._priorityTilesCount >= this._priorityTiles.length) {
	                return;
	            }

sprite.layerId = layerId;
	            sprite.anchor.x = 0.5;
	            sprite.anchor.y = 1.0;
	            sprite.origX = dx;
	            sprite.origY = dy;
	            sprite.x = sprite.origX + startX * this._tileWidth - ox + offsetX + w / 2;
	            sprite.y = sprite.origY + startY * this._tileHeight - oy + offsetY + h;
	            sprite.bitmap = this.bitmaps[textureId];
	            sprite.setFrame(ux, uy, w, h);
	            sprite.priority = this._getPriority(layerId);
	            sprite.z = sprite.zIndex = this._getZIndex(layerId);
	            sprite.show();

this._priorityTilesCount += 1;
	        }
	    }, {
	        key: '_getTextureId',
	        value: function _getTextureId(tileId) {
	            var textureId = 0;
	            var _iteratorNormalCompletion11 = true;
	            var _didIteratorError11 = false;
	            var _iteratorError11 = undefined;

try {
	                for (var _iterator11 = this.tiledData.tilesets[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
	                    var tileset = _step11.value;

if (tileId < tileset.firstgid || tileId >= tileset.firstgid + tileset.tilecount) {
	                        textureId++;
	                        continue;
	                    }
	                    break;
	                }
	            } catch (err) {
	                _didIteratorError11 = true;
	                _iteratorError11 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion11 && _iterator11.return) {
	                        _iterator11.return();
	                    }
	                } finally {
	                    if (_didIteratorError11) {
	                        throw _iteratorError11;
	                    }
	                }
	            }

return textureId;
	        }
	    }, {
	        key: '_getAnimTileId',
	        value: function _getAnimTileId(textureId, tileId) {
	            var tilesData = this.tiledData.tilesets[textureId].tiles;
	            var tileset = this.tiledData.tilesets[textureId];
	            var keyId = tileId + tileset.firstgid;
	            if (!tilesData) {
	                return tileId;
	            }
	            if (!tilesData[tileId]) {
	                return tileId;
	            }
	            if (!tilesData[tileId].animation) {
	                return tileId;
	            }
	            var animation = tilesData[tileId].animation;
	            this._animFrame[keyId] = this._animFrame[keyId] || 0;
	            var frame = this._animFrame[keyId];
	            this._animFrame[keyId] = !!animation[frame] ? frame : 0;
	            frame = this._animFrame[keyId];
	            var duration = animation[frame].duration / 1000 * 60;
	            this._animDuration[keyId] = this._animDuration[keyId] || duration;
	            if (this._animDuration[keyId] <= 0) {
	                this._animDuration[keyId] = duration;
	            }
	            return animation[frame].tileid;
	        }
	    }, {
	        key: '_getPriority',
	        value: function _getPriority(layerId) {
	            var layerData = this.tiledData.layers[layerId];
	            if (!layerData.properties) {
	                return 0;
	            }
	            if (!layerData.properties.priority) {
	                return 0;
	            }
	            return parseInt(layerData.properties.priority);
	        }
	    }, {
	        key: '_isPriorityTile',
	        value: function _isPriorityTile(layerId) {
	            var pluginParams = PluginManager.parameters("YED_Tiled");
	            var playerZIndex = parseInt(pluginParams["Z - Player"]);
	            var zIndex = this._getZIndex(layerId);
	            return this._getPriority(layerId) > 0 && zIndex === playerZIndex;
	        }
	    }, {
	        key: '_getZIndex',
	        value: function _getZIndex(layerId) {
	            var layerData = this.tiledData.layers[layerId];
	            if (!layerData) {
	                return 0;
	            }
	            if (!layerData.properties || !layerData.properties.zIndex) {
	                return 0;
	            }
	            return parseInt(layerData.properties.zIndex);
	        }
	    }, {
	        key: 'hideOnLevel',
	        value: function hideOnLevel(level) {
	            var layerIds = [];
	            var _iteratorNormalCompletion12 = true;
	            var _didIteratorError12 = false;
	            var _iteratorError12 = undefined;

try {
	                for (var _iterator12 = this._layers[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
	                    var layer = _step12.value;

var _iteratorNormalCompletion13 = true;
	            var _didIteratorError13 = false;
	            var _iteratorError13 = undefined;

try {
	                for (var _iterator13 = this._priorityTiles[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
	                    var sprite = _step13.value;

if (layerIds.indexOf(sprite.layerId) === -1) {
	                        continue;
	                    }
	                    sprite.visible = false;
	                }
	            } catch (err) {
	                _didIteratorError13 = true;
	                _iteratorError13 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion13 && _iterator13.return) {
	                        _iterator13.return();
	                    }
	                } finally {
	                    if (_didIteratorError13) {
	                        throw _iteratorError13;
	                    }
	                }
	            }
	        }
	    }, {
	        key: '_compareChildOrder',
	        value: function _compareChildOrder(a, b) {
	            if ((a.z || 0) !== (b.z || 0)) {
	                return (a.z || 0) - (b.z || 0);
	            } else if ((a.y || 0) !== (b.y || 0)) {
	                return (a.y || 0) - (b.y || 0);
	            } else if ((a.priority || 0) !== (b.priority || 0)) {
	                return (a.priority || 0) - (b.priority || 0);
	            } else {
	                return a.spriteId - b.spriteId;
	            }
	        }
	    }, {
	        key: 'tiledData',
	        get: function get() {
	            return this._tiledData;
	        },
	        set: function set(val) {
	            this._tiledData = val;
	            this.setupTiled();
	        }
	    }]);

return TiledTilemap;
	}(ShaderTilemap);

/***/ },

/***/ 76:
/***/ function(module, exports) {

'use strict';

Object.defineProperty(Game_Map.prototype, 'tiledData', {
	    get: function get() {
	        return DataManager._tempTiledData;
	    },
	    configurable: true
	});

Object.defineProperty(Game_Map.prototype, 'currentMapLevel', {
	    get: function get() {
	        var pluginParams = PluginManager.parameters("YED_Tiled");
	        var varID = parseInt(pluginParams["Map Level Variable"]);
	        if (!varID) {
	            return this._currentMapLevel;
	        } else {
	            return $gameVariables.value(varID);
	        }
	    },
	    set: function set(value) {
	        var pluginParams = PluginManager.parameters("YED_Tiled");
	        var varID = parseInt(pluginParams["Map Level Variable"]);
	        if (!varID) {
	            this._currentMapLevel = value;
	        } else {
	            $gameVariables.setValue(varID, value);
	        }
	    },
	    configurable: true
	});

var _setup = Game_Map.prototype.setup;
	Game_Map.prototype.setup = function (mapId) {
	    _setup.call(this, mapId);
	    this._collisionMap = [];
	    this._arrowCollisionMap = [];
	    this._regions = [];
	    this._mapLevelChange = [];
	    this._currentMapLevel = 0;
	    this.currentMapLevel = 0;
	    if (this.isTiledMap()) {
	        $dataMap.width = this.tiledData.width;
	        $dataMap.height = this.tiledData.height;
	        this._setupTiled();
	    }
	};

Game_Map.prototype.isTiledMap = function () {
	    return !!this.tiledData;
	};

Game_Map.prototype._setupTiled = function () {
	    this._initializeMapLevel(0);

this._setupCollision();
	    this._setupRegion();
	    this._setupMapLevelChange();
	    this._setupTiledEvents();
	};

Game_Map.prototype._initializeMapLevel = function (id) {
	    var width = this.width();
	    var height = this.height();
	    var size = width * height;

if (!!this._collisionMap[id]) {
	        return;
	    }

this._collisionMap[id] = [];
	    this._arrowCollisionMap[id] = [];
	    this._regions[id] = [];
	    this._mapLevelChange[id] = [];
	    var _iteratorNormalCompletion = true;
	    var _didIteratorError = false;
	    var _iteratorError = undefined;

try {
	        for (var _iterator = Array(size).keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
	            var x = _step.value;

this._collisionMap[id].push(0);
	            this._arrowCollisionMap[id].push(1 | 2 | 4 | 8);
	            this._regions[id].push(0);
	            this._mapLevelChange[id].push(-1);
	        }
	    } catch (err) {
	        _didIteratorError = true;
	        _iteratorError = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion && _iterator.return) {
	                _iterator.return();
	            }
	        } finally {
	            if (_didIteratorError) {
	                throw _iteratorError;
	            }
	        }
	    }
	};

Game_Map.prototype._setupCollision = function () {
	    this._setupCollisionFull();
	    this._setupCollisionArrow();
	};

Game_Map.prototype._setupCollisionFull = function () {
	    var width = this.width();
	    var height = this.height();
	    var size = width * height;
	    var halfWidth = width / 2;
	    var halfHeight = height / 2;

if (this.isHalfTile()) {
	        size /= 4;
	    }

var _iteratorNormalCompletion2 = true;
	    var _didIteratorError2 = false;
	    var _iteratorError2 = undefined;

try {
	        for (var _iterator2 = this.tiledData.layers[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
	            var layerData = _step2.value;

if (!layerData.properties || !layerData.properties.collision) {
	                continue;
	            }

if (layerData.properties.collision !== "full" && layerData.properties.collision !== "up-left" && layerData.properties.collision !== "up-right" && layerData.properties.collision !== "down-left" && layerData.properties.collision !== "down-right") {
	                continue;
	            }

var level = parseInt(layerData.properties.level) || 0;
	            this._initializeMapLevel(level);

var _iteratorNormalCompletion3 = true;
	            var _didIteratorError3 = false;
	            var _iteratorError3 = undefined;

try {
	                for (var _iterator3 = Array(size).keys()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
	                    var x = _step3.value;

try {
	                            for (var _iterator4 = ids[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
	                                var id = _step4.value;

this._collisionMap[level][id] = 1;
	                            }
	                        } catch (err) {
	                            _didIteratorError4 = true;
	                            _iteratorError4 = err;
	                        } finally {
	                            try {
	                                if (!_iteratorNormalCompletion4 && _iterator4.return) {
	                                    _iterator4.return();
	                                }
	                            } finally {
	                                if (_didIteratorError4) {
	                                    throw _iteratorError4;
	                                }
	                            }
	                        }
	                    }
	                }
	            } catch (err) {
	                _didIteratorError3 = true;
	                _iteratorError3 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
	                        _iterator3.return();
	                    }
	                } finally {
	                    if (_didIteratorError3) {
	                        throw _iteratorError3;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError2 = true;
	        _iteratorError2 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion2 && _iterator2.return) {
	                _iterator2.return();
	            }
	        } finally {
	            if (_didIteratorError2) {
	                throw _iteratorError2;
	            }
	        }
	    }
	};

Game_Map.prototype._setupCollisionArrow = function () {
	    var width = this.width();
	    var height = this.height();
	    var size = width * height;
	    var bit = 0;
	    var halfWidth = width / 2;
	    var halfHeight = height / 2;

if (this.isHalfTile()) {
	        size /= 4;
	    }

var _iteratorNormalCompletion5 = true;
	    var _didIteratorError5 = false;
	    var _iteratorError5 = undefined;

try {
	        for (var _iterator5 = this.tiledData.layers[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
	            var layerData = _step5.value;

if (!layerData.properties || !layerData.properties.collision) {
	                continue;
	            }

if (layerData.properties.collision !== "arrow") {
	                continue;
	            }

if (!layerData.properties.arrowImpassable) {
	                continue;
	            }

if (layerData.properties.arrowImpassable === "left") {
	                bit = 1;
	            }

if (layerData.properties.arrowImpassable === "up") {
	                bit = 2;
	            }

if (layerData.properties.arrowImpassable === "right") {
	                bit = 4;
	            }

if (layerData.properties.arrowImpassable === "down") {
	                bit = 8;
	            }

var level = parseInt(layerData.properties.level) || 0;
	            this._initializeMapLevel(level);
	            var arrowCollisionMap = this._arrowCollisionMap[level];
	            var _iteratorNormalCompletion6 = true;
	            var _didIteratorError6 = false;
	            var _iteratorError6 = undefined;

try {
	                for (var _iterator6 = Array(size).keys()[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
	                    var x = _step6.value;

var realX = x;
	                    if (this.isHalfTile()) {
	                        realX = Math.floor(x / halfWidth) * width * 2 + x % halfWidth * 2;
	                    }

if (!!layerData.data[x]) {
	                        arrowCollisionMap[realX] = arrowCollisionMap[realX] ^ bit;
	                        if (this.isHalfTile()) {
	                            arrowCollisionMap[realX + 1] = arrowCollisionMap[realX + 1] ^ bit;
	                            arrowCollisionMap[realX + width] = arrowCollisionMap[realX + width] ^ bit;
	                            arrowCollisionMap[realX + width + 1] = arrowCollisionMap[realX + width + 1] ^ bit;
	                        }
	                    }
	                }
	            } catch (err) {
	                _didIteratorError6 = true;
	                _iteratorError6 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
	                        _iterator6.return();
	                    }
	                } finally {
	                    if (_didIteratorError6) {
	                        throw _iteratorError6;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError5 = true;
	        _iteratorError5 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion5 && _iterator5.return) {
	                _iterator5.return();
	            }
	        } finally {
	            if (_didIteratorError5) {
	                throw _iteratorError5;
	            }
	        }
	    }
	};

Game_Map.prototype._setupRegion = function () {
	    var width = this.width();
	    var height = this.height();
	    var size = width * height;
	    var halfWidth = width / 2;
	    var halfHeight = height / 2;

if (this.isHalfTile()) {
	        size /= 4;
	    }

var _iteratorNormalCompletion7 = true;
	    var _didIteratorError7 = false;
	    var _iteratorError7 = undefined;

try {
	        for (var _iterator7 = this.tiledData.layers[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
	            var layerData = _step7.value;

if (!layerData.properties || !layerData.properties.regionId) {
	                continue;
	            }

var level = parseInt(layerData.properties.level) || 0;
	            this._initializeMapLevel(level);
	            var regionMap = this._regions[level];

var _iteratorNormalCompletion8 = true;
	            var _didIteratorError8 = false;
	            var _iteratorError8 = undefined;

try {
	                for (var _iterator8 = Array(size).keys()[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
	                    var x = _step8.value;

var realX = x;
	                    if (this.isHalfTile()) {
	                        realX = Math.floor(x / halfWidth) * width * 2 + x % halfWidth * 2;
	                    }

if (!!layerData.data[x]) {
	                        regionMap[realX] = parseInt(layerData.properties.regionId);
	                        if (this.isHalfTile()) {
	                            regionMap[realX + 1] = parseInt(layerData.properties.regionId);
	                            regionMap[realX + width] = parseInt(layerData.properties.regionId);
	                            regionMap[realX + width + 1] = parseInt(layerData.properties.regionId);
	                        }
	                    }
	                }
	            } catch (err) {
	                _didIteratorError8 = true;
	                _iteratorError8 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion8 && _iterator8.return) {
	                        _iterator8.return();
	                    }
	                } finally {
	                    if (_didIteratorError8) {
	                        throw _iteratorError8;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError7 = true;
	        _iteratorError7 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion7 && _iterator7.return) {
	                _iterator7.return();
	            }
	        } finally {
	            if (_didIteratorError7) {
	                throw _iteratorError7;
	            }
	        }
	    }
	};

Game_Map.prototype._setupMapLevelChange = function () {
	    var width = this.width();
	    var height = this.height();
	    var size = width * height;
	    var halfWidth = width / 2;
	    var halfHeight = height / 2;

if (this.isHalfTile()) {
	        size /= 4;
	    }

var _iteratorNormalCompletion9 = true;
	    var _didIteratorError9 = false;
	    var _iteratorError9 = undefined;

try {
	        for (var _iterator9 = this.tiledData.layers[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
	            var layerData = _step9.value;

if (!layerData.properties || !layerData.properties.toLevel) {
	                continue;
	            }

var level = parseInt(layerData.properties.level) || 0;
	            this._initializeMapLevel(level);
	            var levelChangeMap = this._mapLevelChange[level];

var _iteratorNormalCompletion10 = true;
	            var _didIteratorError10 = false;
	            var _iteratorError10 = undefined;

try {
	                for (var _iterator10 = Array(size).keys()[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
	                    var x = _step10.value;

var realX = x;
	                    var toLevel = parseInt(layerData.properties.toLevel);
	                    if (this.isHalfTile()) {
	                        realX = Math.floor(x / halfWidth) * width * 2 + x % halfWidth * 2;
	                    }

if (!!layerData.data[x]) {
	                        levelChangeMap[realX] = toLevel;
	                        if (this.isHalfTile()) {
	                            levelChangeMap[realX + 1] = toLevel;
	                            levelChangeMap[realX + width] = toLevel;
	                            levelChangeMap[realX + width + 1] = toLevel;
	                        }
	                    }
	                }
	            } catch (err) {
	                _didIteratorError10 = true;
	                _iteratorError10 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion10 && _iterator10.return) {
	                        _iterator10.return();
	                    }
	                } finally {
	                    if (_didIteratorError10) {
	                        throw _iteratorError10;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError9 = true;
	        _iteratorError9 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion9 && _iterator9.return) {
	                _iterator9.return();
	            }
	        } finally {
	            if (_didIteratorError9) {
	                throw _iteratorError9;
	            }
	        }
	    }
	};

Game_Map.prototype._setupTiledEvents = function () {
	    var _iteratorNormalCompletion11 = true;
	    var _didIteratorError11 = false;
	    var _iteratorError11 = undefined;

try {
	        for (var _iterator11 = this.tiledData.layers[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
	            var layerData = _step11.value;

if (layerData.type !== "objectgroup") {
	                continue;
	            }

var _iteratorNormalCompletion12 = true;
	            var _didIteratorError12 = false;
	            var _iteratorError12 = undefined;

try {
	                for (var _iterator12 = layerData.objects[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
	                    var object = _step12.value;

if (!object.properties) {
	                        continue;
	                    }

if (!object.properties.eventId) {
	                        continue;
	                    }

Game_Map.prototype.isHalfTile = function () {
	    var pluginParams = PluginManager.parameters("YED_Tiled");
	    return pluginParams["Half-tile movement"].toLowerCase() === "true";
	};

Game_Map.prototype.tileWidth = function () {
	    var tileWidth = this.tiledData.tilewidth;
	    if (this.isHalfTile()) {
	        tileWidth /= 2;
	    }
	    return tileWidth;
	};

Game_Map.prototype.tileHeight = function () {
	    var tileHeight = this.tiledData.tileheight;
	    if (this.isHalfTile()) {
	        tileHeight /= 2;
	    }
	    return tileHeight;
	};

Game_Map.prototype.width = function () {
	    var width = this.tiledData.width;
	    if (this.isHalfTile()) {
	        width *= 2;
	    }
	    return width;
	};

Game_Map.prototype.height = function () {
	    var height = this.tiledData.height;
	    if (this.isHalfTile()) {
	        height *= 2;
	    }
	    return height;
	};

var _regionId = Game_Map.prototype.regionId;
	Game_Map.prototype.regionId = function (x, y) {
	    if (!this.isTiledMap()) {
	        return _regionId.call(this, x, y);
	    }

var index = x + this.width() * y;
	    var regionMap = this._regions[this.currentMapLevel];

return regionMap[index];
	};

var _isPassable = Game_Map.prototype.isPassable;
	Game_Map.prototype.isPassable = function (x, y, d) {
	    if (!this.isTiledMap()) {
	        return _isPassable.call(this, x, y, d);
	    }

var index = x + this.width() * y;
	    var arrows = this._arrowCollisionMap[this.currentMapLevel];

if (d === 4) {
	        if (!(arrows[index] & 1)) {
	            return false;
	        }
	    }

if (d === 8) {
	        if (!(arrows[index] & 2)) {
	            return false;
	        }
	    }

if (d === 6) {
	        if (!(arrows[index] & 4)) {
	            return false;
	        }
	    }

if (d === 2) {
	        if (!(arrows[index] & 8)) {
	            return false;
	        }
	    }

return this._collisionMap[this.currentMapLevel][index] === 0;
	};

Game_Map.prototype.checkMapLevelChanging = function (x, y) {
	    var mapLevelChange = this._mapLevelChange[this.currentMapLevel];
	    var id = y * this.width() + x;
	    if (mapLevelChange[id] < 0) {
	        return false;
	    }
	    this.currentMapLevel = mapLevelChange[id];
	    return true;
	};

/***/ },

/***/ 77:
/***/ function(module, exports) {

"use strict";

Game_CharacterBase.prototype.screenZ = function () {
	    var pluginParams = PluginManager.parameters("YED_Tiled");
	    if (this._priorityType == 0) {
	        return parseInt(pluginParams["Z - Below Player"]);
	    }
	    if (this._priorityType == 2) {
	        return parseInt(pluginParams["Z - Above Player"]);
	    }
	    return parseInt(pluginParams["Z - Player"]);
	};

var _distancePerFrame = Game_CharacterBase.prototype.distancePerFrame;
	Game_CharacterBase.prototype.distancePerFrame = function () {
	    var distance = _distancePerFrame.call(this);
	    return distance * (48 / Math.min($gameMap.tileWidth(), $gameMap.tileHeight()));
	};

/***/ },

/***/ 78:
/***/ function(module, exports) {

"use strict";

var _checkEventTriggerHere = Game_Player.prototype.checkEventTriggerHere;
	Game_Player.prototype.checkEventTriggerHere = function (triggers) {
	    _checkEventTriggerHere.call(this, triggers);
	    this._checkMapLevelChangingHere();
	};

Game_Player.prototype._checkMapLevelChangingHere = function () {
	    $gameMap.checkMapLevelChanging(this.x, this.y);
	};

Game_Player.prototype.performTransfer = function () {
	    if (this.isTransferring()) {
	        this.setDirection(this._newDirection);
	        if (this._newMapId !== $gameMap.mapId() || this._needsMapReload || $gameMap.isTiledMap()) {
	            $gameMap.setup(this._newMapId);
	            this._needsMapReload = false;
	        }
	        this.locate(this._newX, this._newY);
	        this.refresh();
	        this.clearTransferInfo();
	    }
	};

/***/ },

/***/ 79:
/***/ function(module, exports, __webpack_require__) {

"use strict";

var _TiledTilemap = __webpack_require__(75);

var _createTilemap = Spriteset_Map.prototype.createTilemap;
	Spriteset_Map.prototype.createTilemap = function () {
	    if (!$gameMap.isTiledMap()) {
	        _createTilemap.call(this);
	        return;
	    }
	    this._tilemap = new _TiledTilemap.TiledTilemap($gameMap.tiledData);
	    this._tilemap.horizontalWrap = $gameMap.isLoopHorizontal();
	    this._tilemap.verticalWrap = $gameMap.isLoopVertical();
	    this.loadTileset();
	    this._baseSprite.addChild(this._tilemap);
	};

var _loadTileset = Spriteset_Map.prototype.loadTileset;
	Spriteset_Map.prototype.loadTileset = function () {
	    if (!$gameMap.isTiledMap()) {
	        _loadTileset.call(this);
	        return;
	    }

var i = 0;
	    var _iteratorNormalCompletion = true;
	    var _didIteratorError = false;
	    var _iteratorError = undefined;

try {
	        for (var _iterator = $gameMap.tiledData.tilesets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
	            var tileset = _step.value;

this._tilemap.bitmaps[i] = ImageManager.loadParserTileset(tileset.image, 0);
	            i++;
	        }
	    } catch (err) {
	        _didIteratorError = true;
	        _iteratorError = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion && _iterator.return) {
	                _iterator.return();
	            }
	        } finally {
	            if (_didIteratorError) {
	                throw _iteratorError;
	            }
	        }
	    }

this._tilemap.refreshTileset();
	    this._tileset = $gameMap.tiledData.tilesets;
	};

var _update = Spriteset_Map.prototype.update;
	Spriteset_Map.prototype.update = function () {
	    _update.call(this);
	    this._updateHideOnLevel();
	};

Spriteset_Map.prototype.updateTileset = function () {
	    if (this._tileset !== $gameMap.tiledData.tilesets) {
	        this.loadTileset();
	    }
	};

Spriteset_Map.prototype._updateHideOnLevel = function () {
	    this._tilemap.hideOnLevel($gameMap.currentMapLevel);
	};

/***/ }

/******/ });

Geänderter text

Datei öffnen

/*:
 * @plugindesc v1.20 Plugin supports Tiled Map Editor maps with some additional
 * features.
 * @author Dr.Yami
 *
 * @param Z - Player
 * @desc Z Index for Same as Characters events and Players.
 * Default: 3
 * @default 3
 *
 * @param Z - Below Player
 * @desc Z Index for Below Characters events.
 * Default: 1
 * @default 1
 *
 * @param Z - Above Player
 * @desc Z Index for Above Characters events.
 * Default: 5
 * @default 5
 *
 * @param Half-tile movement
 * @desc Moving and collision checking by half a tile.
 * Can be true or false
 * @default true
 *
 * @param Priority Tiles Limit
 * @desc Limit for priority tile sprites.
 * Should not be too large.
 * @default 256
 *
 * @param Map Level Variable
 * @desc Get and set map level by variable
 * @default 0
 *
 * @help
 * Use these properties in Tiled Map's layer:
 *   zIndex
 *   The layer will have z-index == property's value
 *
 *   collision
 *   The layer will be collision mask layer. Use one of these value:
 *     full - Normal collision (1 full-tile)
 *     arrow - Arrow collision
 *     up-left - Half-tile collision up-left quarter
 *     up-right - Half-tile collision up-right quarter
 *     down-left - Half-tile collision down-left quarter
 *     down-right - Half-tile collision down-right quarter
 *
 *   arrowImpassable
 *   If the layer is an arraw collision mask layer, it will make one direction be impassable
 *   Value can be up, down, left, right
 *
 *   regionId
 *   Mark the layer as region layer, the layer ID will be the value of property
 *
 *   priority
 *   Mark the layer as priority layer, allows it goes above player when player is behind,
 *   below player when player is in front of. Value should be > 0, zIndex should be
 *   the same as player z-index.
 *
 *   level
 *   Mark the layer on different level, use for multiple levels map (for example a bridge).
 *   Default level is 0. Use this for collision and regionId.
 *
 *   hideOnLevel
 *   Hide the layer when on a certain level.
 *
 *   toLevel
 *   The tiles on this layer will transfer player to another level.
 */
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};