521 lines
23 KiB
JavaScript
521 lines
23 KiB
JavaScript
|
(function webpackUniversalModuleDefinition(root, factory) {
|
||
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
||
|
|
module.exports = factory();
|
||
|
|
else if(typeof define === 'function' && define.amd)
|
||
|
|
define([], factory);
|
||
|
|
else if(typeof exports === 'object')
|
||
|
|
exports["AnimatedTiles"] = factory();
|
||
|
|
else
|
||
|
|
root["AnimatedTiles"] = factory();
|
||
|
|
})(window, function() {
|
||
|
|
return /******/ (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] = {
|
||
|
|
/******/ i: moduleId,
|
||
|
|
/******/ l: false,
|
||
|
|
/******/ exports: {}
|
||
|
|
/******/ };
|
||
|
|
/******/
|
||
|
|
/******/ // Execute the module function
|
||
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
|
|
/******/
|
||
|
|
/******/ // Flag the module as loaded
|
||
|
|
/******/ module.l = 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;
|
||
|
|
/******/
|
||
|
|
/******/ // define getter function for harmony exports
|
||
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
||
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
||
|
|
/******/ Object.defineProperty(exports, name, {
|
||
|
|
/******/ configurable: false,
|
||
|
|
/******/ enumerable: true,
|
||
|
|
/******/ get: getter
|
||
|
|
/******/ });
|
||
|
|
/******/ }
|
||
|
|
/******/ };
|
||
|
|
/******/
|
||
|
|
/******/ // define __esModule on exports
|
||
|
|
/******/ __webpack_require__.r = function(exports) {
|
||
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
|
/******/ };
|
||
|
|
/******/
|
||
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
||
|
|
/******/ __webpack_require__.n = function(module) {
|
||
|
|
/******/ var getter = module && module.__esModule ?
|
||
|
|
/******/ function getDefault() { return module['default']; } :
|
||
|
|
/******/ function getModuleExports() { return module; };
|
||
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
||
|
|
/******/ return getter;
|
||
|
|
/******/ };
|
||
|
|
/******/
|
||
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
||
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
||
|
|
/******/
|
||
|
|
/******/ // __webpack_public_path__
|
||
|
|
/******/ __webpack_require__.p = "";
|
||
|
|
/******/
|
||
|
|
/******/
|
||
|
|
/******/ // Load entry module and return exports
|
||
|
|
/******/ return __webpack_require__(__webpack_require__.s = 0);
|
||
|
|
/******/ })
|
||
|
|
/************************************************************************/
|
||
|
|
/******/ ([
|
||
|
|
/* 0 */
|
||
|
|
/*!*****************!*\
|
||
|
|
!*** ./main.js ***!
|
||
|
|
\*****************/
|
||
|
|
/*! no static exports found */
|
||
|
|
/*! all exports used */
|
||
|
|
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
|
||
|
|
/***/ (function(module, exports, __webpack_require__) {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
|
||
|
|
|
||
|
|
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; }; }();
|
||
|
|
|
||
|
|
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; }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Niklas Berg <nkholski@niklasberg.se>
|
||
|
|
* @copyright 2018 Niklas Berg
|
||
|
|
* @license {@link https://github.com/nkholski/phaser3-animated-tiles/blob/master/LICENSE|MIT License}
|
||
|
|
*/
|
||
|
|
|
||
|
|
//
|
||
|
|
// This plugin is based on Photonstorms Phaser 3 plugin template with added support for ES6.
|
||
|
|
//
|
||
|
|
|
||
|
|
var AnimatedTiles = function (_Phaser$Plugins$Scene) {
|
||
|
|
_inherits(AnimatedTiles, _Phaser$Plugins$Scene);
|
||
|
|
|
||
|
|
/*
|
||
|
|
TODO:
|
||
|
|
1. Fix property names which is a mess after adding support for multiple maps, tilesets and layers.
|
||
|
|
2. Helper functions: Get mapIndex by passing a map (and maybe support it as argument to methods), Get layerIndex, get tile index from properties.
|
||
|
|
|
||
|
|
*/
|
||
|
|
function AnimatedTiles(scene, pluginManager) {
|
||
|
|
_classCallCheck(this, AnimatedTiles);
|
||
|
|
|
||
|
|
// TileMap the plugin belong to.
|
||
|
|
// TODO: Array or object for multiple tilemaps support
|
||
|
|
// TODO: reference to layers too, and which is activated or not
|
||
|
|
var _this = _possibleConstructorReturn(this, (AnimatedTiles.__proto__ || Object.getPrototypeOf(AnimatedTiles)).call(this, scene, pluginManager));
|
||
|
|
|
||
|
|
_this.map = null;
|
||
|
|
|
||
|
|
// Array with all tiles to animate
|
||
|
|
// TODO: Turn on and off certain tiles.
|
||
|
|
_this.animatedTiles = [];
|
||
|
|
|
||
|
|
// Global playback rate
|
||
|
|
_this.rate = 1;
|
||
|
|
|
||
|
|
// Should the animations play or not?
|
||
|
|
_this.active = false;
|
||
|
|
|
||
|
|
// Should the animations play or not per layer. If global active is false this value makes no difference
|
||
|
|
_this.activeLayer = [];
|
||
|
|
|
||
|
|
// Obey timescale?
|
||
|
|
_this.followTimeScale = true;
|
||
|
|
|
||
|
|
if (!scene.sys.settings.isBooted) {
|
||
|
|
scene.sys.events.once('boot', _this.boot, _this);
|
||
|
|
}
|
||
|
|
return _this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Called when the Plugin is booted by the PluginManager.
|
||
|
|
// If you need to reference other systems in the Scene (like the Loader or DisplayList) then set-up those references now, not in the constructor.
|
||
|
|
|
||
|
|
|
||
|
|
_createClass(AnimatedTiles, [{
|
||
|
|
key: 'boot',
|
||
|
|
value: function boot() {
|
||
|
|
var eventEmitter = this.systems.events;
|
||
|
|
eventEmitter.on('postupdate', this.postUpdate, this);
|
||
|
|
eventEmitter.on('shutdown', this.shutdown, this);
|
||
|
|
eventEmitter.on('destroy', this.destroy, this);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initilize support for animated tiles on given map
|
||
|
|
|
||
|
|
}, {
|
||
|
|
key: 'init',
|
||
|
|
value: function init(map) {
|
||
|
|
// TODO: Check if map is initilized already, if so do it again but overwrite the old.
|
||
|
|
var mapAnimData = this.getAnimatedTiles(map);
|
||
|
|
var animatedTiles = {
|
||
|
|
map: map,
|
||
|
|
animatedTiles: mapAnimData,
|
||
|
|
active: true,
|
||
|
|
rate: 1,
|
||
|
|
activeLayer: []
|
||
|
|
};
|
||
|
|
map.layers.forEach(function () {
|
||
|
|
return animatedTiles.activeLayer.push(true);
|
||
|
|
});
|
||
|
|
this.animatedTiles.push(animatedTiles);
|
||
|
|
if (this.animatedTiles.length === 1) {
|
||
|
|
this.active = true; // Start the animations by default
|
||
|
|
}
|
||
|
|
// Needed?
|
||
|
|
this.animatedTiles[this.animatedTiles.length-1].animatedTiles.forEach(
|
||
|
|
(animatedTile) => {
|
||
|
|
animatedTile.tiles.forEach((layer) => {
|
||
|
|
this.updateLayer(animatedTile, layer);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
)
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'setRate',
|
||
|
|
value: function setRate(rate) {
|
||
|
|
var gid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
||
|
|
var map = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
||
|
|
|
||
|
|
if (gid === null) {
|
||
|
|
if (map === null) {
|
||
|
|
this.rate = rate;
|
||
|
|
} else {
|
||
|
|
this.animatedTiles[map].rate = rate;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var loopThrough = function loopThrough(animatedTiles) {
|
||
|
|
animatedTiles.forEach(function (animatedTile) {
|
||
|
|
if (animatedTile.index === gid) {
|
||
|
|
animatedTile.rate = rate;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
if (map === null) {
|
||
|
|
this.animatedTiles.forEach(function (animatedTiles) {
|
||
|
|
loopThrough(animatedTiles.animatedTiles);
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
loopThrough(this.animatedTiles[map].animatedTiles);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// if tile is number (gid) --> set rate for that tile
|
||
|
|
// TODO: if passing an object -> check properties matching object and set rate
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'resetRates',
|
||
|
|
value: function resetRates() {
|
||
|
|
var mapIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
||
|
|
|
||
|
|
if (mapIndex === null) {
|
||
|
|
this.rate = 1;
|
||
|
|
this.animatedTiles.forEach(function (mapAnimData) {
|
||
|
|
mapAnimData.rate = 1;
|
||
|
|
mapAnimData.animatedTiles.forEach(function (tileAnimData) {
|
||
|
|
tileAnimData.rate = 1;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
this.animatedTiles[mapIndex].rate = 1;
|
||
|
|
this.animatedTiles[mapIndex].animatedTiles.forEach(function (tileAnimData) {
|
||
|
|
tileAnimData.rate = 1;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Start (or resume) animations
|
||
|
|
}, {
|
||
|
|
key: 'resume',
|
||
|
|
value: function resume() {
|
||
|
|
var _this2 = this;
|
||
|
|
|
||
|
|
var layerIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
||
|
|
var mapIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
||
|
|
|
||
|
|
var scope = mapIndex === null ? this : this.animatedTiles[mapIndex];
|
||
|
|
if (layerIndex === null) {
|
||
|
|
scope.active = true;
|
||
|
|
} else {
|
||
|
|
scope.activeLayer[layerIndex] = true;
|
||
|
|
scope.animatedTiles.forEach(function (animatedTile) {
|
||
|
|
_this2.updateLayer(animatedTile, animatedTile.tiles[layerIndex]);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Stop (or pause) animations
|
||
|
|
|
||
|
|
}, {
|
||
|
|
key: 'pause',
|
||
|
|
value: function pause() {
|
||
|
|
var layerIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
||
|
|
var mapIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
||
|
|
|
||
|
|
var scope = mapIndex === null ? this : this.animatedTiles[mapIndex];
|
||
|
|
if (layerIndex === null) {
|
||
|
|
scope.active = false;
|
||
|
|
} else {
|
||
|
|
scope.activeLayer[layerIndex] = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'postUpdate',
|
||
|
|
value: function postUpdate(time, delta) {
|
||
|
|
var _this3 = this;
|
||
|
|
|
||
|
|
if (!this.active) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Elapsed time is the delta multiplied by the global rate and the scene timeScale if folowTimeScale is true
|
||
|
|
var globalElapsedTime = delta * this.rate * (this.followTimeScale ? this.scene.time.timeScale : 1);
|
||
|
|
this.animatedTiles.forEach(function (mapAnimData) {
|
||
|
|
if (!mapAnimData.active) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Multiply with rate for this map
|
||
|
|
var elapsedTime = globalElapsedTime * mapAnimData.rate;
|
||
|
|
mapAnimData.animatedTiles.forEach(function (animatedTile) {
|
||
|
|
// Reduce time for current tile, multiply elapsedTime with this tile's private rate
|
||
|
|
animatedTile.next -= elapsedTime * animatedTile.rate;
|
||
|
|
// Time for current tile is up!!!
|
||
|
|
if (animatedTile.next < 0) {
|
||
|
|
// Remember current frame index
|
||
|
|
var currentIndex = animatedTile.currentFrame;
|
||
|
|
// Remember the tileId of current tile
|
||
|
|
var oldTileId = animatedTile.frames[currentIndex].tileid;
|
||
|
|
// Advance to next in line
|
||
|
|
var newIndex = currentIndex + 1;
|
||
|
|
// If we went beyond last frame, we just start over
|
||
|
|
if (newIndex > animatedTile.frames.length - 1) {
|
||
|
|
newIndex = 0;
|
||
|
|
}
|
||
|
|
// Set lifelength for current frame
|
||
|
|
animatedTile.next = animatedTile.frames[newIndex].duration;
|
||
|
|
// Set index of current frame
|
||
|
|
animatedTile.currentFrame = newIndex;
|
||
|
|
// Store the tileId (gid) we will shift to
|
||
|
|
// Loop through all tiles (via layers)
|
||
|
|
//this.updateLayer
|
||
|
|
animatedTile.tiles.forEach(function (layer, layerIndex) {
|
||
|
|
if (!mapAnimData.activeLayer[layerIndex]) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_this3.updateLayer(animatedTile, layer, oldTileId);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}); // animData loop
|
||
|
|
}); // Map loop
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'updateLayer',
|
||
|
|
value: function updateLayer(animatedTile, layer) {
|
||
|
|
var oldTileId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
|
||
|
|
|
||
|
|
var tilesToRemove = [];
|
||
|
|
var tileId = animatedTile.frames[animatedTile.currentFrame].tileid;
|
||
|
|
layer.forEach(function (tile) {
|
||
|
|
// If the tile is removed or has another index than expected, it's
|
||
|
|
// no longer animated. Mark for removal.
|
||
|
|
if (oldTileId > -1 && (tile === null || tile.index !== oldTileId)) {
|
||
|
|
tilesToRemove.push(tile);
|
||
|
|
} else {
|
||
|
|
// Finally we set the index of the tile to the one specified by current frame!!!
|
||
|
|
tile.index = tileId;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
// Remove obselete tiles
|
||
|
|
tilesToRemove.forEach(function (tile) {
|
||
|
|
var pos = layer.indexOf(tile);
|
||
|
|
if (pos > -1) {
|
||
|
|
layer.splice(pos, 1);
|
||
|
|
} else {
|
||
|
|
console.error("This shouldn't happen. Not at all. Blame Phaser Animated Tiles plugin. You'll be fine though.");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// Called when a Scene shuts down, it may then come back again later (which will invoke the 'start' event) but should be considered dormant.
|
||
|
|
|
||
|
|
}, {
|
||
|
|
key: 'shutdown',
|
||
|
|
value: function shutdown() {}
|
||
|
|
|
||
|
|
// Called when a Scene is destroyed by the Scene Manager. There is no coming back from a destroyed Scene, so clear up all resources here.
|
||
|
|
|
||
|
|
}, {
|
||
|
|
key: 'destroy',
|
||
|
|
value: function destroy() {
|
||
|
|
this.shutdown();
|
||
|
|
this.scene = undefined;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'getAnimatedTiles',
|
||
|
|
value: function getAnimatedTiles(map) {
|
||
|
|
var _this4 = this;
|
||
|
|
|
||
|
|
// this.animatedTiles is an array of objects with information on how to animate and which tiles.
|
||
|
|
var animatedTiles = [];
|
||
|
|
// loop through all tilesets
|
||
|
|
map.tilesets.forEach(
|
||
|
|
// Go through the data stored on each tile (not tile on the tilemap but tile in the tileset)
|
||
|
|
function (tileset) {
|
||
|
|
var tileData = tileset.tileData;
|
||
|
|
Object.keys(tileData).forEach(function (index) {
|
||
|
|
index = parseInt(index);
|
||
|
|
// If tile has animation info we'll dive into it
|
||
|
|
if (tileData[index].hasOwnProperty("animation")) {
|
||
|
|
var animatedTileData = {
|
||
|
|
index: index + tileset.firstgid, // gid of the original tile
|
||
|
|
frames: [], // array of frames
|
||
|
|
currentFrame: 0, // start on first frame
|
||
|
|
tiles: [], // array with one array per layer with list of tiles that depends on this animation data
|
||
|
|
rate: 1 // multiplier, set to 2 for double speed or 0.25 quarter speed
|
||
|
|
};
|
||
|
|
// push all frames to the animatedTileData
|
||
|
|
tileData[index].animation.forEach(function (frameData) {
|
||
|
|
var frame = {
|
||
|
|
duration: frameData.duration,
|
||
|
|
tileid: frameData.tileid + tileset.firstgid
|
||
|
|
};
|
||
|
|
animatedTileData.frames.push(frame);
|
||
|
|
});
|
||
|
|
// time until jumping to next frame
|
||
|
|
animatedTileData.next = animatedTileData.frames[0].duration;
|
||
|
|
// Go through all layers for tiles
|
||
|
|
map.layers.forEach(function (layer) {
|
||
|
|
if ((!layer.tilemapLayer) ||
|
||
|
|
(!layer.tilemapLayer.type) ||
|
||
|
|
(layer.tilemapLayer.type === "StaticTilemapLayer")) {
|
||
|
|
// We just push an empty array if the layer is static (impossible to animate).
|
||
|
|
// If we just skip the layer, the layer order will be messed up
|
||
|
|
// when updating animated tiles and things will look awful.
|
||
|
|
animatedTileData.tiles.push([]);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// tiles array for current layer
|
||
|
|
var tiles = [];
|
||
|
|
// loop through all rows with tiles...
|
||
|
|
layer.data.forEach(function (tileRow) {
|
||
|
|
// ...and loop through all tiles in that row
|
||
|
|
tileRow.forEach(function (tile) {
|
||
|
|
// Tiled start index for tiles with 1 but animation with 0. Thus that wierd "-1"
|
||
|
|
if (tile.index - tileset.firstgid === index) {
|
||
|
|
tiles.push(tile);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
// add the layer's array with tiles to the tiles array.
|
||
|
|
// this will make it possible to control layers individually in the future
|
||
|
|
animatedTileData.tiles.push(tiles);
|
||
|
|
});
|
||
|
|
// animatedTileData is finished for current animation, push it to the animatedTiles-property of the plugin
|
||
|
|
animatedTiles.push(animatedTileData);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
map.layers.forEach(function (layer, layerIndex) {
|
||
|
|
// layer indices array of booleans whether to animate tiles on layer or not
|
||
|
|
_this4.activeLayer[layerIndex] = true;
|
||
|
|
});
|
||
|
|
|
||
|
|
return animatedTiles;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'putTileAt',
|
||
|
|
value: function putTileAt(layer, tile, x, y) {
|
||
|
|
// Replaces putTileAt of the native API, but updates the list of animatedTiles in the process.
|
||
|
|
// No need to call updateAnimatedTiles as required for other modificatons of the tile-map
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: 'updateAnimatedTiles',
|
||
|
|
value: function updateAnimatedTiles() {
|
||
|
|
// future args: x=null, y=null, w=null, h=null, container=null
|
||
|
|
var x = null,
|
||
|
|
y = null,
|
||
|
|
w = null,
|
||
|
|
h = null,
|
||
|
|
container = null;
|
||
|
|
// 1. If no container, loop through all initilized maps
|
||
|
|
if (container === null) {
|
||
|
|
container = [];
|
||
|
|
this.animatedTiles.forEach(function (mapAnimData) {
|
||
|
|
container.push(mapAnimData);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
// 2. If container is a map, loop through it's layers
|
||
|
|
// container = [container];
|
||
|
|
|
||
|
|
// 1 & 2: Update the map(s)
|
||
|
|
container.forEach(function (mapAnimData) {
|
||
|
|
var chkX = x !== null ? x : 0;
|
||
|
|
var chkY = y !== null ? y : 0;
|
||
|
|
var chkW = w !== null ? mapAnimData.map.width : 10;
|
||
|
|
var chkH = h !== null ? mapAnimData.map.height : 10;
|
||
|
|
|
||
|
|
mapAnimData.animatedTiles.forEach(function (tileAnimData) {
|
||
|
|
tileAnimData.tiles.forEach(function (tiles, layerIndex) {
|
||
|
|
var layer = mapAnimData.map.layers[layerIndex];
|
||
|
|
if (layer.type === "StaticTilemapLayer") {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (var _x9 = chkX; _x9 < chkX + chkW; _x9++) {
|
||
|
|
for (var _y = chkY; _y < chkY + chkH; _y++) {
|
||
|
|
var tile = mapAnimData.map.layers[layerIndex].data[_x9][_y];
|
||
|
|
// should this tile be animated?
|
||
|
|
if (tile.index == tileAnimData.index) {
|
||
|
|
// is it already known? if not, add it to the list
|
||
|
|
if (tiles.indexOf(tile) === -1) {
|
||
|
|
tiles.push(tile);
|
||
|
|
}
|
||
|
|
// update index to match current fram of this animation
|
||
|
|
tile.index = tileAnimData.frames[tileAnimData.currentFrame].tileid;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
// 3. If container is a layer, just loop through it's tiles
|
||
|
|
}
|
||
|
|
}]);
|
||
|
|
|
||
|
|
return AnimatedTiles;
|
||
|
|
}(Phaser.Plugins.ScenePlugin);
|
||
|
|
|
||
|
|
;
|
||
|
|
|
||
|
|
// Static function called by the PluginFile Loader.
|
||
|
|
AnimatedTiles.register = function (PluginManager) {
|
||
|
|
// Register this plugin with the PluginManager, so it can be added to Scenes.
|
||
|
|
PluginManager.register('AnimatedTiles', AnimatedTiles, 'animatedTiles');
|
||
|
|
};
|
||
|
|
|
||
|
|
module.exports = AnimatedTiles;
|
||
|
|
|
||
|
|
/***/ })
|
||
|
|
/******/ ]);
|
||
|
|
});
|