Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Untitled diff

Created 7 years agoDiff never expires

/*:

* @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 &&

Saved diffs

Original text

Open file

/*:
 * @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;

	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._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
	});

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

	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; }

	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

	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 {
	                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 layerData = this.tiledData.layers[layer.layerId];
	                    if (layerData.properties && layerData.properties.hasOwnProperty("hideOnLevel")) {
	                        if (parseInt(layerData.properties.hideOnLevel) !== level) {
	                            this.addChild(layer);
	                            continue;
	                        }
	                        layerIds.push(layer.layerId);
	                        this.removeChild(layer);
	                    }
	                }
	            } catch (err) {
	                _didIteratorError12 = true;
	                _iteratorError12 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion12 && _iterator12.return) {
	                        _iterator12.return();
	                    }
	                } finally {
	                    if (_didIteratorError12) {
	                        throw _iteratorError12;
	                    }
	                }
	            }

	            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;

	                    var realX = x;
	                    var ids = [];
	                    if (this.isHalfTile()) {
	                        realX = Math.floor(x / halfWidth) * width * 2 + x % halfWidth * 2;
	                    }
	                    if (!!layerData.data[x]) {
	                        if (layerData.properties.collision === "full") {
	                            ids.push(realX);
	                            if (this.isHalfTile()) {
	                                ids.push(realX + 1, realX + width, realX + width + 1);
	                            }
	                        }
	                        if (layerData.properties.collision === "up-left") {
	                            ids.push(realX);
	                        }
	                        if (layerData.properties.collision === "up-right") {
	                            ids.push(realX + 1);
	                        }
	                        if (layerData.properties.collision === "down-left") {
	                            ids.push(realX + width);
	                        }
	                        if (layerData.properties.collision === "down-right") {
	                            ids.push(realX + width + 1);
	                        }
	                        var _iteratorNormalCompletion4 = true;
	                        var _didIteratorError4 = false;
	                        var _iteratorError4 = undefined;

	                        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;
	                    }

	                    var eventId = parseInt(object.properties.eventId);
	                    var event = this._events[eventId];
	                    if (!event) {
	                        continue;
	                    }
	                    var x = Math.floor(object.x / this.tileWidth());
	                    var y = Math.floor(object.y / this.tileHeight());
	                    if (this.isHalfTile()) {
	                        x += 1;
	                        y += 1;
	                    }
	                    event.locate(x, y);
	                }
	            } catch (err) {
	                _didIteratorError12 = true;
	                _iteratorError12 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion12 && _iterator12.return) {
	                        _iterator12.return();
	                    }
	                } finally {
	                    if (_didIteratorError12) {
	                        throw _iteratorError12;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError11 = true;
	        _iteratorError11 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion11 && _iterator11.return) {
	                _iterator11.return();
	            }
	        } finally {
	            if (_didIteratorError11) {
	                throw _iteratorError11;
	            }
	        }
	    }
	};

	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);
	};

/***/ }

/******/ });

Changed text

Open file

