1745 lines
41 KiB
JavaScript
1745 lines
41 KiB
JavaScript
/*:
|
||
* Yami Engine Delta - Tilemap
|
||
*
|
||
* @plugindesc v1.1.3 Implementation for Tiled Map Editor.
|
||
* @author Yami Engine Delta [Dr.Yami]
|
||
*
|
||
* @help This plugin is to use TileD generated maps for your RPG Maker MV games!
|
||
* Follow the instructions to use it:
|
||
*
|
||
* 1. Create a New Folder named **maps** (without asterisks) inside game project's root folder.
|
||
* 2. Create a new map in TileD. The settings must be CSV and Orthogonal. The Tile size you set will be the grid in the game!
|
||
* When loading your images, make sure to reference them all in the game's **img/tilesets** folder.
|
||
* 3. Export as json file and make sure that the filename is Map*ID*.json. ID being the map's index as seen in the editor.
|
||
* 4. Put all json files from Tiled into the **maps** folder.
|
||
* 5. Put all tilesets into the game's **img/tilesets** This is a reminder!
|
||
* 6. Put `<position: X, Y>` into an event comment box for positioning.
|
||
* 7. For upper layer (layer that ABOVE player), add *Custom Properties* (in Tiled) `layer` with value `upper`
|
||
* 8. For lower layer (layer that BELOW player), no need to add anything
|
||
* 9. For collision: any Tile Layer with *Custom Properties* (in Tiled) `collision` with value `true` has collision.
|
||
* Which mean any tile that is not empty in that Layer will have collision. You can turn off Visible for Collision Layer if you want.
|
||
* 10. For Region ID: any Tile Layer with *Custom Properties* (in Tiled) `regionId` with value is number will make any tile that is not empty has a region ID of entered number.
|
||
* You can turn off Visible for Region Layer if you want.
|
||
* 11. Images for Image Layers should be put in **img/parallaxes**
|
||
* 12. For parallax: add *Custom Properties* (in Tiled) `parallax` with value `true` to Image Layer. Add *Custom Properties* `planeX` and `planeY` for parallax moving.
|
||
* 13. For arrow passable: add *Custom Properties* (in Tiled) `arrowImpassable` with value `up` `down` `left` or `right` to Tile Layer. Any tile that is not empty on that
|
||
* layer will make the *direction* based on `arrowImpassable` value impassable.
|
||
*
|
||
*/
|
||
/*:ja
|
||
* Yami Engine Delta - Tilemap
|
||
*
|
||
* @plugindesc v1.1.3 デフォルトのエディタの代わりに、TileDをマップエディタとして使うことができます。
|
||
* @author Yami Engine Delta [Dr.Yami]
|
||
*
|
||
* @help デフォルトのエディタの代わりに、TileDをマップエディタとして使うことができます。
|
||
* 使用方法は以下の通りです。
|
||
*
|
||
* 1. ゲームのプロジェクト直下のサブフォルダ内に "maps" という名前の新しいフォ
|
||
* ルダを作成してください。
|
||
* 2. TileD内で新規マップを作成します。セッティングはCSVとOrthogonalに設定して
|
||
* ください。設定したタイルサイズが、ゲーム内のグリッドとなります。
|
||
* イメージをロードする際には、参照先が必ず "img/tilesets" になるようにして
|
||
* ください。
|
||
* 3. ファイルをJSON形式でエクスポートし、ファイル名は 「Map*ID*.json」となる
|
||
* ようにしてください。(任意のIDを入れる) ここのIDは、エディタ内ではマップの
|
||
* インデックスとして表示されます。"00"は使わないようにしてください。
|
||
* 4. TileDから全てのJSONファイルを、 "maps" のフォルダに入れてください。
|
||
* 5. 全てのタイルセットがゲームの "img/tilesets" に入っているか今一度確認して
|
||
* ください。
|
||
* 6. `<position: X, Y>` という文字列をイベントコマンドボックスに挿入し、位置
|
||
* を指定します。
|
||
* 7. 上層(プレイヤーより上)のレイヤーに対しては、"Custom Properties" で、
|
||
* `layer` を `upper` という値で指定してください。
|
||
* 8. 下層(プレイヤーより下)のレイヤーに対しては、何か追加する必要はありません。
|
||
* 9. コリジョンについて："Custom Properties" を持つタイルレイヤーで、
|
||
* `collision` の値が `true` である場合には、コリジョンを持ちます。
|
||
* つまり、レイヤーの中身が空ではない全てのタイルが、コリジョンを持つという
|
||
* ことになります。コリジョンレイヤーを見えなくすることもできます。
|
||
* 10. リージョンIDについて: "Custom Properties" を持つタイルレイヤーで、
|
||
* `regionId` に値が入っている場合には、値が空ではない全てのタイルにその数値が
|
||
* 与えられます。リージョンレイヤーを見えなくすることもできます。
|
||
* 11. イメージレイヤーに使われる画像については、"img/parallaxes" に格納して
|
||
* ください。
|
||
* 12. パララックスについて：TileD内の *Custom Properties* で、 `parallax` の
|
||
* 値を `true` で指定してください。*Custom Properties* で `planeX` と `planeY`
|
||
* を指定して、パララックスの動きを指定します。
|
||
* 13. 進行可能方向について：TileD内の *Custom Properties* で、
|
||
* `arrowImpassable` の値を `up` `down` `left` `right` で指定してください。
|
||
* そのレイヤー上の値が空ではない全てのタイルは、`arrowImpassable`の値に基づい
|
||
* て、進行不可になります。
|
||
*
|
||
*/
|
||
|
||
/**
|
||
* @namespace Tilemap
|
||
* @memberof YED
|
||
*/
|
||
|
||
var YED = YED || {};
|
||
|
||
// init Tilemap module
|
||
YED.Tilemap = {};
|
||
|
||
(function () {
|
||
ImageManager.loadParserTileset = function (path, hue) {
|
||
var paths = path.split("/"),
|
||
filename = paths[paths.length - 1],
|
||
realPath = "img/tilesets/" + filename;
|
||
|
||
return this.loadNormalBitmap(realPath, hue);
|
||
};
|
||
|
||
ImageManager.loadParserParallax = function (path, hue) {
|
||
var paths = path.split("/"),
|
||
filename = paths[paths.length - 1],
|
||
realPath = "img/parallaxes/" + filename;
|
||
|
||
return this.loadNormalBitmap(realPath, hue);
|
||
};
|
||
})();
|
||
|
||
/* globals YED: false */
|
||
|
||
(function () {
|
||
/**
|
||
* The Data object is created by {@link YED.Tilemap.Core} to load and
|
||
* contain tilemap data from json file
|
||
*
|
||
* To make sure the scene is ready, loading method should be called
|
||
* manually:
|
||
*
|
||
* ```js
|
||
* var data = new YED.Tilemap.Data();
|
||
* data.loadMapFile();
|
||
* ```
|
||
*
|
||
* @class
|
||
* @memberof YED.Tilemap
|
||
*/
|
||
var Data = function (data) {
|
||
this._loadListeners = [];
|
||
this._isExist = false;
|
||
this._collision = []; // collision matrix
|
||
this._region = []; // region matrix
|
||
this._arrows = []; // arrow matrix
|
||
this.data = data;
|
||
};
|
||
|
||
Object.defineProperties(Data.prototype, {
|
||
/**
|
||
* Tilemap data, the Data object will load tilemap data into this member
|
||
*
|
||
* @member {Object}
|
||
* @memberof YED.Tilemap.Data#
|
||
*/
|
||
data: {
|
||
get: function () {
|
||
return this._data || null;
|
||
},
|
||
|
||
set: function (data) {
|
||
this._data = data;
|
||
this._setupData();
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tilemap height, will be number of vertical grids
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
height: {
|
||
get: function () {
|
||
return this.data.height;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tilemap width, will be number of horizontal grids
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
width: {
|
||
get: function () {
|
||
return this.data.width;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tile height, will be height of each tile
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
tileHeight: {
|
||
get: function () {
|
||
return this.data.tileheight;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tile width, will be width of each tile
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
tileWidth: {
|
||
get: function () {
|
||
return this.data.tilewidth;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tilemap custom properties
|
||
*
|
||
* @member {Object}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
properties: {
|
||
get: function () {
|
||
return this.data.properties;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tilemap layers data
|
||
*
|
||
* @member {Object[]}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
layers: {
|
||
get: function () {
|
||
return this.data.layers;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tilemap tilesets data
|
||
*
|
||
* @member {Object[]}
|
||
* @memberof YED.Tilemap.Data#
|
||
* @readonly
|
||
*/
|
||
tilesets: {
|
||
get: function () {
|
||
return this.data.tilesets;
|
||
},
|
||
},
|
||
|
||
collision: {
|
||
get: function () {
|
||
return this._collision;
|
||
},
|
||
},
|
||
|
||
region: {
|
||
get: function () {
|
||
return this._region;
|
||
},
|
||
},
|
||
|
||
arrows: {
|
||
get: function () {
|
||
return this._arrows;
|
||
},
|
||
},
|
||
});
|
||
|
||
/**
|
||
* Setup things after loaded data
|
||
*
|
||
* @private
|
||
*/
|
||
Data.prototype._setupData = function () {
|
||
if (!!this.data) {
|
||
this._setupCollision();
|
||
this._setupArrows();
|
||
this._setupRegions();
|
||
this._loadTilesets();
|
||
}
|
||
};
|
||
|
||
Data.prototype._setupCollision = function () {
|
||
var collisionLayers = this._getCollisionLayers(),
|
||
i,
|
||
j,
|
||
layer;
|
||
|
||
for (i = 0; i < this.width * this.height; i++) {
|
||
this.collision[i] = 0;
|
||
}
|
||
|
||
for (i = 0; i < collisionLayers.length; i++) {
|
||
layer = collisionLayers[i];
|
||
|
||
if (!layer.data) {
|
||
continue;
|
||
}
|
||
|
||
for (j = 0; j < layer.data.length; j++) {
|
||
if (layer.data[j] > 0) {
|
||
this.collision[j] = 1;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
Data.prototype._setupRegions = function () {
|
||
var regionLayers = this._getRegionsLayers(),
|
||
i,
|
||
j,
|
||
layer;
|
||
|
||
for (i = 0; i < this.width * this.height; i++) {
|
||
this.region[i] = 0;
|
||
}
|
||
|
||
for (i = 0; i < regionLayers.length; i++) {
|
||
layer = regionLayers[i];
|
||
|
||
if (!layer.data) {
|
||
continue;
|
||
}
|
||
|
||
for (j = 0; j < layer.data.length; j++) {
|
||
if (layer.data[j] > 0) {
|
||
this.region[j] = parseInt(layer.properties.regionId);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
Data.prototype._setupArrows = function () {
|
||
var arrowLayers = this._getArrowLayers(),
|
||
i,
|
||
j,
|
||
layer,
|
||
bit;
|
||
|
||
for (i = 0; i < this.width * this.height; i++) {
|
||
this.arrows[i] = 1 | 2 | 4 | 8;
|
||
}
|
||
|
||
for (i = 0; i < arrowLayers.length; i++) {
|
||
layer = arrowLayers[i];
|
||
|
||
if (!layer.data) {
|
||
continue;
|
||
}
|
||
|
||
if (layer.properties.arrowImpassable === "left") {
|
||
bit = 1;
|
||
}
|
||
|
||
if (layer.properties.arrowImpassable === "up") {
|
||
bit = 2;
|
||
}
|
||
|
||
if (layer.properties.arrowImpassable === "right") {
|
||
bit = 4;
|
||
}
|
||
|
||
if (layer.properties.arrowImpassable === "down") {
|
||
bit = 8;
|
||
}
|
||
|
||
for (j = 0; j < layer.data.length; j++) {
|
||
if (layer.data[j] > 0) {
|
||
this.arrows[j] = this.arrows[j] ^ bit;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
Data.prototype._loadTilesets = function () {
|
||
var tilesetsData = this.tilesets,
|
||
i = 0,
|
||
length = tilesetsData.length,
|
||
data;
|
||
|
||
for (; i < length; i++) {
|
||
data = tilesetsData[i];
|
||
ImageManager.loadParserTileset(data.image, 0);
|
||
}
|
||
};
|
||
|
||
Data.prototype._getCollisionLayers = function () {
|
||
return this.layers.filter(function (layer) {
|
||
return !!layer.properties && !!layer.properties.collision;
|
||
});
|
||
};
|
||
|
||
Data.prototype._getRegionsLayers = function () {
|
||
return this.layers.filter(function (layer) {
|
||
return !!layer.properties && !!layer.properties.regionId;
|
||
});
|
||
};
|
||
|
||
Data.prototype._getArrowLayers = function () {
|
||
return this.layers.filter(function (layer) {
|
||
return !!layer.properties && !!layer.properties.arrowImpassable;
|
||
});
|
||
};
|
||
|
||
Data.prototype.getImageLayers = function () {
|
||
return this.layers.filter(function (layer) {
|
||
return layer.type === "imagelayer";
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Check if the data is finished loading
|
||
*
|
||
* @return {Boolean} Ready flag
|
||
*/
|
||
Data.prototype.isReady = function () {
|
||
return !!this.data; // hack boolean
|
||
};
|
||
|
||
/**
|
||
* Check if map data exists
|
||
*
|
||
* @return {Boolean} Exist flag
|
||
*/
|
||
Data.prototype.isExist = function () {
|
||
return this._isExist;
|
||
};
|
||
|
||
YED.Tilemap.Data = Data;
|
||
})();
|
||
|
||
/* globals YED: false */
|
||
|
||
(function () {
|
||
/**
|
||
* The Tileset objects are created by {@link YED.Tilemap.Core Tilemap.Core} to load
|
||
* tileset textures and return tile blocks when needed
|
||
*
|
||
* A Tileset object is created with a tileset data gets from {@link YED.Tilemap.Data#tilesets Tilemap.Data#tilesets},
|
||
* for example:
|
||
*
|
||
* ```js
|
||
* var tilesetData = data.tilesets[0];
|
||
* var tileset = new YED.Tilemap.Tileset(tilesetData);
|
||
* ```
|
||
* @class
|
||
* @memberof YED.Tilemap
|
||
* @param {Object} data A Tileset data gets from {@link YED.Tilemap.Data#tilesets Tilemap.Data#tilesets}
|
||
*/
|
||
var Tileset = function (data) {
|
||
this.data = data;
|
||
};
|
||
|
||
Object.defineProperties(Tileset.prototype, {
|
||
/**
|
||
* Tileset data get from tilemap data
|
||
*
|
||
* @member {Object}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
*/
|
||
data: {
|
||
get: function () {
|
||
return this._data || null;
|
||
},
|
||
|
||
set: function (data) {
|
||
this._data = data;
|
||
this._setupData();
|
||
},
|
||
},
|
||
|
||
/**
|
||
* ID of the first tile in tileset
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
* @readonly
|
||
*/
|
||
firstId: {
|
||
get: function () {
|
||
return this.data.firstgid;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tileset bitmap, use Bitmap object of RMMV framework
|
||
*
|
||
* @member {Bitmap}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
*/
|
||
bitmap: {
|
||
get: function () {
|
||
return this._bitmap || null;
|
||
},
|
||
|
||
set: function (bitmap) {
|
||
this._bitmap = bitmap || null;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tileset bitmap height
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
* @readonly
|
||
*/
|
||
imageHeight: {
|
||
get: function () {
|
||
return this.data.imageheight;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tileset bitmap width
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
* @readonly
|
||
*/
|
||
imageWidth: {
|
||
get: function () {
|
||
return this.data.imagewidth;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
* @readonly
|
||
*/
|
||
tileHeight: {
|
||
get: function () {
|
||
return this.data.tileheight;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Tileset#
|
||
* @readonly
|
||
*/
|
||
tileWidth: {
|
||
get: function () {
|
||
return this.data.tilewidth || 0;
|
||
},
|
||
},
|
||
});
|
||
|
||
/**
|
||
* Setup things after loaded data
|
||
*
|
||
* @private
|
||
*/
|
||
Tileset.prototype._setupData = function () {
|
||
if (!!this.data) {
|
||
this.bitmap = ImageManager.loadParserTileset(this.data.image, 0);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Get number of tiles in each line of tileset
|
||
*
|
||
* @return {number} Tiles count
|
||
* @private
|
||
*/
|
||
Tileset.prototype._countTilesHorizontal = function () {
|
||
return Math.floor(this.imageWidth / this.tileWidth);
|
||
};
|
||
|
||
/**
|
||
* Get number of tiles in each column of tileset
|
||
*
|
||
* @return {number} Tiles count
|
||
* @private
|
||
*/
|
||
Tileset.prototype._countTilesVertical = function () {
|
||
return Math.floor(this.imageHeight / this.tileHeight);
|
||
};
|
||
|
||
/**
|
||
* Get total tiles in tileset
|
||
*
|
||
* @return {number} Tiles count
|
||
*/
|
||
Tileset.prototype.getTotalTiles = function () {
|
||
return this._countTilesHorizontal() * this._countTilesVertical();
|
||
};
|
||
|
||
/**
|
||
* Get grid position of tile, take tile ID as param
|
||
*
|
||
* @param {number} id Tile ID in layer data
|
||
* @return {Object} Object contains {x,y}
|
||
* @private
|
||
*/
|
||
Tileset.prototype._getTilePosition = function (id) {
|
||
var realId = id - this.firstId,
|
||
result = { x: 0, y: 0 },
|
||
tileX = realId % this._countTilesHorizontal(),
|
||
tileY = Math.floor(realId / this._countTilesHorizontal());
|
||
|
||
result.x = tileX;
|
||
result.y = tileY;
|
||
|
||
return result;
|
||
};
|
||
|
||
/**
|
||
* Get tile block rectangle, take tile ID as param
|
||
*
|
||
* @param {number} id Tile ID in layer data
|
||
* @return {Object} Object contains {x,y,width,height}
|
||
* @private
|
||
*/
|
||
Tileset.prototype._getTileBlock = function (id) {
|
||
var pos = this._getTilePosition(id);
|
||
var result = { x: 0, y: 0, width: 0, height: 0 };
|
||
|
||
result.x = pos.x * this.tileWidth;
|
||
result.y = pos.y * this.tileHeight;
|
||
result.width = this.tileWidth;
|
||
result.height = this.tileHeight;
|
||
|
||
return result;
|
||
};
|
||
|
||
/**
|
||
* Get parameters for bitmap block transfer function
|
||
*
|
||
* @param {number} id Tile ID in layer data
|
||
* @param {number} x Destination X
|
||
* @param {number} y Destination Y
|
||
* @return {number[]} Array parameters
|
||
*/
|
||
Tileset.prototype.getBlockTransferParams = function (id, x, y) {
|
||
var tileBlock = this._getTileBlock(id);
|
||
var result = [];
|
||
|
||
result.push(this.bitmap);
|
||
result.push(tileBlock.x, tileBlock.y, tileBlock.width, tileBlock.height);
|
||
result.push(x, y);
|
||
|
||
return result;
|
||
};
|
||
|
||
/**
|
||
* Check if tile ID is included in tileset
|
||
*
|
||
* @param {number} id Tile ID in layer data
|
||
* @return {Boolean} Is in tileset
|
||
*/
|
||
Tileset.prototype.isInTileset = function (id) {
|
||
var lastId = this.firstId + this.getTotalTiles();
|
||
|
||
return id >= this.firstId && id < lastId;
|
||
};
|
||
|
||
/**
|
||
* Check if the tileset bitmap is finished loading
|
||
*
|
||
* @return {Boolean} Ready Flag
|
||
*/
|
||
Tileset.prototype.isReady = function () {
|
||
return ImageManager.isReady();
|
||
};
|
||
|
||
YED.Tilemap.Tileset = Tileset;
|
||
})();
|
||
|
||
/* globals YED: false */
|
||
|
||
(function () {
|
||
/**
|
||
* The Layer object extends Sprite object in RMMV framework, is created
|
||
* by {@link YED.Tilemap.Core} to render a layer in tilemap
|
||
*
|
||
* A Layer can be created and render by simply creating a new Layer object
|
||
* and add into a {@link http://www.goodboydigital.com/pixijs/docs/classes/DisplayObjectContainer.html PIXI.DisplayObjectContainer} object:
|
||
*
|
||
* ```js
|
||
* var layer = new YED.Tilemap.Layer(data, tilesets, tileWidth, tileHeight);
|
||
* scene.addChild(layer);
|
||
* ```
|
||
*
|
||
* @class
|
||
* @extends Sprite
|
||
* @memberof YED.Tilemap
|
||
* @param {Object} data A Layer data gets from {@link YED.Tilemap.Data#layers Tilemap.Data#layers}
|
||
* @param {YED.Tilemap.Tileset[]} tilesets An array of {@link YED.Tilemap.Tileset Tilemap.Tileset}
|
||
* @param {number} tileWidth Width of each tile
|
||
* @param {number} tileHeight Height of each tile
|
||
*/
|
||
var Layer = function () {
|
||
this.initialize.apply(this, arguments);
|
||
};
|
||
|
||
// extends Sprite
|
||
Layer.prototype = Object.create(Sprite.prototype);
|
||
Layer.prototype.constructor = Layer;
|
||
|
||
// initialize, inherited from Sprite
|
||
Layer.prototype.initialize = function (
|
||
data,
|
||
tilesets,
|
||
tileWidth,
|
||
tileHeight
|
||
) {
|
||
Sprite.prototype.initialize.call(this);
|
||
|
||
this.data = data;
|
||
this.tilesets = tilesets;
|
||
|
||
this.tileWidth = tileWidth;
|
||
this.tileHeight = tileHeight;
|
||
|
||
this._tilingSprite = null;
|
||
|
||
if (!this.data.visible) {
|
||
this.visible = false;
|
||
}
|
||
};
|
||
|
||
Object.defineProperties(Layer.prototype, {
|
||
/**
|
||
* Layer data get from tilemap data
|
||
*
|
||
* @member {Object}
|
||
* @memberof YED.Tilemap.Layer#
|
||
*/
|
||
data: {
|
||
get: function () {
|
||
return this._data || null;
|
||
},
|
||
|
||
set: function (data) {
|
||
this._data = data;
|
||
this._setupData();
|
||
},
|
||
},
|
||
|
||
gridHorz: {
|
||
get: function () {
|
||
return this._gridHorz || 0;
|
||
},
|
||
|
||
set: function (grid) {
|
||
this._gridHorz = grid;
|
||
},
|
||
},
|
||
|
||
gridVert: {
|
||
get: function () {
|
||
return this._gridVert || 0;
|
||
},
|
||
|
||
set: function (grid) {
|
||
this._gridVert = grid;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Height of each tile in layer
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Layer#
|
||
*/
|
||
tileHeight: {
|
||
get: function () {
|
||
return this._tileHeight || 0;
|
||
},
|
||
|
||
set: function (height) {
|
||
this._tileHeight = height;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Width of each tile in layer
|
||
*
|
||
* @member {number}
|
||
* @memberof YED.Tilemap.Layer#
|
||
*/
|
||
tileWidth: {
|
||
get: function () {
|
||
return this._tileWidth || 0;
|
||
},
|
||
|
||
set: function (width) {
|
||
this._tileWidth = width;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tiles data, an one dimensional array contains tile IDs
|
||
*
|
||
* @member {number[]}
|
||
* @memberof YED.Tilemap.Layer#
|
||
* @readonly
|
||
*/
|
||
tilesData: {
|
||
get: function () {
|
||
return this.data.data;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Objects data, an one dimensional array contains object data
|
||
*
|
||
* @member {Object[]}
|
||
* @memberof YED.Tilemap.Layer#
|
||
* @readonly
|
||
*/
|
||
objectsData: {
|
||
get: function () {
|
||
return this.data.objects;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Tilesets used for layer
|
||
*
|
||
* @member {YED.Tilemap.Tileset[]}
|
||
* @memberof YED.Tilemap.Layer#
|
||
*/
|
||
tilesets: {
|
||
get: function () {
|
||
return this._tilesets || [];
|
||
},
|
||
|
||
set: function (tilesets) {
|
||
this._tilesets = tilesets;
|
||
},
|
||
},
|
||
|
||
/**
|
||
* Layer custom properties
|
||
*
|
||
* @member {Object}
|
||
* @memberof YED.Tilemap.Layer#
|
||
* @readonly
|
||
*/
|
||
properties: {
|
||
get: function () {
|
||
return this.data.properties || {};
|
||
},
|
||
},
|
||
});
|
||
|
||
/**
|
||
* Setup things after loaded data
|
||
*
|
||
* @private
|
||
*/
|
||
Layer.prototype._setupData = function () {
|
||
if (!!this.data) {
|
||
this.gridHorz = this.data.width;
|
||
this.gridVert = this.data.height;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Check if layer is tile-based layer
|
||
*
|
||
* @return {Boolean}
|
||
*/
|
||
Layer.prototype.isTileLayer = function () {
|
||
return this.data.type === "tilelayer";
|
||
};
|
||
|
||
/**
|
||
* Check if layer is object-based layer or tile-based layer
|
||
*
|
||
* @return {Boolean}
|
||
*/
|
||
Layer.prototype.isObjectLayer = function () {
|
||
return this.data.type === "objectgroup";
|
||
};
|
||
|
||
/**
|
||
* Check if layer is image-based layer
|
||
*
|
||
* @return {Boolean}
|
||
*/
|
||
Layer.prototype.isImageLayer = function () {
|
||
return this.data.type === "imagelayer";
|
||
};
|
||
|
||
/**
|
||
* Check if layer is plane layer
|
||
*
|
||
* @return {Boolean}
|
||
*/
|
||
Layer.prototype.isPlaneLayer = function () {
|
||
return (
|
||
this.isImageLayer() && !!this.properties && !!this.properties.parallax
|
||
);
|
||
};
|
||
|
||
Layer.prototype.isLoopHorizontal = function () {
|
||
return $gameMap.isLoopHorizontal();
|
||
};
|
||
|
||
Layer.prototype.isLoopVertical = function () {
|
||
return $gameMap.isLoopVertical();
|
||
};
|
||
|
||
Layer.prototype.isLoop = function () {
|
||
return this.isLoopHorizontal() || this.isLoopVertical();
|
||
};
|
||
|
||
Layer.prototype.isCollisionLayer = function () {
|
||
return !!this.properties && !!this.properties.collision;
|
||
};
|
||
|
||
Layer.prototype.isRegionLayer = function () {
|
||
return !!this.properties && !!this.properties.regionId;
|
||
};
|
||
|
||
Layer.prototype.isUpperLayer = function () {
|
||
if (!!this.properties.layer) {
|
||
return this.properties.layer.toLowerCase() === "upper";
|
||
}
|
||
|
||
return false;
|
||
};
|
||
|
||
/**
|
||
* Render layer with given data and tilesets
|
||
*/
|
||
Layer.prototype.renderLayer = function () {
|
||
this._layerBitmap =
|
||
this._layerBitmap ||
|
||
new Bitmap(
|
||
this.gridHorz * this.tileWidth,
|
||
this.gridVert * this.tileHeight
|
||
);
|
||
|
||
// different methods for tile-based and object-based layer
|
||
if (this.isObjectLayer()) {
|
||
this._renderObjectLayer();
|
||
}
|
||
|
||
if (this.isTileLayer()) {
|
||
this._renderTileLayer();
|
||
}
|
||
|
||
if (this.isImageLayer() && !this.isPlaneLayer()) {
|
||
this._renderImageLayer();
|
||
}
|
||
|
||
if (this.isPlaneLayer()) {
|
||
this._renderPlaneLayer();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Render tile-based layer
|
||
*
|
||
* @private
|
||
*/
|
||
Layer.prototype._renderTileLayer = function () {
|
||
var i = 0,
|
||
length = this.tilesData.length, // tiles data iterator, fuck js
|
||
tileId,
|
||
bitmapX,
|
||
bitmapY;
|
||
|
||
for (; i < length; i++) {
|
||
tileId = this.tilesData[i];
|
||
|
||
bitmapX = i % this._gridHorz;
|
||
bitmapX = bitmapX * this.tileWidth;
|
||
|
||
bitmapY = Math.floor(i / this._gridHorz);
|
||
bitmapY = bitmapY * this.tileHeight;
|
||
|
||
// skip tileId zero (none tile)
|
||
if (tileId === 0) {
|
||
continue;
|
||
}
|
||
|
||
this._drawTile(tileId, bitmapX, bitmapY);
|
||
}
|
||
|
||
if (this.isLoop) {
|
||
this._renderLoopLayer();
|
||
} else {
|
||
this.bitmap = this._layerBitmap;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Render object-based layer
|
||
*
|
||
* @private
|
||
*/
|
||
Layer.prototype._renderObjectLayer = function () {
|
||
var i = 0,
|
||
length = this.objectsData.length,
|
||
tileId,
|
||
bitmapX,
|
||
bitmapY,
|
||
data;
|
||
|
||
for (; i < length; i++) {
|
||
data = this.objectsData[i];
|
||
|
||
tileId = data.gid;
|
||
|
||
bitmapX = Math.round(data.x);
|
||
bitmapY = Math.round(data.y - data.height);
|
||
|
||
if (tileId === 0) {
|
||
continue;
|
||
}
|
||
|
||
this._drawTile(tileId, bitmapX, bitmapY);
|
||
}
|
||
|
||
if (this.isLoop) {
|
||
this._renderLoopLayer();
|
||
} else {
|
||
this.bitmap = this._layerBitmap;
|
||
}
|
||
};
|
||
|
||
Layer.prototype._renderLoopLayer = function () {
|
||
var tilingWidth, tilingHeight;
|
||
|
||
tilingWidth = this.isLoopHorizontal()
|
||
? Graphics.width
|
||
: this._layerBitmap.width;
|
||
|
||
tilingHeight = this.isLoopVertical()
|
||
? Graphics.height
|
||
: this._layerBitmap.height;
|
||
|
||
this._tilingSprite = new TilingSprite(this._layerBitmap);
|
||
this._tilingSprite.move(0, 0, tilingWidth, tilingHeight);
|
||
this.addChild(this._tilingSprite);
|
||
};
|
||
|
||
/**
|
||
* Render object-based layer
|
||
*
|
||
* @private
|
||
*/
|
||
Layer.prototype._renderImageLayer = function () {
|
||
var dest = this._layerBitmap,
|
||
img = ImageManager.loadParserParallax(this.data.image, 0);
|
||
|
||
dest.blt(img, 0, 0, img.width, img.height, this.data.x, this.data.y);
|
||
this.bitmap = this._layerBitmap;
|
||
};
|
||
|
||
/**
|
||
* Render object-based layer
|
||
*
|
||
* @private
|
||
*/
|
||
Layer.prototype._renderPlaneLayer = function () {
|
||
var img = ImageManager.loadParserParallax(this.data.image, 0);
|
||
|
||
this._tilingSprite = new TilingSprite(img);
|
||
this._tilingSprite.move(
|
||
this.data.x,
|
||
this.data.y,
|
||
Graphics.width,
|
||
Graphics.height
|
||
);
|
||
this.addChild(this._tilingSprite);
|
||
};
|
||
|
||
/**
|
||
* Get tileset which contains the drawing tile
|
||
*
|
||
* @param {number} tileId Tile ID in layer data
|
||
* @return {YED.Tilemap.Tileset|null} Tileset contains tile ID
|
||
* @private
|
||
*/
|
||
Layer.prototype._getTileset = function (tileId) {
|
||
var i = 0,
|
||
length = this.tilesets.length,
|
||
tileset; // for tilesets iterator
|
||
|
||
for (; i < length; i++) {
|
||
tileset = this.tilesets[i];
|
||
|
||
// skip current tileset if tileId is not in this tileset
|
||
if (tileset.isInTileset(tileId) === false) {
|
||
continue;
|
||
}
|
||
|
||
return tileset;
|
||
} // end tilesets loop
|
||
|
||
return null;
|
||
};
|
||
|
||
/**
|
||
* Draw a tile on specific coordination
|
||
*
|
||
* @param {number} tileId Tile ID in layer data
|
||
* @param {number} x Real X on bitmap
|
||
* @param {number} y Real Y on bitmap
|
||
*/
|
||
Layer.prototype._drawTile = function (tileId, x, y) {
|
||
var tileset = this._getTileset(tileId);
|
||
var params = tileset.getBlockTransferParams(tileId, x, y);
|
||
var dest = this._layerBitmap;
|
||
|
||
dest.blt.apply(dest, params);
|
||
};
|
||
|
||
Layer.prototype.update = function () {
|
||
this._updatePlane();
|
||
};
|
||
|
||
Layer.prototype._updatePlane = function () {
|
||
var xSpeed = parseInt(this.properties.planeX),
|
||
ySpeed = parseInt(this.properties.planeY),
|
||
ox,
|
||
oy,
|
||
mOx,
|
||
mOy;
|
||
|
||
if (!this._tilingSprite) {
|
||
return;
|
||
}
|
||
|
||
ox = this._tilingSprite.origin.x;
|
||
oy = this._tilingSprite.origin.y;
|
||
|
||
mOx = this._tilingSprite.bitmap.width;
|
||
mOy = this._tilingSprite.bitmap.height;
|
||
|
||
if (!!xSpeed) {
|
||
this._tilingSprite.origin.x = (ox + xSpeed) % mOx;
|
||
}
|
||
|
||
if (!!ySpeed) {
|
||
this._tilingSprite.origin.y = (oy + ySpeed) % mOy;
|
||
}
|
||
};
|
||
|
||
Layer.prototype.moveLoopLayer = function (x, y) {
|
||
if (!this._tilingSprite) {
|
||
return;
|
||
}
|
||
|
||
this._tilingSprite.origin.x = x;
|
||
this._tilingSprite.origin.y = y;
|
||
};
|
||
|
||
YED.Tilemap.Layer = Layer;
|
||
})();
|
||
|
||
/* globals YED: false */
|
||
|
||
(function () {
|
||
// Shorten dependencies
|
||
var Data = YED.Tilemap.Data,
|
||
Tileset = YED.Tilemap.Tileset,
|
||
Layer = YED.Tilemap.Layer;
|
||
|
||
/**
|
||
* The Core object is the bootstrap to load and render tilemap to the screen
|
||
*
|
||
* A tilemap can be created inside a scene with a single statement
|
||
*
|
||
* ```js
|
||
* var tilemap = new YED.Tilemap.Core();
|
||
* this.addChild(tilemap); // add tilemap to scene
|
||
* ```
|
||
*
|
||
* @class
|
||
* @extends PIXI.DisplayObjectContainer
|
||
* @memberof YED.Tilemap
|
||
*/
|
||
var Core = function () {
|
||
PIXI.DisplayObjectContainer.call(this);
|
||
|
||
this.setup();
|
||
};
|
||
|
||
Core.dataMap = null;
|
||
Core.noMap = false;
|
||
Core.singleton = null;
|
||
|
||
Core.loadMapFile = function () {
|
||
var filePath = Core.getFilePath();
|
||
Core.loadFile(filePath);
|
||
};
|
||
|
||
Core.unloadMap = function () {
|
||
Core.dataMap = null;
|
||
Core.noMap = false;
|
||
};
|
||
|
||
Core.loadFile = function (filePath) {
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("GET", filePath);
|
||
xhr.overrideMimeType("application/json");
|
||
|
||
// on success callback
|
||
xhr.onreadystatechange = function () {
|
||
if (xhr.readyState === 4) {
|
||
if (xhr.status === 200 || xhr.responseText !== "") {
|
||
Core.dataMap = JSON.parse(xhr.responseText);
|
||
} else {
|
||
// Core.noMap = true;
|
||
throw new Error("[YED#Tilemap] Loading error");
|
||
}
|
||
}
|
||
};
|
||
|
||
// set data to null and send request
|
||
Core.unloadMap();
|
||
xhr.send();
|
||
};
|
||
|
||
/**
|
||
* Get file path with filename to the json file for automatically loading
|
||
*
|
||
* @return {string} The path and filename to json file
|
||
* @private
|
||
*/
|
||
Core.getFilePath = function () {
|
||
return Core.getPath() + Core.getFilename();
|
||
};
|
||
|
||
/**
|
||
* Get path to json file
|
||
*
|
||
* @return {string} The path to json file
|
||
* @private
|
||
*/
|
||
Core.getPath = function () {
|
||
return "./maps/";
|
||
};
|
||
|
||
/**
|
||
* Get json filename
|
||
*
|
||
* @return {string} Filename
|
||
* @private
|
||
*/
|
||
Core.getFilename = function () {
|
||
var id = Core.getMapId();
|
||
return "Map" + id + ".json";
|
||
};
|
||
|
||
/**
|
||
* Get map ID from RMMV framework for search json file
|
||
*
|
||
* @return {number} Map ID
|
||
* @private
|
||
*/
|
||
Core.getMapId = function () {
|
||
var isTransferring = $gamePlayer.isTransferring();
|
||
return isTransferring ? $gamePlayer.newMapId() : $gameMap.mapId();
|
||
};
|
||
|
||
Core.isMapLoaded = function () {
|
||
return !!Core.dataMap || !!Core.noMap;
|
||
};
|
||
|
||
Core.isDefaultMap = function () {
|
||
return !Core.dataMap && !!Core.noMap;
|
||
};
|
||
|
||
Core.prototype = Object.create(PIXI.DisplayObjectContainer.prototype);
|
||
Core.prototype.constructor = Core;
|
||
|
||
Object.defineProperties(Core.prototype, {
|
||
data: {
|
||
get: function () {
|
||
return this._data || null;
|
||
},
|
||
|
||
set: function (data) {
|
||
this._data = data;
|
||
},
|
||
},
|
||
|
||
tilesets: {
|
||
get: function () {
|
||
return this._tilesets || [];
|
||
},
|
||
|
||
set: function (tilesets) {
|
||
this._tilesets = tilesets;
|
||
},
|
||
},
|
||
|
||
layers: {
|
||
get: function () {
|
||
return this.lowerLayers.concat(this.upperLayers);
|
||
},
|
||
},
|
||
|
||
upperLayers: {
|
||
get: function () {
|
||
return this._upperLayers;
|
||
},
|
||
},
|
||
|
||
lowerLayers: {
|
||
get: function () {
|
||
return this._lowerLayers;
|
||
},
|
||
},
|
||
});
|
||
|
||
Core.prototype.setup = function () {
|
||
this._clearData();
|
||
this._setupData();
|
||
this._setupLayers();
|
||
this._setupTilesets();
|
||
this._setupParallaxes();
|
||
};
|
||
|
||
Core.prototype._clearData = function () {
|
||
this._data = null;
|
||
this._tilesets = [];
|
||
this._needRefresh = false;
|
||
this._upperLayers = [];
|
||
this._lowerLayers = [];
|
||
this.z = -1;
|
||
};
|
||
|
||
Core.prototype._setupData = function () {
|
||
this.data = new Data(Core.dataMap);
|
||
};
|
||
|
||
Core.prototype._setupTilesets = function () {
|
||
var tilesetsData = this.data.tilesets,
|
||
i = 0,
|
||
length = tilesetsData.length,
|
||
data;
|
||
|
||
for (; i < length; i++) {
|
||
data = tilesetsData[i];
|
||
this.tilesets.push(new Tileset(data));
|
||
}
|
||
};
|
||
|
||
Core.prototype._setupParallaxes = function () {
|
||
var imageData = this.data.getImageLayers(),
|
||
i = 0,
|
||
length = imageData.length;
|
||
|
||
for (; i < length; i++) {
|
||
ImageManager.loadParserParallax(imageData[i].image, 0);
|
||
}
|
||
};
|
||
|
||
Core.prototype._setupLayers = function () {
|
||
var layersData = this.data.layers,
|
||
i = 0,
|
||
length = layersData.length,
|
||
data,
|
||
layer;
|
||
|
||
for (; i < length; i++) {
|
||
data = layersData[i];
|
||
layer = new Layer(
|
||
data,
|
||
this.tilesets,
|
||
this.data.tileWidth,
|
||
this.data.tileHeight
|
||
);
|
||
|
||
if (layer.isUpperLayer()) {
|
||
this.upperLayers.push(layer);
|
||
} else {
|
||
this.lowerLayers.push(layer);
|
||
}
|
||
|
||
// this.addChild(layer);
|
||
// this.layers.push(layer);
|
||
}
|
||
};
|
||
|
||
Core.prototype.update = function () {
|
||
this._updateRender();
|
||
};
|
||
|
||
Core.prototype._updateRender = function () {
|
||
if (this._needRefresh && ImageManager.isReady()) {
|
||
this.render();
|
||
this._needRefresh = false;
|
||
}
|
||
};
|
||
|
||
Core.prototype.render = function () {
|
||
var layers = this.layers,
|
||
i = 0,
|
||
length = layers.length,
|
||
layer;
|
||
|
||
for (; i < length; i++) {
|
||
layer = layers[i];
|
||
layer.renderLayer();
|
||
}
|
||
};
|
||
|
||
Core.prototype.refresh = function () {
|
||
this._needRefresh = true;
|
||
};
|
||
|
||
/**
|
||
* Check if map data exists
|
||
*
|
||
* @return {Boolean} Exist flag
|
||
*/
|
||
Core.prototype.isExist = function () {
|
||
return this.data.isExist();
|
||
};
|
||
|
||
YED.Tilemap.Core = Core;
|
||
})();
|
||
|
||
/* globals YED: false */
|
||
|
||
(function () {
|
||
var _DataManager_loadMapData = DataManager.loadMapData;
|
||
var _DataManager_isMapLoaded = DataManager.isMapLoaded;
|
||
var _Scene_Map_onMapLoaded = Scene_Map.prototype.onMapLoaded;
|
||
var _Game_Map_setup = Game_Map.prototype.setup;
|
||
var _Game_Map_tileWidth = Game_Map.prototype.tileWidth;
|
||
var _Game_Map_tileHeight = Game_Map.prototype.tileHeight;
|
||
var _Game_Map_width = Game_Map.prototype.width;
|
||
var _Game_Map_height = Game_Map.prototype.height;
|
||
var _Game_Event_setupPage = Game_Event.prototype.setupPage;
|
||
var _Game_CharacterBase_distancePerFrame =
|
||
Game_CharacterBase.prototype.distancePerFrame;
|
||
var _Spriteset_Map_createTilemap = Spriteset_Map.prototype.createTilemap;
|
||
|
||
DataManager.loadMapData = function (mapId) {
|
||
_DataManager_loadMapData.call(this, mapId);
|
||
|
||
this.loadYEDMapData(mapId);
|
||
};
|
||
|
||
DataManager.loadYEDMapData = function (mapId) {
|
||
if (mapId > 0) {
|
||
YED.Tilemap.Core.loadMapFile();
|
||
} else {
|
||
YED.Tilemap.Core.unloadMap();
|
||
}
|
||
};
|
||
|
||
DataManager.isMapLoaded = function () {
|
||
var defaultLoaded = _DataManager_isMapLoaded.call(this);
|
||
var yedTilemapLoaded = YED.Tilemap.Core.isMapLoaded();
|
||
|
||
return defaultLoaded && yedTilemapLoaded;
|
||
};
|
||
|
||
Scene_Map.prototype.onMapLoaded = function () {
|
||
$gameMap.setupYEDTilemap();
|
||
|
||
_Scene_Map_onMapLoaded.call(this);
|
||
};
|
||
|
||
Game_Map.prototype.setup = function (mapId) {
|
||
this.setupYEDTilemap();
|
||
|
||
_Game_Map_setup.call(this, mapId);
|
||
};
|
||
|
||
Game_Map.prototype.setupYEDTilemap = function () {
|
||
// this._yed_tilemap = new YED.Tilemap.Core();
|
||
YED.Tilemap.Core.singleton =
|
||
YED.Tilemap.Core.singleton || new YED.Tilemap.Core();
|
||
|
||
YED.Tilemap.Core.singleton.setup();
|
||
|
||
// overwrite dataMap width/height
|
||
$dataMap.width = this._yedTilemapData().width;
|
||
$dataMap.height = this._yedTilemapData().height;
|
||
};
|
||
|
||
Game_Map.prototype._yedTilemapData = function () {
|
||
return YED.Tilemap.Core.singleton.data;
|
||
};
|
||
|
||
Game_Map.prototype.oldTileWidth = function () {
|
||
return _Game_Map_tileWidth.call(this);
|
||
};
|
||
|
||
Game_Map.prototype.oldTileHeight = function () {
|
||
return _Game_Map_tileHeight.call(this);
|
||
};
|
||
|
||
Game_Map.prototype.oldWidth = function () {
|
||
return _Game_Map_width.call(this);
|
||
};
|
||
|
||
Game_Map.prototype.oldHeight = function () {
|
||
return _Game_Map_height.call(this);
|
||
};
|
||
|
||
Game_Map.prototype.tileWidth = function () {
|
||
return this._yedTilemapData().tileWidth;
|
||
};
|
||
|
||
Game_Map.prototype.tileHeight = function () {
|
||
return this._yedTilemapData().tileHeight;
|
||
};
|
||
|
||
Game_Map.prototype.width = function () {
|
||
return this._yedTilemapData().width;
|
||
};
|
||
|
||
Game_Map.prototype.height = function () {
|
||
return this._yedTilemapData().height;
|
||
};
|
||
|
||
Game_Map.prototype.defaultMapX = function () {
|
||
return this._yedTilemapData().properties.defaultMapX || 0;
|
||
};
|
||
|
||
Game_Map.prototype.defaultMapY = function () {
|
||
return this._yedTilemapData().properties.defaultMapY || 0;
|
||
};
|
||
|
||
Game_Map.prototype.tilemapUpperLayers = function () {
|
||
return YED.Tilemap.Core.singleton.upperLayers;
|
||
};
|
||
|
||
Game_Map.prototype.tilemapLowerLayers = function () {
|
||
return YED.Tilemap.Core.singleton.lowerLayers;
|
||
};
|
||
|
||
Game_Map.prototype.tilemapRefresh = function () {
|
||
YED.Tilemap.Core.singleton.refresh();
|
||
};
|
||
|
||
Game_Map.prototype.isPassable = function (x, y, d) {
|
||
var collision = this._yedTilemapData().collision,
|
||
arrows = this._yedTilemapData().arrows,
|
||
index = this.width() * y + x;
|
||
|
||
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 collision[index] === 0;
|
||
};
|
||
|
||
Game_Map.prototype.regionId = function (x, y) {
|
||
var regions = this._yedTilemapData().region,
|
||
index = this.width() * y + x;
|
||
|
||
return regions[index];
|
||
};
|
||
|
||
Game_CharacterBase.prototype.distancePerFrame = function () {
|
||
var distance = _Game_CharacterBase_distancePerFrame.call(this);
|
||
return distance * (48 / $gameMap.tileWidth());
|
||
};
|
||
|
||
Game_Event.prototype.setupPage = function () {
|
||
this.setupInitPosition();
|
||
|
||
_Game_Event_setupPage.call(this);
|
||
};
|
||
|
||
Game_Event.prototype.setupInitPosition = function () {
|
||
var list,
|
||
tag = /<position:[ ]*(\d+),[ ]*(\d+)>/i,
|
||
command,
|
||
comment,
|
||
matches,
|
||
x,
|
||
y;
|
||
|
||
if (!this.page()) {
|
||
return;
|
||
}
|
||
|
||
list = this.list();
|
||
|
||
for (var i = 0; i < list.length; i++) {
|
||
command = list[i];
|
||
|
||
if (command.code !== 108) {
|
||
continue;
|
||
}
|
||
|
||
comment = command.parameters[0];
|
||
matches = comment.match(tag);
|
||
if (matches) {
|
||
x = parseInt(matches[1]);
|
||
y = parseInt(matches[2]);
|
||
this.setPosition(x, y);
|
||
}
|
||
}
|
||
};
|
||
|
||
Spriteset_Map.prototype.createTilemap = function () {
|
||
_Spriteset_Map_createTilemap.call(this);
|
||
this._tilemap.tileWidth = $gameMap.oldTileWidth();
|
||
this._tilemap.tileHeight = $gameMap.oldTileHeight();
|
||
this._tilemap.setData(
|
||
$gameMap.oldWidth(),
|
||
$gameMap.oldHeight(),
|
||
$gameMap.data()
|
||
);
|
||
};
|
||
|
||
Tilemap.prototype.refresh = function () {
|
||
this._needsRepaint = true; // no need to draw default tiles
|
||
this._lastTiles.length = 0;
|
||
$gameMap.tilemapRefresh();
|
||
};
|
||
|
||
Tilemap.prototype._createLayers = function () {
|
||
var margin = this._margin,
|
||
upperLayers = $gameMap.tilemapUpperLayers(),
|
||
lowerLayers = $gameMap.tilemapLowerLayers(),
|
||
tileCols = Math.ceil(this._width / this._tileWidth) + 1,
|
||
tileRows = Math.ceil(this._height / this._tileHeight) + 1,
|
||
layerWidth = tileCols * this._tileWidth,
|
||
layerHeight = tileRows * this._tileHeight,
|
||
i;
|
||
|
||
this._lowerBitmap = new Bitmap(layerWidth, layerHeight);
|
||
this._upperBitmap = new Bitmap(layerWidth, layerHeight);
|
||
|
||
this._layerWidth = layerWidth;
|
||
this._layerHeight = layerHeight;
|
||
|
||
/*
|
||
* Z coordinate:
|
||
*
|
||
* 0 : Lower tiles
|
||
* 1 : Lower characters
|
||
* 3 : Normal characters
|
||
* 4 : Upper tiles
|
||
* 5 : Upper characters
|
||
* 6 : Airship shadow
|
||
* 7 : Balloon
|
||
* 8 : Animation
|
||
* 9 : Destination
|
||
*/
|
||
|
||
this._lowerLayer = new Sprite();
|
||
this._lowerLayer.move(-margin, -margin, this._width, this._height);
|
||
this._lowerLayer.z = 0;
|
||
|
||
this._upperLayer = new Sprite();
|
||
this._upperLayer.move(-margin, -margin, this._width, this._height);
|
||
this._upperLayer.z = 4;
|
||
|
||
for (i = 0; i < lowerLayers.length; i++) {
|
||
this._lowerLayer.addChild(lowerLayers[i]);
|
||
}
|
||
|
||
for (i = 0; i < upperLayers.length; i++) {
|
||
this._upperLayer.addChild(upperLayers[i]);
|
||
}
|
||
|
||
this.addChild(this._lowerLayer);
|
||
this.addChild(this._upperLayer);
|
||
this.addChild(YED.Tilemap.Core.singleton);
|
||
};
|
||
|
||
Tilemap.prototype._updateLayerPositions = function (startX, startY) {
|
||
/* jshint unused:vars */
|
||
var m = this._margin,
|
||
ox = Math.floor(this.origin.x),
|
||
oy = Math.floor(this.origin.y),
|
||
x2 = -(ox - m),
|
||
y2 = -(oy - m);
|
||
|
||
// TODO: Loop map!!!
|
||
|
||
var moveFunc = function (layer) {
|
||
if (
|
||
!layer.isPlaneLayer() &&
|
||
!layer.isLoopVertical() &&
|
||
!layer.isLoopHorizontal()
|
||
) {
|
||
layer.move(x2, y2);
|
||
}
|
||
|
||
if (
|
||
!layer.isPlaneLayer() &&
|
||
layer.isLoopVertical() &&
|
||
layer.isLoopHorizontal()
|
||
) {
|
||
layer.move(m, m);
|
||
layer.moveLoopLayer(ox, oy);
|
||
return;
|
||
}
|
||
|
||
if (!layer.isPlaneLayer() && layer.isLoopHorizontal()) {
|
||
layer.move(m, y2);
|
||
layer.moveLoopLayer(ox, 0);
|
||
return;
|
||
}
|
||
|
||
if (!layer.isPlaneLayer() && layer.isLoopVertical()) {
|
||
layer.move(x2, m);
|
||
layer.moveLoopLayer(0, oy);
|
||
return;
|
||
}
|
||
|
||
if (layer.isPlaneLayer()) {
|
||
layer.move(m, m);
|
||
}
|
||
};
|
||
|
||
for (var i = 0; i < 2; i++) {
|
||
var children;
|
||
|
||
if (i === 0) {
|
||
children = this._lowerLayer.children;
|
||
} else {
|
||
children = this._upperLayer.children;
|
||
}
|
||
|
||
children.forEach(moveFunc);
|
||
}
|
||
|
||
// this._updateDefaultLayerPositions(startX, startY);
|
||
};
|
||
|
||
// Tilemap.prototype._paintAllTiles = function(startX, startY) {
|
||
// /* jshint unused:vars */
|
||
// // destroy method
|
||
// };
|
||
})();
|