/*:
 * @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 && 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
	});

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

	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; }

	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

	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 {
	                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;
	            if (!tilesData) {
	                return tileId;
	            }
	            if (!tilesData[tileId]) {
	                return tileId;
	            }
	            if (!tilesData[tileId].animation) {
	                return tileId;
	            }
	            var animation = tilesData[tileId].animation;
	            this._animFrame[tileId] = this._animFrame[tileId] || 0;
	            var frame = this._animFrame[tileId];
	            this._animFrame[tileId] = !!animation[frame] ? frame : 0;
	            frame = this._animFrame[tileId];
	            var duration = animation[frame].duration / 1000 * 60;
	            this._animDuration[tileId] = this._animDuration[tileId] || duration;
	            if (this._animDuration[tileId] <= 0) {
	                this._animDuration[tileId] = 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 layerData = this.tiledData.layers[layer.layerId];
	                    if (layerData.properties && layerData.properties.hasOwnProperty("hideOnLevel")) {
	                        if (parseInt(layerData.properties.hideOnLevel) !== level) {
	                            this.addChild(layer);
	                            continue;
	                        }
	                        layerIds.push(layer.layerId);
	                        this.removeChild(layer);
	                    }
	                }
	            } catch (err) {
	                _didIteratorError12 = true;
	                _iteratorError12 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion12 && _iterator12.return) {
	                        _iterator12.return();
	                    }
	                } finally {
	                    if (_didIteratorError12) {
	                        throw _iteratorError12;
	                    }
	                }
	            }

	            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._isSetupBefore = this._isSetupBefore || {};
	    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();
	        this._isSetupBefore[mapId] = true;
	    }
	};

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

	Game_Map.prototype.isSaveEventLocations = function () {
	    if (!this.tiledData.properties) {
	        return false;
	    }
	    return !!this.tiledData.properties.saveEventLocations;
	};

	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._getTileProperties = function (tileId) {
	    var tilesetId = 0;
	    var _iteratorNormalCompletion2 = true;
	    var _didIteratorError2 = false;
	    var _iteratorError2 = undefined;

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

	            if (tileId < _tileset.firstgid || tileId >= _tileset.firstgid + _tileset.tilecount) {
	                tilesetId++;
	                continue;
	            }
	            break;
	        }
	    } catch (err) {
	        _didIteratorError2 = true;
	        _iteratorError2 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion2 && _iterator2.return) {
	                _iterator2.return();
	            }
	        } finally {
	            if (_didIteratorError2) {
	                throw _iteratorError2;
	            }
	        }
	    }

	    var tileset = this.tiledData.tilesets[tilesetId];
	    if (!tileId || !tileset.tileproperties) {
	        return {};
	    }
	    return tileset.tileproperties['' + (tileId - tileset.firstgid)] || {};
	};

	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 _iteratorNormalCompletion3 = true;
	    var _didIteratorError3 = false;
	    var _iteratorError3 = undefined;

	    try {
	        for (var _iterator3 = this.tiledData.layers[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
	            var layerData = _step3.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" && layerData.properties.collision !== "tile-base") {
	                continue;
	            }

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

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

	            try {
	                for (var _iterator4 = Array(size).keys()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
	                    var x = _step4.value;

	                    var realX = x;
	                    var ids = [];
	                    if (this.isHalfTile()) {
	                        realX = Math.floor(x / halfWidth) * width * 2 + x % halfWidth * 2;
	                    }
	                    if (!!layerData.data[x]) {
	                        if (layerData.properties.collision === "full") {
	                            ids.push(realX);
	                            if (this.isHalfTile()) {
	                                ids.push(realX + 1, realX + width, realX + width + 1);
	                            }
	                        }
	                        if (layerData.properties.collision === "up-left") {
	                            ids.push(realX);
	                        }
	                        if (layerData.properties.collision === "up-right") {
	                            ids.push(realX + 1);
	                        }
	                        if (layerData.properties.collision === "down-left") {
	                            ids.push(realX + width);
	                        }
	                        if (layerData.properties.collision === "down-right") {
	                            ids.push(realX + width + 1);
	                        }
	                        if (layerData.properties.collision === "tile-base") {
	                            var tileproperties = this._getTileProperties(layerData.data[x]);
	                            if (tileproperties.collision === "full") {
	                                ids.push(realX);
	                                if (this.isHalfTile()) {
	                                    ids.push(realX + 1, realX + width, realX + width + 1);
	                                }
	                            }
	                        }
	                        var _iteratorNormalCompletion5 = true;
	                        var _didIteratorError5 = false;
	                        var _iteratorError5 = undefined;

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

	                                this._collisionMap[level][id] = 1;
	                            }
	                        } catch (err) {
	                            _didIteratorError5 = true;
	                            _iteratorError5 = err;
	                        } finally {
	                            try {
	                                if (!_iteratorNormalCompletion5 && _iterator5.return) {
	                                    _iterator5.return();
	                                }
	                            } finally {
	                                if (_didIteratorError5) {
	                                    throw _iteratorError5;
	                                }
	                            }
	                        }
	                    }
	                }
	            } 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;
	            }
	        }
	    }
	};

	Game_Map.prototype._getArrowBit = function (impassable) {
	    var bit = 0;
	    var arrows = impassable.split('&').map(function (i) {
	        return i.trim().toLowerCase();
	    });

	    var _iteratorNormalCompletion6 = true;
	    var _didIteratorError6 = false;
	    var _iteratorError6 = undefined;

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

	            if (arrow === 'left') bit ^= 1;
	            if (arrow === 'up') bit ^= 2;
	            if (arrow === 'right') bit ^= 4;
	            if (arrow === 'down') bit ^= 8;
	        }
	    } catch (err) {
	        _didIteratorError6 = true;
	        _iteratorError6 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion6 && _iterator6.return) {
	                _iterator6.return();
	            }
	        } finally {
	            if (_didIteratorError6) {
	                throw _iteratorError6;
	            }
	        }
	    }

	    return bit;
	};

	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 _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.collision) {
	                continue;
	            }

	            if (layerData.properties.collision !== "arrow" && layerData.properties.collision !== "tile-base") {
	                continue;
	            }

	            var level = parseInt(layerData.properties.level) || 0;
	            this._initializeMapLevel(level);
	            var arrowCollisionMap = this._arrowCollisionMap[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.properties.collision === "tile-base") {
	                        var tileproperties = this._getTileProperties(layerData.data[x]);
	                        if (!!tileproperties.arrowImpassable) {
	                            bit = this._getArrowBit(tileproperties.arrowImpassable);
	                            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;
	                            }
	                        }
	                    } else if (!!layerData.data[x]) {
	                        if (!layerData.properties.arrowImpassable) {
	                            continue;
	                        }

	                        bit = this._getArrowBit(layerData.properties.arrowImpassable);

	                        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) {
	                _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._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 _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.regionId) {
	                continue;
	            }

	            var level = parseInt(layerData.properties.level) || 0;
	            this._initializeMapLevel(level);
	            var regionMap = this._regions[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;
	                    if (this.isHalfTile()) {
	                        realX = Math.floor(x / halfWidth) * width * 2 + x % halfWidth * 2;
	                    }

	                    if (layerData.properties.regionId === "tile-base") {
	                        var tileproperties = this._getTileProperties(layerData.data[x]);
	                        if (!!tileproperties.regionId) {
	                            regionMap[realX] = parseInt(tileproperties.regionId);
	                            if (this.isHalfTile()) {
	                                regionMap[realX + 1] = parseInt(tileproperties.regionId);;
	                                regionMap[realX + width] = parseInt(tileproperties.regionId);;
	                                regionMap[realX + width + 1] = parseInt(tileproperties.regionId);;
	                            }
	                        }
	                    } else 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) {
	                _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._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 _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.properties || !layerData.properties.toLevel) {
	                continue;
	            }

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

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

	            try {
	                for (var _iterator12 = Array(size).keys()[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
	                    var x = _step12.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) {
	                _didIteratorError12 = true;
	                _iteratorError12 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion12 && _iterator12.return) {
	                        _iterator12.return();
	                    }
	                } finally {
	                    if (_didIteratorError12) {
	                        throw _iteratorError12;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError11 = true;
	        _iteratorError11 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion11 && _iterator11.return) {
	                _iterator11.return();
	            }
	        } finally {
	            if (_didIteratorError11) {
	                throw _iteratorError11;
	            }
	        }
	    }
	};

	Game_Map.prototype._setupTiledEvents = function () {
	    var _iteratorNormalCompletion13 = true;
	    var _didIteratorError13 = false;
	    var _iteratorError13 = undefined;

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

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

	            var _iteratorNormalCompletion14 = true;
	            var _didIteratorError14 = false;
	            var _iteratorError14 = undefined;

	            try {
	                for (var _iterator14 = layerData.objects[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
	                    var object = _step14.value;

	                    if (!object.properties) {
	                        continue;
	                    }

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

	                    var eventId = parseInt(object.properties.eventId);
	                    var event = this._events[eventId];
	                    if (!event) {
	                        continue;
	                    }
	                    var x = Math.floor(object.x / this.tileWidth());
	                    var y = Math.floor(object.y / this.tileHeight());
	                    if (this.isHalfTile()) {
	                        x += 1;
	                        y += 1;
	                    }

	                    event.locate(x, y);
	                    if (event.loadLocation) {
	                        event.loadLocation();
	                    }
	                }
	            } catch (err) {
	                _didIteratorError14 = true;
	                _iteratorError14 = err;
	            } finally {
	                try {
	                    if (!_iteratorNormalCompletion14 && _iterator14.return) {
	                        _iterator14.return();
	                    }
	                } finally {
	                    if (_didIteratorError14) {
	                        throw _iteratorError14;
	                    }
	                }
	            }
	        }
	    } catch (err) {
	        _didIteratorError13 = true;
	        _iteratorError13 = err;
	    } finally {
	        try {
	            if (!_iteratorNormalCompletion13 && _iterator13.return) {
	                _iterator13.return();
	            }
	        } finally {
	            if (_didIteratorError13) {
	                throw _iteratorError13;
	            }
	        }
	    }
	};

	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);
	};

/***/ },

/***/ 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);
	};

/***/ }

/******/ });