code:
Sea|海
Deep Sea|深い海
Rock Shoal|岩礁
Icebergs|氷山
Poison Swamp|毒の沼
Dead Trees|枯れ木
Lava|溶岩
Lava Bubbles|溶岩の泡
Pond|池
Boulder|岩
Frozen Sea|凍った海
Whirlpool|渦
Land's End|大地の境界
Endless Waterfall|下界に落ちる滝
Cloud (Land's End)|雲（大地の境界）
Cloud|雲


code:
Grassland A|草原A
Grassland A (Dark)|草原A（濃）
Grassland B|草原B
Grassland B (Dark)|草原B（濃）
Forest|森
Forest (Conifer)|森（針葉樹）
Hill (Grass)|丘（草）
Mountain (Dirt)|山（土）
Wasteland A|荒れ地A
Wasteland B|荒れ地B
Dirt Field A|土肌A
Dirt Field B|土肌B
Forest (Dead Trees)|森（枯れ木）
Road (Dirt)|道（土）
Hill (Dirt)|丘（土）
Mountain (Rock)|山（岩）
Desert A|砂漠A
Desert B|砂漠B
Rocky Land A|岩地A
Rocky Land B (Lava)|岩地B（溶岩）
Forest (Palm Trees)|森（ヤシの木）
Road (Paved)|道（舗装）
Hill (Sandstone)|丘（砂岩）
Mountain (Sandstone)|山（砂岩）
Snowfield|雪原
Hill (Snow)|丘（雪）
Clouds|雲
Large Clouds|大きな雲
Forest (Snow)|森（雪）
Pit|穴
Hill (Rock)|丘（岩）
Mountain (Snow)|山（雪）

repo_name: onms/sister

license: unknown


code:
Transparent|透明
Sign|立て札
Pier (H)|桟橋（横）
Pier (V)|桟橋（縦）
Pond|池
Oasis|オアシス
Pond (Ice)|池（氷）
Beanstalk|豆の木
Tent|テント
Igloo|氷の家
Pyramid|ピラミッド
Giant Tree|大樹
Giant Tree (Snow)|大樹（雪）
Dirt|土砂
Avalanche|雪崩
Beanstalk|豆の木
Cave A|洞窟A
Cave B|洞窟B
Cave (Collapsed)|洞窟（土砂崩れ）
Mine|坑道
Tunnel|トンネル
Tunnel (Blocked)|トンネル（通行止め）
Shrine|ほこら
Shrine (Snow)|ほこら（雪）
Crater|クレーター
Trail|山道
Rock Mountain|岩山
Rock Mountain|岩山
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Snow)|岩山（雪）
Rock Mountain (Snow)|岩山（雪）
Volcano Crater (Lava)|火口（溶岩）
Volcano Crater (Lava)|火口（溶岩）
Rock Mountain|岩山
Rock Mountain|岩山
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Snow)|岩山（雪）
Rock Mountain (Snow)|岩山（雪）
Volcano Crater|火口
Volcano Crater|火口
Rock Mountain|岩山
Rock Mountain|岩山
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Snow)|岩山（雪）
Rock Mountain (Snow)|岩山（雪）
Volcano|火山
Volcano|火山
Rock Mountain|岩山
Rock Mountain|岩山
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Sandstone)|岩山（砂岩）
Rock Mountain (Snow)|岩山（雪）
Rock Mountain (Snow)|岩山（雪）
Town A|町A
Town A|町A
Town B|町B
Town B|町B
Village A|村A
Village A|村A
Village B|村B
House (Town)|家（町）
Town C|町C
Town D|町D
Village C|村C
Village D|村D
Town E (Desert)|町E（砂漠）
Town E (Desert)|町E（砂漠）
Town F (Desert)|町F（砂漠）
House (Village)|家（村）
Town A (Snow)|町A（雪）
Town A (Snow)|町A（雪）
Town B (Snow)|町B（雪）
Town B (Snow)|町B（雪）
Town G (Desert)|町G（砂漠）
Town G (Desert)|町G（砂漠）
Large Tent|大きなテント
House (Desert)|家（砂漠）
Town C (Snow)|町C（雪）
Town D (Snow)|町D（雪）
Village C (Snow)|村C（雪）
Village D (Snow)|村D（雪）
Village A (Snow)|村A（雪）
Village A (Snow)|村A（雪）
Village B (Snow)|村B（雪）
House (Snow)|家（雪）
Fortress City |城塞都市
Fortress City |城塞都市
Fortress City (Snow)|城塞都市（雪）
Fortress City (Snow)|城塞都市（雪）
Large Mansion|大きな屋敷
Large Mansion|大きな屋敷
School of Magic|魔法学校
School of Magic|魔法学校
Fortress City |城塞都市
Fortress City |城塞都市
Fortress City (Snow)|城塞都市（雪）
Fortress City (Snow)|城塞都市（雪）
Large Mansion|大きな屋敷
Large Mansion|大きな屋敷
School of Magic|魔法学校
School of Magic|魔法学校
Bridge (H)|橋（横）
Bridge (V)|橋（縦）
Collapsed Bridge (H)|崩れた橋（横）
Collapsed Bridge (V)|崩れた橋（縦）
Snow Bridge (H)|雪の橋（横）
Snow Bridge (V)|雪の橋（縦）
Collapsed Snow Bridge (H)|崩れた雪の橋（横）
Collapsed Snow Bridge (V)|崩れた雪の橋（縦）
Tower A|塔A
Tower A (Ruins)|塔A（廃墟）
Tower B|塔B
Tower C|塔C
Tower A (Snow)|塔A（雪）
Tower D|塔D
Temple A|神殿A
Temple A (Snow)|神殿A（雪）
Tower A|塔A
Tower A (Ruins)|塔A（廃墟）
Tower B|塔B
Tower C|塔C
Tower A (Snow)|塔A（雪）
Tower D (Ruins)|塔D（廃墟）
Temple B|神殿B
Temple C|神殿C
Castle A|城A
Castle A|城A
Castle B|城B
Castle B|城B
Fort A|砦A
Fort A|砦A
Fort B|砦B
Fort B|砦B
Castle A|城A
Castle A|城A
Castle B|城B
Castle B|城B
Fort A|砦A
Fort A|砦A
Fort B|砦B
Fort B|砦B
Castle C|城C
Castle C|城C
Castle D|城D
Castle D|城D
Castle (Ruins)|城（廃墟）
Castle (Ruins)|城（廃墟）
Fort (Ruins)|砦（廃墟）
Fort (Ruins)|砦（廃墟）
Castle C|城C
Castle C|城C
Castle D|城D
Castle D|城D
Castle (Ruins)|城（廃墟）
Castle (Ruins)|城（廃墟）
Fort (Ruins)|砦（廃墟）
Fort (Ruins)|砦（廃墟）
Castle A, B (Snow)|城A・B（雪）
Castle A, B (Snow)|城A・B（雪）
Castle C, D (Snow)|城C・D（雪）
Castle C, D (Snow)|城C・D（雪）
Fort (Snow)|砦（雪）
Fort (Snow)|砦（雪）
Castle (Ruins, Snow)|城（廃墟・雪）
Castle (Ruins, Snow)|城（廃墟・雪）
Castle A, B (Snow)|城A・B（雪）
Castle A, B (Snow)|城A・B（雪）
Castle C, D (Snow)|城C・D（雪）
Castle C, D (Snow)|城C・D（雪）
Fort (Snow)|砦（雪）
Fort (Snow)|砦（雪）
Castle (Ruins, Snow)|城（廃墟・雪）
Castle (Ruins, Snow)|城（廃墟・雪）
Castle (Walled)|城（城壁）
Castle (Walled)|城（城壁）
Castle (Walled)|城（城壁）
Demon Castle|魔王城
Demon Castle|魔王城
Cursed Castle|呪われた城
Cursed Castle|呪われた城
Town C (Ruins)|町C（廃墟）
Castle (Walled)|城（城壁）
Castle (Walled)|城（城壁）
Castle (Walled)|城（城壁）
Demon Castle|魔王城
Demon Castle|魔王城
Cursed Castle|呪われた城
Cursed Castle|呪われた城
Town F (Ruins)|町F（廃墟）
Castle (Walled)|城（城壁）
Castle (Walled)|城（城壁）
Castle (Walled)|城（城壁）
Town A (Ruins)|町A（廃墟）
Town A (Ruins)|町A（廃墟）
Village A (Ruins)|村A（廃墟）
Village A (Ruins)|村A（廃墟）
House (Ruins)|家（廃墟）
Castle Wall (Ruins A)|城壁（廃墟A）
Castle Wall (Ruins B)|城壁（廃墟B）
Castle Wall (Ruins C)|城壁（廃墟C）
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall (Gate)|城壁（城門）
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Barricades|バリケード
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Castle Wall|城壁
Lookout Post|やぐら
Floating Continent (Giant Tree)|浮遊大陸（大樹）
Floating Continent (Giant Tree)|浮遊大陸（大樹）
Floating Continent|浮遊大陸
Floating Continent|浮遊大陸
Floating Continent (Cloud)|浮遊大陸（雲）
Floating Continent (Cloud)|浮遊大陸（雲）
Cloud Land|雲の大地
Cloud Land|雲の大地
Floating Continent (Castle)|浮遊大陸（城）
Floating Continent (Castle)|浮遊大陸（城）
Floating Continent|浮遊大陸
Floating Continent|浮遊大陸
Floating Continent (Cloud)|浮遊大陸（雲）
Floating Continent (Cloud)|浮遊大陸（雲）
Cloud Land|雲の大地
Cloud Land|雲の大地
Floating Continent (Temple)|浮遊大陸（神殿）
Floating Continent (Temple)|浮遊大陸（神殿）
Floating Continent (Shadow)|浮遊大陸（影）
Floating Continent (Shadow)|浮遊大陸（影）
Cloud Land (Temple)|雲の大地（神殿）
Cloud Land (Temple)|雲の大地（神殿）
Cloud Land (Castle)|雲の大地（城）
Cloud Land (Castle)|雲の大地（城）


code:
Transparent|透明
Signboard A|看板A
Signboard B|看板B
Signboard C|看板C
Iron Bridge (H)|鉄橋（横）
Iron Bridge (V)|鉄橋（縦）
Reservoir A|貯水池A
Reservoir B|貯水池B
Hut|小屋
Shanty|掘っ立て小屋
Signboard D|看板D
Stele A|石碑A
Stele B|石碑B
Windmill|風車
Parabolic Antenna|パラボラアンテナ
Heliport|ヘリポート
Entrance A (Open)|入口A（開）
Entrance A (Closed)|入口A（閉）
Entrance B (Open)|入口B（開）
Entrance B (Closed)|入口B（閉）
Entrance C (Open)|入口C（開）
Entrance C (Closed)|入口C（閉）
Entrance D (Closed)|入口D（閉）
Entrance E (Closed)|入口E（閉）
Road|道路
Road|道路
Road Closed|通行止め
Rocky Mountain|岩山
Rocky Mountain|岩山
Mountain|山
Mountain|山
Coniferous Tree A|針葉樹A
Road|道路
Road|道路
Road|道路
Rocky Mountain|岩山
Rocky Mountain|岩山
Mountain|山
Mountain|山
Coniferous Tree B|針葉樹B
Road|道路
Road|道路
Road|道路
Rocky Mountain|岩山
Rocky Mountain|岩山
Mountain|山
Mountain|山
Broadleaf Tree|広葉樹
Road|道路
Road|道路
Road|道路
Rocky Mountain|岩山
Rocky Mountain|岩山
Mountain|山
Mountain|山
Broken Buildings|壊れたビル街
Town A|町A
Town B|町B
Slum A|スラム街A
Slum B|スラム街B
Mansion A|邸宅A
Mansion A|邸宅A
Gate A|ゲートA
Gate B|ゲートB
Shopping Area A|商店街A
Shopping Area B|商店街B
Buildings A|ビル街A
Buildings B|ビル街B
Mansion B|邸宅B
Mansion B|邸宅B
Gate C|ゲートC
Gate D|ゲートD
Residential Street|住宅街
Residential Street|住宅街
Slum|スラム街
Slum|スラム街
School|学校
School|学校
Hospital|病院
Hospital|病院
Residential Street|住宅街
Residential Street|住宅街
Slum|スラム街
Slum|スラム街
School|学校
School|学校
Hospital|病院
Hospital|病院
City A|街A
City A|街A
City B|街B
City B|街B
Residence A|屋敷A
Residence A|屋敷A
Residence B|屋敷B
Residence B|屋敷B
City A|街A
City A|街A
City B|街B
City B|街B
Residence A|屋敷A
Residence A|屋敷A
Residence B|屋敷B
Residence B|屋敷B
Bridge A (V)|橋A（縦）
Bridge A (H)|橋A（横）
Broken Bridge A (V)|壊れた橋A（縦）
Broken Bridge A (H)|壊れた橋A（横）
Bridge B (V)|橋B（縦）
Bridge B (H)|橋B（横）
Broken Bridge B (V)|壊れた橋（縦）
Broken Bridge B (H)|壊れた橋（横）
Building A|ビルA
Building B|ビルB
Building C|ビルC
Building D|ビルD
Apartment|マンション
Apartment Complex|マンション群
Collapsed Building A|崩壊したビルA
Collapsed Building B|崩壊したビルB
Building A|ビルA
Building B|ビルB
Building C|ビルC
Building D|ビルD
Apartment|マンション
Apartment Complex|マンション群
Collapsed Building A|崩壊したビルA
Collapsed Building B|崩壊したビルB
Large Town A|大きな町A
Large Town A|大きな町A
Entertainment District A|歓楽街A
Entertainment District A|歓楽街A
Police Station|警察署
Police Station|警察署
Crater A|クレーターA
Crater A|クレーターA
Large Town A|大きな町A
Large Town A|大きな町A
Entertainment District A|歓楽街A
Entertainment District A|歓楽街A
Police Station|警察署
Police Station|警察署
Crater A|クレーターA
Crater A|クレーターA
Large Town B|大きな町B
Large Town B|大きな町B
Entertainment District B|歓楽街B
Entertainment District B|歓楽街B
Museum|博物館
Museum|博物館
Crater B|クレーターB
Crater B|クレーターB
Large Town B|大きな町B
Large Town B|大きな町B
Entertainment District B|歓楽街B
Entertainment District B|歓楽街B
Museum|博物館
Museum|博物館
Crater B|クレーターB
Crater B|クレーターB
Warehouse A|倉庫A
Warehouse A|倉庫A
Factory|工場
Factory|工場
Warehouse B|倉庫B
Gantry Crane|ガントリークレーン
Park|公園
Crater C|クレーターC
Warehouse A|倉庫A
Warehouse A|倉庫A
Factory|工場
Factory|工場
Warehouse B|倉庫B
Gantry Crane|ガントリークレーン
Statue A|像A
Statue B|像B
Fuel Tank|燃料タンク
Fuel Tank|燃料タンク
Construction Site|工事現場
Construction Site|工事現場
Watchtower|監視塔
Steel Tower|鉄塔
Tower A|タワーA
Tower B|タワーB
Fuel Tank|燃料タンク
Fuel Tank|燃料タンク
Construction Site|工事現場
Construction Site|工事現場
Watchtower|監視塔
Steel Tower|鉄塔
Tower A|タワーA
Tower B|タワーB
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall (Gate)|外壁（門）
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall (Gate)|外壁（門）
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Outer Wall|外壁
Theme Park|テーマパーク
Theme Park|テーマパーク
Port|港湾
Port|港湾
Military Base|軍事基地
Military Base|軍事基地
Dome|ドーム
Dome|ドーム
Theme Park|テーマパーク
Theme Park|テーマパーク
Port|港湾
Port|港湾
Military Base|軍事基地
Military Base|軍事基地
Dome|ドーム
Dome|ドーム
Lighthouse|灯台
Broken Lighthouse|壊れた灯台
Temple|寺院
Church|教会
Cemetery A|墓地A
Cemetery B|墓地B
Prison|刑務所
Prison|刑務所


code:
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var CanvasTileRenderer = (function () {
            function CanvasTileRenderer(renderer) {
                this.tileAnim = [0, 0];
                this.dontUseTransform = false;
                this.renderer = renderer;
                this.tileAnim = [0, 0];
            }
            return CanvasTileRenderer;
        }());
        tilemap.CanvasTileRenderer = CanvasTileRenderer;
        PIXI.CanvasRenderer.registerPlugin('tilemap', CanvasTileRenderer);
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var CompositeRectTileLayer = (function (_super) {
            __extends(CompositeRectTileLayer, _super);
            function CompositeRectTileLayer(zIndex, bitmaps, useSquare, texPerChild) {
                var _this = _super.call(this) || this;
                _this.shadowColor = new Float32Array([0.0, 0.0, 0.0, 0.5]);
                _this.modificationMarker = 0;
                _this._globalMat = null;
                _this._tempScale = null;
                _this.initialize.apply(_this, arguments);
                return _this;
            }
            CompositeRectTileLayer.prototype.updateTransform = function () {
                _super.prototype.displayObjectUpdateTransform.call(this);
            };
            CompositeRectTileLayer.prototype.initialize = function (zIndex, bitmaps, useSquare, texPerChild) {
                this.z = this.zIndex = zIndex;
                this.useSquare = useSquare;
                this.texPerChild = texPerChild || 16;
                if (bitmaps) {
                    this.setBitmaps(bitmaps);
                }
            };
            CompositeRectTileLayer.prototype.setBitmaps = function (bitmaps) {
                var texPerChild = this.texPerChild;
                var len1 = this.children.length;
                var len2 = Math.ceil(bitmaps.length / texPerChild);
                var i;
                for (i = 0; i < len1; i++) {
                    this.children[i].textures = bitmaps.slice(i * texPerChild, (i + 1) * texPerChild);
                }
                for (i = len1; i < len2; i++) {
                    this.addChild(new tilemap.RectTileLayer(this.zIndex, bitmaps.slice(i * texPerChild, (i + 1) * texPerChild)));
                }
            };
            CompositeRectTileLayer.prototype.clear = function () {
                for (var i = 0; i < this.children.length; i++)
                    this.children[i].clear();
                this.modificationMarker = 0;
            };
            CompositeRectTileLayer.prototype.addRect = function (num, u, v, x, y, tileWidth, tileHeight) {
                if (this.children[num] && this.children[num].textures)
                    this.children[num].addRect(0, u, v, x, y, tileWidth, tileHeight);
            };
            CompositeRectTileLayer.prototype.addFrame = function (texture_, x, y, animX, animY) {
                var texture;
                var layer = null, ind = 0;
                var children = this.children;
                if (typeof texture_ === "number") {
                    var childIndex = texture_ / this.texPerChild >> 0;
                    layer = children[childIndex];
                    if (!layer) {
                        layer = children[0];
                        if (!layer) {
                            return false;
                        }
                        ind = 0;
                    }
                    else {
                        ind = texture_ % this.texPerChild;
                    }
                    texture = layer.textures[ind];
                }
                else if (typeof texture_ === "string") {
                    texture = PIXI.Texture.fromImage(texture_);
                }
                else {
                    texture = texture_;
                    for (var i = 0; i < children.length; i++) {
                        var child = children[i];
                        var tex = child.textures;
                        for (var j = 0; j < tex.length; j++) {
                            if (tex[j].baseTexture == texture.baseTexture) {
                                layer = child;
                                ind = j;
                                break;
                            }
                        }
                        if (layer) {
                            break;
                        }
                    }
                    if (!layer) {
                        for (i = 0; i < children.length; i++) {
                            var child = children[i];
                            if (child.textures.length < this.texPerChild) {
                                layer = child;
                                ind = child.textures.length;
                                child.textures.push(texture);
                                break;
                            }
                        }
                        if (!layer) {
                            children.push(layer = new tilemap.RectTileLayer(this.zIndex, texture));
                            ind = 0;
                        }
                    }
                }
                layer.addRect(ind, texture.frame.x, texture.frame.y, x, y, texture.frame.width, texture.frame.height, animX, animY);
                return true;
            };
            ;
            CompositeRectTileLayer.prototype.renderCanvas = function (renderer) {
                if (!renderer.plugins.tilemap.dontUseTransform) {
                    var wt = this.worldTransform;
                    renderer.context.setTransform(wt.a, wt.b, wt.c, wt.d, wt.tx * renderer.resolution, wt.ty * renderer.resolution);
                }
                var layers = this.children;
                for (var i = 0; i < layers.length; i++)
                    layers[i].renderCanvas(renderer);
            };
            ;
            CompositeRectTileLayer.prototype.renderWebGL = function (renderer) {
                var gl = renderer.gl;
                var shader = renderer.plugins.tilemap.getShader(this.useSquare);
                renderer.setObjectRenderer(renderer.plugins.tilemap);
                renderer.bindShader(shader);
                this._globalMat = this._globalMat || new PIXI.Matrix();
                renderer._activeRenderTarget.projectionMatrix.copy(this._globalMat).append(this.worldTransform);
                shader.uniforms.projectionMatrix = this._globalMat.toArray(true);
                shader.uniforms.shadowColor = this.shadowColor;
                if (this.useSquare) {
                    var tempScale = this._tempScale = (this._tempScale || [0, 0]);
                    tempScale[0] = this._globalMat.a >= 0 ? 1 : -1;
                    tempScale[1] = this._globalMat.d < 0 ? 1 : -1;
                    var ps = shader.uniforms.pointScale = tempScale;
                    shader.uniforms.projectionScale = Math.abs(this.worldTransform.a) * renderer.resolution;
                }
                var af = shader.uniforms.animationFrame = renderer.plugins.tilemap.tileAnim;
                var layers = this.children;
                for (var i = 0; i < layers.length; i++)
                    layers[i].renderWebGL(renderer, this.useSquare);
            };
            CompositeRectTileLayer.prototype.isModified = function (anim) {
                var layers = this.children;
                if (this.modificationMarker != layers.length) {
                    return true;
                }
                for (var i = 0; i < layers.length; i++) {
                    var layer = layers[i];
                    if (layer.modificationMarker != layer.pointsBuf.length ||
                        anim && layer.hasAnim) {
                        return true;
                    }
                }
                return false;
            };
            CompositeRectTileLayer.prototype.clearModify = function () {
                var layers = this.children;
                this.modificationMarker = layers.length;
                for (var i = 0; i < layers.length; i++) {
                    var layer = layers[i];
                    layer.modificationMarker = layer.pointsBuf.length;
                }
            };
            return CompositeRectTileLayer;
        }(PIXI.Container));
        tilemap.CompositeRectTileLayer = CompositeRectTileLayer;
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var GraphicsLayer = (function (_super) {
            __extends(GraphicsLayer, _super);
            function GraphicsLayer(zIndex) {
                var _this = _super.call(this) || this;
                _this.z = _this.zIndex = zIndex;
                return _this;
            }
            GraphicsLayer.prototype.renderCanvas = function (renderer) {
                var wt = null;
                if (renderer.plugins.tilemap.dontUseTransform) {
                    wt = this.transform.worldTransform;
                    this.transform.worldTransform = PIXI.Matrix.IDENTITY;
                }
                renderer.plugins.graphics.render(this);
                if (renderer.plugins.tilemap.dontUseTransform) {
                    this.transform.worldTransform = wt;
                }
                renderer.context.globalAlpha = 1.0;
            };
            GraphicsLayer.prototype.renderWebGL = function (renderer) {
                if (!this._webGL[renderer.CONTEXT_UID])
                    this.dirty = true;
                _super.prototype.renderWebGL.call(this, renderer);
            };
            GraphicsLayer.prototype.isModified = function (anim) {
                return false;
            };
            GraphicsLayer.prototype.clearModify = function () {
            };
            return GraphicsLayer;
        }(PIXI.Graphics));
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var RectTileLayer = (function (_super) {
            __extends(RectTileLayer, _super);
            function RectTileLayer(zIndex, texture) {
                var _this = _super.call(this) || this;
                _this.z = 0;
                _this.zIndex = 0;
                _this.pointsBuf = [];
                _this._tempSize = new Float32Array([0, 0]);
                _this._tempTexSize = 1;
                _this.modificationMarker = 0;
                _this.hasAnim = false;
                _this.vbId = 0;
                _this.vbBuffer = null;
                _this.vbArray = null;
                _this.vbInts = null;
                _this.initialize(zIndex, texture);
                return _this;
            }
            RectTileLayer.prototype.initialize = function (zIndex, textures) {
                if (!textures) {
                    textures = [];
                }
                else if (!(textures instanceof Array) && textures.baseTexture) {
                    textures = [textures];
                }
                this.textures = textures;
                this.z = this.zIndex = zIndex;
                this.visible = false;
            };
            RectTileLayer.prototype.clear = function () {
                this.pointsBuf.length = 0;
                this.modificationMarker = 0;
                this.hasAnim = false;
            };
            RectTileLayer.prototype.renderCanvas = function (renderer) {
                if (this.textures.length === 0)
                    return;
                var points = this.pointsBuf;
                renderer.context.fillStyle = '#000000';
                for (var i = 0, n = points.length; i < n; i += 9) {
                    var x1 = points[i], y1 = points[i + 1];
                    var x2 = points[i + 2], y2 = points[i + 3];
                    var w = points[i + 4];
                    var h = points[i + 5];
                    x1 += points[i + 6] * renderer.plugins.tilemap.tileAnim[0];
                    y1 += points[i + 7] * renderer.plugins.tilemap.tileAnim[1];
                    var textureId = points[i + 8];
                    if (textureId >= 0) {
                        renderer.context.drawImage(this.textures[textureId].baseTexture.source, x1, y1, w, h, x2, y2, w, h);
                    }
                    else {
                        renderer.context.globalAlpha = 0.5;
                        renderer.context.fillRect(x2, y2, w, h);
                        renderer.context.globalAlpha = 1;
                    }
                }
            };
            RectTileLayer.prototype.addRect = function (textureId, u, v, x, y, tileWidth, tileHeight, animX, animY) {
                if (animX === void 0) { animX = 0; }
                if (animY === void 0) { animY = 0; }
                var pb = this.pointsBuf;
                this.hasAnim = this.hasAnim || animX > 0 || animY > 0;
                if (tileWidth == tileHeight) {
                    pb.push(u);
                    pb.push(v);
                    pb.push(x);
                    pb.push(y);
                    pb.push(tileWidth);
                    pb.push(tileHeight);
                    pb.push(animX | 0);
                    pb.push(animY | 0);
                    pb.push(textureId);
                }
                else {
                    var i;
                    if (tileWidth % tileHeight === 0) {
                        for (i = 0; i < tileWidth / tileHeight; i++) {
                            pb.push(u + i * tileHeight);
                            pb.push(v);
                            pb.push(x + i * tileHeight);
                            pb.push(y);
                            pb.push(tileHeight);
                            pb.push(tileHeight);
                            pb.push(animX | 0);
                            pb.push(animY | 0);
                            pb.push(textureId);
                        }
                    }
                    else if (tileHeight % tileWidth === 0) {
                        for (i = 0; i < tileHeight / tileWidth; i++) {
                            pb.push(u);
                            pb.push(v + i * tileWidth);
                            pb.push(x);
                            pb.push(y + i * tileWidth);
                            pb.push(tileWidth);
                            pb.push(tileWidth);
                            pb.push(animX | 0);
                            pb.push(animY | 0);
                            pb.push(textureId);
                        }
                    }
                    else {
                        pb.push(u);
                        pb.push(v);
                        pb.push(x);
                        pb.push(y);
                        pb.push(tileWidth);
                        pb.push(tileHeight);
                        pb.push(animX | 0);
                        pb.push(animY | 0);
                        pb.push(textureId);
                    }
                }
            };
            ;
            RectTileLayer.prototype.renderWebGL = function (renderer, useSquare) {
                if (useSquare === void 0) { useSquare = false; }
                var points = this.pointsBuf;
                if (points.length === 0)
                    return;
                var rectsCount = points.length / 9;
                var tile = renderer.plugins.tilemap;
                var gl = renderer.gl;
                if (!useSquare) {
                    tile.checkIndexBuffer(rectsCount);
                }
                var shader = tile.getShader(useSquare);
                var textures = this.textures;
                if (textures.length === 0)
                    return;
                var len = textures.length;
                if (this._tempTexSize < shader.maxTextures) {
                    this._tempTexSize = shader.maxTextures;
                    this._tempSize = new Float32Array(2 * shader.maxTextures);
                }
                for (var i = 0; i < len; i++) {
                    if (!textures[i] || !textures[i].valid)
                        return;
                    var texture = textures[i].baseTexture;
                }
                tile.bindTextures(renderer, shader, textures);
                var vb = tile.getVb(this.vbId);
                if (!vb) {
                    vb = tile.createVb(useSquare);
                    this.vbId = vb.id;
                    this.vbBuffer = null;
                    this.modificationMarker = 0;
                }
                var vao = vb.vao;
                renderer.bindVao(vao);
                var vertexBuf = vb.vb;
                vertexBuf.bind();
                var vertices = rectsCount * shader.vertPerQuad;
                if (vertices === 0)
                    return;
                if (this.modificationMarker != vertices) {
                    this.modificationMarker = vertices;
                    var vs = shader.stride * vertices;
                    if (!this.vbBuffer || this.vbBuffer.byteLength < vs) {
                        var bk = shader.stride;
                        while (bk < vs) {
                            bk *= 2;
                        }
                        this.vbBuffer = new ArrayBuffer(bk);
                        this.vbArray = new Float32Array(this.vbBuffer);
                        this.vbInts = new Uint32Array(this.vbBuffer);
                        vertexBuf.upload(this.vbBuffer, 0, true);
                    }
                    var arr = this.vbArray, ints = this.vbInts;
                    var sz = 0;
                    var textureId, shiftU, shiftV;
                    if (useSquare) {
                        for (i = 0; i < points.length; i += 9) {
                            textureId = (points[i + 8] >> 2);
                            shiftU = 1024 * (points[i + 8] & 1);
                            shiftV = 1024 * ((points[i + 8] >> 1) & 1);
                            arr[sz++] = points[i + 2];
                            arr[sz++] = points[i + 3];
                            arr[sz++] = points[i + 0] + shiftU;
                            arr[sz++] = points[i + 1] + shiftV;
                            arr[sz++] = points[i + 4];
                            arr[sz++] = points[i + 6];
                            arr[sz++] = points[i + 7];
                            arr[sz++] = textureId;
                        }
                    }
                    else {
                        var tint = -1;
                        for (i = 0; i < points.length; i += 9) {
                            var eps = 0.5;
                            textureId = (points[i + 8] >> 2);
                            shiftU = 1024 * (points[i + 8] & 1);
                            shiftV = 1024 * ((points[i + 8] >> 1) & 1);
                            var x = points[i + 2], y = points[i + 3];
                            var w = points[i + 4], h = points[i + 5];
                            var u = points[i] + shiftU, v = points[i + 1] + shiftV;
                            var animX = points[i + 6], animY = points[i + 7];
                            arr[sz++] = x;
                            arr[sz++] = y;
                            arr[sz++] = u;
                            arr[sz++] = v;
                            arr[sz++] = u + eps;
                            arr[sz++] = v + eps;
                            arr[sz++] = u + w - eps;
                            arr[sz++] = v + h - eps;
                            arr[sz++] = animX;
                            arr[sz++] = animY;
                            arr[sz++] = textureId;
                            arr[sz++] = x + w;
                            arr[sz++] = y;
                            arr[sz++] = u + w;
                            arr[sz++] = v;
                            arr[sz++] = u + eps;
                            arr[sz++] = v + eps;
                            arr[sz++] = u + w - eps;
                            arr[sz++] = v + h - eps;
                            arr[sz++] = animX;
                            arr[sz++] = animY;
                            arr[sz++] = textureId;
                            arr[sz++] = x + w;
                            arr[sz++] = y + h;
                            arr[sz++] = u + w;
                            arr[sz++] = v + h;
                            arr[sz++] = u + eps;
                            arr[sz++] = v + eps;
                            arr[sz++] = u + w - eps;
                            arr[sz++] = v + h - eps;
                            arr[sz++] = animX;
                            arr[sz++] = animY;
                            arr[sz++] = textureId;
                            arr[sz++] = x;
                            arr[sz++] = y + h;
                            arr[sz++] = u;
                            arr[sz++] = v + h;
                            arr[sz++] = u + eps;
                            arr[sz++] = v + eps;
                            arr[sz++] = u + w - eps;
                            arr[sz++] = v + h - eps;
                            arr[sz++] = animX;
                            arr[sz++] = animY;
                            arr[sz++] = textureId;
                        }
                    }
                    vertexBuf.upload(arr, 0, true);
                }
                if (useSquare)
                    gl.drawArrays(gl.POINTS, 0, vertices);
                else
                    gl.drawElements(gl.TRIANGLES, rectsCount * 6, gl.UNSIGNED_SHORT, 0);
            };
            return RectTileLayer;
        }(PIXI.Container));
        tilemap.RectTileLayer = RectTileLayer;
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var rectShaderFrag = "varying vec2 vTextureCoord;\nvarying vec4 vFrame;\nvarying float vTextureId;\nuniform vec4 shadowColor;\nuniform sampler2D uSamplers[%count%];\nuniform vec2 uSamplerSize[%count%];\n\nvoid main(void){\n   vec2 textureCoord = clamp(vTextureCoord, vFrame.xy, vFrame.zw);\n   float textureId = floor(vTextureId + 0.5);\n\n   vec4 color;\n   %forloop%\n   gl_FragColor = color;\n}";
        var rectShaderVert = "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aFrame;\nattribute vec2 aAnim;\nattribute float aTextureId;\n\nuniform mat3 projectionMatrix;\nuniform vec2 animationFrame;\n\nvarying vec2 vTextureCoord;\nvarying float vTextureId;\nvarying vec4 vFrame;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n   vec2 anim = aAnim * animationFrame;\n   vTextureCoord = aTextureCoord + anim;\n   vFrame = aFrame + vec4(anim, anim);\n   vTextureId = aTextureId;\n}\n";
        var TilemapShader = (function (_super) {
            __extends(TilemapShader, _super);
            function TilemapShader(gl, maxTextures, shaderVert, shaderFrag) {
                var _this = _super.call(this, gl, shaderVert, shaderFrag) || this;
                _this.maxTextures = 0;
                _this.maxTextures = maxTextures;
                tilemap.shaderGenerator.fillSamplers(_this, _this.maxTextures);
                return _this;
            }
            return TilemapShader;
        }(PIXI.Shader));
        tilemap.TilemapShader = TilemapShader;
        var RectTileShader = (function (_super) {
            __extends(RectTileShader, _super);
            function RectTileShader(gl, maxTextures) {
                var _this = _super.call(this, gl, maxTextures, rectShaderVert, tilemap.shaderGenerator.generateFragmentSrc(maxTextures, rectShaderFrag)) || this;
                _this.vertSize = 11;
                _this.vertPerQuad = 4;
                _this.stride = _this.vertSize * 4;
                tilemap.shaderGenerator.fillSamplers(_this, _this.maxTextures);
                return _this;
            }
            RectTileShader.prototype.createVao = function (renderer, vb) {
                var gl = renderer.gl;
                return renderer.createVao()
                    .addIndex(this.indexBuffer)
                    .addAttribute(vb, this.attributes.aVertexPosition, gl.FLOAT, false, this.stride, 0)
                    .addAttribute(vb, this.attributes.aTextureCoord, gl.FLOAT, false, this.stride, 2 * 4)
                    .addAttribute(vb, this.attributes.aFrame, gl.FLOAT, false, this.stride, 4 * 4)
                    .addAttribute(vb, this.attributes.aAnim, gl.FLOAT, false, this.stride, 8 * 4)
                    .addAttribute(vb, this.attributes.aTextureId, gl.FLOAT, false, this.stride, 10 * 4);
            };
            return RectTileShader;
        }(TilemapShader));
        tilemap.RectTileShader = RectTileShader;
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var shaderGenerator;
        (function (shaderGenerator) {
            function fillSamplers(shader, maxTextures) {
                var sampleValues = [];
                for (var i = 0; i < maxTextures; i++) {
                    sampleValues[i] = i;
                }
                shader.bind();
                shader.uniforms.uSamplers = sampleValues;
                var samplerSize = [];
                for (i = 0; i < maxTextures; i++) {
                    samplerSize.push(1.0 / 2048);
                    samplerSize.push(1.0 / 2048);
                }
                shader.uniforms.uSamplerSize = samplerSize;
            }
            shaderGenerator.fillSamplers = fillSamplers;
            function generateFragmentSrc(maxTextures, fragmentSrc) {
                return fragmentSrc.replace(/%count%/gi, maxTextures + "")
                    .replace(/%forloop%/gi, this.generateSampleSrc(maxTextures));
            }
            shaderGenerator.generateFragmentSrc = generateFragmentSrc;
            function generateSampleSrc(maxTextures) {
                var src = '';
                src += '\n';
                src += '\n';
                src += 'if(vTextureId <= -1.0) {';
                src += '\n\tcolor = shadowColor;';
                src += '\n}';
                for (var i = 0; i < maxTextures; i++) {
                    src += '\nelse ';
                    if (i < maxTextures - 1) {
                        src += 'if(textureId == ' + i + '.0)';
                    }
                    src += '\n{';
                    src += '\n\tcolor = texture2D(uSamplers[' + i + '], textureCoord * uSamplerSize[' + i + ']);';
                    src += '\n}';
                }
                src += '\n';
                src += '\n';
                return src;
            }
            shaderGenerator.generateSampleSrc = generateSampleSrc;
        })(shaderGenerator = tilemap.shaderGenerator || (tilemap.shaderGenerator = {}));
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var squareShaderVert = "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aAnim;\nattribute float aTextureId;\nattribute float aSize;\n\nuniform mat3 projectionMatrix;\nuniform vec2 samplerSize;\nuniform vec2 animationFrame;\nuniform float projectionScale;\n\nvarying vec2 vTextureCoord;\nvarying float vSize;\nvarying float vTextureId;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition + aSize * 0.5, 1.0)).xy, 0.0, 1.0);\n   gl_PointSize = aSize * projectionScale;\n   vTextureCoord = aTextureCoord + aAnim * animationFrame;\n   vTextureId = aTextureId;\n   vSize = aSize;\n}\n";
        var squareShaderFrag = "\nvarying vec2 vTextureCoord;\nvarying float vSize;\nvarying float vTextureId;\n\nuniform vec4 shadowColor;\nuniform sampler2D uSamplers[%count%];\nuniform vec2 uSamplerSize[%count%];\nuniform vec2 pointScale;\n\nvoid main(void){\n   float margin = 0.5 / vSize;\n   vec2 pointCoord = (gl_PointCoord - 0.5) * pointScale + 0.5;\n   vec2 clamped = vec2(clamp(pointCoord.x, margin, 1.0 - margin), clamp(pointCoord.y, margin, 1.0 - margin));\n   vec2 textureCoord = pointCoord * vSize + vTextureCoord;\n   float textureId = vTextureId;\n   vec4 color;\n   %forloop%\n   gl_FragColor = color;\n}\n\n";
        var SquareTileShader = (function (_super) {
            __extends(SquareTileShader, _super);
            function SquareTileShader(gl, maxTextures) {
                var _this = _super.call(this, gl, maxTextures, squareShaderVert, tilemap.shaderGenerator.generateFragmentSrc(maxTextures, squareShaderFrag)) || this;
                _this.vertSize = 8;
                _this.vertPerQuad = 1;
                _this.stride = _this.vertSize * 4;
                _this.maxTextures = maxTextures;
                tilemap.shaderGenerator.fillSamplers(_this, _this.maxTextures);
                return _this;
            }
            SquareTileShader.prototype.createVao = function (renderer, vb) {
                var gl = renderer.gl;
                return renderer.createVao()
                    .addIndex(this.indexBuffer)
                    .addAttribute(vb, this.attributes.aVertexPosition, gl.FLOAT, false, this.stride, 0)
                    .addAttribute(vb, this.attributes.aTextureCoord, gl.FLOAT, false, this.stride, 2 * 4)
                    .addAttribute(vb, this.attributes.aSize, gl.FLOAT, false, this.stride, 4 * 4)
                    .addAttribute(vb, this.attributes.aAnim, gl.FLOAT, false, this.stride, 5 * 4)
                    .addAttribute(vb, this.attributes.aTextureId, gl.FLOAT, false, this.stride, 7 * 4);
            };
            ;
            return SquareTileShader;
        }(tilemap.TilemapShader));
        tilemap.SquareTileShader = SquareTileShader;
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap) {
        var glCore = PIXI.glCore;
        function _hackSubImage(tex, sprite, clearBuffer, clearWidth, clearHeight) {
            var gl = tex.gl;
            var baseTex = sprite.texture.baseTexture;
            if (clearBuffer && clearWidth > 0 && clearHeight > 0) {
                gl.texSubImage2D(gl.TEXTURE_2D, 0, sprite.position.x, sprite.position.y, clearWidth, clearHeight, tex.format, tex.type, clearBuffer);
            }
            gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 1);
            gl.texSubImage2D(gl.TEXTURE_2D, 0, sprite.position.x, sprite.position.y, tex.format, tex.type, baseTex.source);
        }
        var TileRenderer = (function (_super) {
            __extends(TileRenderer, _super);
            function TileRenderer(renderer) {
                var _this = _super.call(this, renderer) || this;
                _this.vbs = {};
                _this.indices = new Uint16Array(0);
                _this.lastTimeCheck = 0;
                _this.tileAnim = [0, 0];
                _this.maxTextures = 4;
                _this.texLoc = [];
                return _this;
            }
            TileRenderer.prototype.onContextChange = function () {
                var gl = this.renderer.gl;
                var maxTextures = this.maxTextures;
                this.rectShader = new tilemap.RectTileShader(gl, maxTextures);
                this.squareShader = new tilemap.SquareTileShader(gl, maxTextures);
                this.checkIndexBuffer(2000);
                this.rectShader.indexBuffer = this.indexBuffer;
                this.squareShader.indexBuffer = this.indexBuffer;
                this.vbs = {};
                this.glTextures = [];
                this.boundSprites = [];
                this.initBounds();
            };
            TileRenderer.prototype.initBounds = function () {
                var gl = this.renderer.gl;
                var tempCanvas = document.createElement('canvas');
                tempCanvas.width = 2048;
                tempCanvas.height = 2048;
                for (var i = 0; i < this.maxTextures; i++) {
                    var rt = PIXI.RenderTexture.create(2048, 2048);
                    rt.baseTexture.premultipliedAlpha = true;
                    rt.baseTexture.scaleMode = TileRenderer.SCALE_MODE;
                    rt.baseTexture.wrapMode = PIXI.WRAP_MODES.CLAMP;
                    this.renderer.textureManager.updateTexture(rt);
                    this.glTextures.push(rt);
                    var bs = [];
                    for (var j = 0; j < 4; j++) {
                        var spr = new PIXI.Sprite();
                        spr.position.x = 1024 * (j & 1);
                        spr.position.y = 1024 * (j >> 1);
                        bs.push(spr);
                    }
                    this.boundSprites.push(bs);
                }
            };
            TileRenderer.prototype.bindTextures = function (renderer, shader, textures) {
                var bounds = this.boundSprites;
                var glts = this.glTextures;
                var len = textures.length;
                var maxTextures = this.maxTextures;
                if (len > 4 * maxTextures) {
                    return;
                }
                var doClear = TileRenderer.DO_CLEAR;
                if (doClear && !this._clearBuffer) {
                    this._clearBuffer = new Uint8Array(1024 * 1024 * 4);
                }
                var i;
                for (i = 0; i < len; i++) {
                    var texture = textures[i];
                    if (!texture || !textures[i].valid)
                        continue;
                    var bs = bounds[i >> 2][i & 3];
                    if (!bs.texture ||
                        bs.texture.baseTexture !== texture.baseTexture) {
                        bs.texture = texture;
                        var glt = glts[i >> 2];
                        renderer.bindTexture(glt, 0, true);
                        if (doClear) {
                            _hackSubImage(glt.baseTexture._glTextures[renderer.CONTEXT_UID], bs, this._clearBuffer, 1024, 1024);
                        }
                        else {
                            _hackSubImage(glt.baseTexture._glTextures[renderer.CONTEXT_UID], bs);
                        }
                    }
                }
                this.texLoc.length = 0;
                for (i = 0; i < maxTextures; i++) {
                    this.texLoc.push(renderer.bindTexture(glts[i], i, true));
                }
                shader.uniforms.uSamplers = this.texLoc;
            };
            TileRenderer.prototype.checkLeaks = function () {
                var now = Date.now();
                var old = now - 10000;
                if (this.lastTimeCheck < old ||
                    this.lastTimeCheck > now) {
                    this.lastTimeCheck = now;
                    var vbs = this.vbs;
                    for (var key in vbs) {
                        if (vbs[key].lastTimeAccess < old) {
                            this.removeVb(key);
                        }
                    }
                }
            };
            ;
            TileRenderer.prototype.start = function () {
                this.renderer.state.setBlendMode(PIXI.BLEND_MODES.NORMAL);
            };
            TileRenderer.prototype.getVb = function (id) {
                this.checkLeaks();
                var vb = this.vbs[id];
                if (vb) {
                    vb.lastAccessTime = Date.now();
                    return vb;
                }
                return null;
            };
            TileRenderer.prototype.createVb = function (useSquare) {
                var id = ++TileRenderer.vbAutoincrement;
                var shader = this.getShader(useSquare);
                var gl = this.renderer.gl;
                var vb = PIXI.glCore.GLBuffer.createVertexBuffer(gl, null, gl.STREAM_DRAW);
                var stuff = {
                    id: id,
                    vb: vb,
                    vao: shader.createVao(this.renderer, vb),
                    lastTimeAccess: Date.now(),
                    useSquare: useSquare,
                    shader: shader
                };
                this.vbs[id] = stuff;
                return stuff;
            };
            TileRenderer.prototype.removeVb = function (id) {
                if (this.vbs[id]) {
                    this.vbs[id].vb.destroy();
                    this.vbs[id].vao.destroy();
                    delete this.vbs[id];
                }
            };
            TileRenderer.prototype.checkIndexBuffer = function (size) {
                var totalIndices = size * 6;
                var indices = this.indices;
                if (totalIndices <= indices.length) {
                    return;
                }
                var len = indices.length || totalIndices;
                while (len < totalIndices) {
                    len <<= 1;
                }
                indices = new Uint16Array(len);
                this.indices = indices;
                for (var i = 0, j = 0; i + 5 < indices.length; i += 6, j += 4) {
                    indices[i + 0] = j + 0;
                    indices[i + 1] = j + 1;
                    indices[i + 2] = j + 2;
                    indices[i + 3] = j + 0;
                    indices[i + 4] = j + 2;
                    indices[i + 5] = j + 3;
                }
                if (this.indexBuffer) {
                    this.indexBuffer.upload(indices);
                }
                else {
                    var gl = this.renderer.gl;
                    this.indexBuffer = glCore.GLBuffer.createIndexBuffer(gl, this.indices, gl.STATIC_DRAW);
                }
            };
            TileRenderer.prototype.getShader = function (useSquare) {
                return useSquare ? this.squareShader : this.rectShader;
            };
            TileRenderer.prototype.destroy = function () {
                _super.prototype.destroy.call(this);
                this.rectShader.destroy();
                this.squareShader.destroy();
                this.rectShader = null;
                this.squareShader = null;
            };
            ;
            return TileRenderer;
        }(PIXI.ObjectRenderer));
        TileRenderer.vbAutoincrement = 0;
        TileRenderer.SCALE_MODE = PIXI.SCALE_MODES.LINEAR;
        TileRenderer.DO_CLEAR = false;
        tilemap.TileRenderer = TileRenderer;
        PIXI.WebGLRenderer.registerPlugin('tilemap', TileRenderer);
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
    var tilemap;
    (function (tilemap_1) {
        var ZLayer = (function (_super) {
            __extends(ZLayer, _super);
            function ZLayer(tilemap, zIndex) {
                var _this = _super.call(this) || this;
                _this._lastAnimationFrame = -1;
                _this.tilemap = tilemap;
                _this.z = zIndex;
                return _this;
            }
            ZLayer.prototype.clear = function () {
                var layers = this.children;
                for (var i = 0; i < layers.length; i++)
                    layers[i].clear();
                this._previousLayers = 0;
            };
            ZLayer.prototype.cacheIfDirty = function () {
                var tilemap = this.tilemap;
                var layers = this.children;
                var modified = this._previousLayers != layers.length;
                this._previousLayers = layers.length;
                var buf = this.canvasBuffer;
                var tempRender = this._tempRender;
                if (!buf) {
                    buf = this.canvasBuffer = document.createElement('canvas');
                    tempRender = this._tempRender = new PIXI.CanvasRenderer(100, 100, { view: buf });
                    tempRender.context = tempRender.rootContext;
                    tempRender.plugins.tilemap.dontUseTransform = true;
                }
                if (buf.width != tilemap._layerWidth ||
                    buf.height != tilemap._layerHeight) {
                    buf.width = tilemap._layerWidth;
                    buf.height = tilemap._layerHeight;
                    modified = true;
                }
                var i;
                if (!modified) {
                    for (i = 0; i < layers.length; i++) {
                        if (layers[i].isModified(this._lastAnimationFrame != tilemap.animationFrame)) {
                            modified = true;
                            break;
                        }
                    }
                }
                this._lastAnimationFrame = tilemap.animationFrame;
                if (modified) {
                    if (tilemap._hackRenderer) {
                        tilemap._hackRenderer(tempRender);
                    }
                    tempRender.context.clearRect(0, 0, buf.width, buf.height);
                    for (i = 0; i < layers.length; i++) {
                        layers[i].clearModify();
                        layers[i].renderCanvas(tempRender);
                    }
                }
                this.layerTransform = this.worldTransform;
                for (i = 0; i < layers.length; i++) {
                    this.layerTransform = layers[i].worldTransform;
                    break;
                }
            };
            ;
            ZLayer.prototype.renderCanvas = function (renderer) {
                this.cacheIfDirty();
                var wt = this.layerTransform;
                renderer.context.setTransform(wt.a, wt.b, wt.c, wt.d, wt.tx * renderer.resolution, wt.ty * renderer.resolution);
                var tilemap = this.tilemap;
                renderer.context.drawImage(this.canvasBuffer, 0, 0);
            };
            ;
            return ZLayer;
        }(PIXI.Container));
        tilemap_1.ZLayer = ZLayer;
    })(tilemap = PIXI.tilemap || (PIXI.tilemap = {}));
})(PIXI || (PIXI = {}));
//# sourceMappingURL=pixi-tilemap.js.map


code:
//=============================================================================
// AddStateBeforeBattle.js
//=============================================================================

/*:
 * @plugindesc 戦闘開始時にステートを付与するプラグイン
 * @author さすらいのトム
 *
 * @help
 * 特徴を有するメモ欄に以下の通りメモすれば
 * 戦闘開始時にそのステートが付与されます
 *　<addStateBeforeBattle:ステートID>
 *
 *  利用規約
 *  クレジットの表記等は特に必要ありません
 *  ただししていただけると作者が悦びます
 *  二次配布や無断転載等につきましても特に規制は設けません
 *  また、このプラグインを導入し発生したいかなる問題につきましては
 *  当方では責任を負いかねます。
 *
 */
(function(){
    'use strict';

    var _BattleManager_setup = BattleManager.setup;
    BattleManager.setup      = function(troopId, canEscape, canLose) {
        _BattleManager_setup.call(this, troopId, canEscape, canLose);
        this.allBattleMembers().forEach(function(member) {
            member.addStateBeforeBattle(member._actorId);
        });
    };

	//Game_BattlerBase
	Game_Battler.prototype.addStateBeforeBattle = function(id) {
		this.traitObjects().forEach(function(traitObject) {
			if(traitObject.meta['addStateBeforeBattle']){
                var stateId = Number(traitObject.meta['addStateBeforeBattle']);
                $gameActors.actor(id).addState(stateId);
			}
		});
    };
}());


code:
//=============================================================================
// AltMenuScreen.js
//=============================================================================

/*:
 * @plugindesc Alternative menu screen layout.
 * @author Yoji Ojima
 *
 * @help This plugin does not provide plugin commands.
 */

/*:ja
 * @plugindesc メニュー画面のレイアウトを変更します。
 * @author Yoji Ojima
 *
 * @help このプラグインには、プラグインコマンドはありません。
 */

(function() {

    var _Scene_Menu_create = Scene_Menu.prototype.create;
    Scene_Menu.prototype.create = function() {
        _Scene_Menu_create.call(this);
        this._statusWindow.x = 0;
        this._statusWindow.y = this._commandWindow.height;
        this._goldWindow.x = Graphics.boxWidth - this._goldWindow.width;
    };

    Window_MenuCommand.prototype.windowWidth = function() {
        return Graphics.boxWidth;
    };

    Window_MenuCommand.prototype.maxCols = function() {
        return 4;
    };

    Window_MenuCommand.prototype.numVisibleRows = function() {
        return 2;
    };

    Window_MenuStatus.prototype.windowWidth = function() {
        return Graphics.boxWidth;
    };

    Window_MenuStatus.prototype.windowHeight = function() {
        var h1 = this.fittingHeight(1);
        var h2 = this.fittingHeight(2);
        return Graphics.boxHeight - h1 - h2;
    };

    Window_MenuStatus.prototype.maxCols = function() {
        return 4;
    };

    Window_MenuStatus.prototype.numVisibleRows = function() {
        return 1;
    };

    Window_MenuStatus.prototype.drawItemImage = function(index) {
        var actor = $gameParty.members()[index];
        var rect = this.itemRectForText(index);
        var w = Math.min(rect.width, 144);
        var h = Math.min(rect.height, 144);
        var lineHeight = this.lineHeight();
        this.changePaintOpacity(actor.isBattleMember());
        this.drawActorFace(actor, rect.x, rect.y + lineHeight * 2.5, w, h);
        this.changePaintOpacity(true);
    };

    Window_MenuStatus.prototype.drawItemStatus = function(index) {
        var actor = $gameParty.members()[index];
        var rect = this.itemRectForText(index);
        var x = rect.x;
        var y = rect.y;
        var width = rect.width;
        var bottom = y + rect.height;
        var lineHeight = this.lineHeight();
        this.drawActorName(actor, x, y + lineHeight * 0, width);
        this.drawActorLevel(actor, x, y + lineHeight * 1, width);
        this.drawActorClass(actor, x, bottom - lineHeight * 4, width);
        this.drawActorHp(actor, x, bottom - lineHeight * 3, width);
        this.drawActorMp(actor, x, bottom - lineHeight * 2, width);
        this.drawActorIcons(actor, x, bottom - lineHeight * 1, width);
    };

    var _Window_MenuActor_initialize = Window_MenuActor.prototype.initialize;
    Window_MenuActor.prototype.initialize = function() {
        _Window_MenuActor_initialize.call(this);
        this.y = this.fittingHeight(2);
    };

})();


code:
//=============================================================================
// AltSaveScreen.js
//=============================================================================

/*:
 * @plugindesc Alternative save/load screen layout.
 * @author Yoji Ojima
 *
 * @help This plugin does not provide plugin commands.
 */

/*:ja
 * @plugindesc セーブ／ロード画面のレイアウトを変更します。
 * @author Yoji Ojima
 *
 * @help このプラグインには、プラグインコマンドはありません。
 */

(function() {

    var _Scene_File_create = Scene_File.prototype.create;
    Scene_File.prototype.create = function() {
        _Scene_File_create.call(this);
        this._listWindow.height = this._listWindow.fittingHeight(8);
        var x = 0;
        var y = this._listWindow.y + this._listWindow.height;
        var width = Graphics.boxWidth;
        var height = Graphics.boxHeight - y;
        this._statusWindow = new Window_SavefileStatus(x, y, width, height);
        this._statusWindow.setMode(this.mode());
        this._listWindow.statusWindow = this._statusWindow;
        this._listWindow.callUpdateHelp();
        this.addWindow(this._statusWindow);
    };

    var _Scene_File_start = Scene_File.prototype.start;
    Scene_File.prototype.start = function() {
        _Scene_File_start.call(this);
        this._listWindow.ensureCursorVisible();
        this._listWindow.callUpdateHelp();
    };

    Window_SavefileList.prototype.windowWidth = function() {
        return Graphics.boxWidth;
    };

    Window_SavefileList.prototype.maxCols = function() {
        return 4;
    };

    Window_SavefileList.prototype.numVisibleRows = function() {
        return 5;
    };

    Window_SavefileList.prototype.spacing = function() {
        return 8;
    };

    Window_SavefileList.prototype.itemHeight = function() {
        return this.lineHeight() * 2;
    };

    var _Window_SavefileList_callUpdateHelp =
            Window_SavefileList.prototype.callUpdateHelp;
    Window_SavefileList.prototype.callUpdateHelp = function() {
        _Window_SavefileList_callUpdateHelp.call(this);
        if (this.active && this.statusWindow) {
            this.statusWindow.setId(this.index() + 1);
        }
    };

    function Window_SavefileStatus() {
        this.initialize.apply(this, arguments);
    }

    Window_SavefileStatus.prototype = Object.create(Window_Base.prototype);
    Window_SavefileStatus.prototype.constructor = Window_SavefileStatus;

    Window_SavefileStatus.prototype.initialize = function(x, y, width, height) {
        Window_Base.prototype.initialize.call(this, x, y, width, height);
        this._id = 1;
    };

    Window_SavefileStatus.prototype.setMode = function(mode) {
        this._mode = mode;
    };

    Window_SavefileStatus.prototype.setId = function(id) {
        this._id = id;
        this.refresh();
    };

    Window_SavefileStatus.prototype.refresh = function() {
        this.contents.clear();
        var id = this._id;
        var valid = DataManager.isThisGameFile(id);
        var info = DataManager.loadSavefileInfo(id);
        var rect = this.contents.rect;
        this.resetTextColor();
        if (this._mode === 'load') {
            this.changePaintOpacity(valid);
        }
        this.drawFileId(id, rect.x, rect.y);
        if (info) {
            this.changePaintOpacity(valid);
            this.drawContents(info, rect, valid);
            this.changePaintOpacity(true);
        }
    };

    Window_SavefileStatus.prototype.drawFileId = function(id, x, y) {
        this.drawText(TextManager.file + ' ' + id, x, y, 180);
    };

    Window_SavefileStatus.prototype.drawContents = function(info, rect, valid) {
        var bottom = rect.y + rect.height;
        var playtimeY = bottom - this.lineHeight();
        this.drawText(info.title, rect.x + 192, rect.y, rect.width - 192);
        if (valid) {
            this.drawPartyfaces(info, rect.x, bottom - 144);
        }
        this.drawText(info.playtime, rect.x, playtimeY, rect.width, 'right');
    };

    Window_SavefileStatus.prototype.drawPartyfaces = function(info, x, y) {
        if (info && info.faces) {
            for (var i = 0; i < info.faces.length; i++) {
                var data = info.faces[i];
                this.drawFace(data[0], data[1], x + i * 150, y);
            }
        }
    };

})();


code:
//=============================================================================
// AltWindowFramejs
//=============================================================================

/*:
 * @plugindesc Alternative Windowflame.
 * @author KADOKAWA
 *
 * @help This plugin does not provide plugin commands.
 * @requiredAssets img/system/Window_Talk
 * @requiredAssets img/system/Window_Battle
 * @requiredAssets img/system/Window_Status
 * @requiredAssets img/system/Window_Other
 */

/*:ja
 * @plugindesc ウィンドウのフレームを変更します。
 * @author KADOKAWA
 *
 * @help このプラグインには、プラグインコマンドはありません。
 * @requiredAssets img/system/Window_Talk
 * @requiredAssets img/system/Window_Battle
 * @requiredAssets img/system/Window_Status
 * @requiredAssets img/system/Window_Other
 */

 (function() {

    Window_Base.prototype.loadWindowskin = function() {
        this.windowskin = ImageManager.loadSystem('Window_Talk');
        this.windowskin = ImageManager.loadSystem('Window_Battle');
        this.windowskin = ImageManager.loadSystem('Window_Status');
        this.windowskin = ImageManager.loadSystem('Window_Other');
        this.windowskin = ImageManager.loadSystem('Window');
    };

    var _Scene_Title_Create = Scene_Title.prototype.create;
    Scene_Title.prototype.create = function() {
        _Scene_Title_Create.call(this);
        this._commandWindow._windowskin = ImageManager.loadSystem('Window_Other');
        this._commandWindow._refreshAllParts();
    };

    var _Scene_Menu_Create = Scene_Menu.prototype.create;
    Scene_Menu.prototype.create = function() {
        _Scene_Menu_Create.call(this);
        var _image = ImageManager.loadSystem('Window_Status');
        this._statusWindow._windowskin = _image;
        this._commandWindow._windowskin = _image;
        this._goldWindow._windowskin = _image;

        this._statusWindow._refreshAllParts();
        this._commandWindow._refreshAllParts();
        this._goldWindow._refreshAllParts();
    };

    var _Scene_Item_Create = Scene_Item.prototype.create;
    Scene_Item.prototype.create = function() {
        _Scene_Item_Create.call(this);
        var _image = ImageManager.loadSystem('Window_Status');
        this._categoryWindow._windowskin = _image;
        this._itemWindow._windowskin = _image;
        this._helpWindow._windowskin = _image;
        this._actorWindow._windowskin = _image;

        this._categoryWindow._refreshAllParts();
        this._itemWindow._refreshAllParts();
        this._helpWindow._refreshAllParts();
        this._actorWindow._refreshAllParts();
    }

    var _Scene_Skill_Create = Scene_Skill.prototype.create;
    Scene_Skill.prototype.create = function() {
        _Scene_Skill_Create.call(this);
        var _image = ImageManager.loadSystem('Window_Status');
        this._helpWindow._windowskin = _image;
        this._skillTypeWindow._windowskin = _image;
        this._statusWindow._windowskin = _image;
        this._itemWindow._windowskin = _image;
        this._actorWindow._windowskin = _image;

        this._helpWindow._refreshAllParts();
        this._skillTypeWindow._refreshAllParts();
        this._statusWindow._refreshAllParts();
        this._itemWindow._refreshAllParts();
        this._actorWindow._refreshAllParts();
    };

    var _Scene_Equip_Create = Scene_Equip.prototype.create;
    Scene_Equip.prototype.create = function() {
        _Scene_Equip_Create.call(this);
        var _image = ImageManager.loadSystem('Window_Status');
        this._helpWindow._windowskin = _image;
        this._statusWindow._windowskin = _image;
        this._commandWindow._windowskin = _image;
        this._slotWindow._windowskin = _image;
        this._itemWindow._windowskin = _image;

        this._helpWindow._refreshAllParts();
        this._statusWindow._refreshAllParts();
        this._commandWindow._refreshAllParts();
        this._slotWindow._refreshAllParts();
        this._itemWindow._refreshAllParts();
    };

    var _Scene_Status_Create = Scene_Status.prototype.create;
    Scene_Status.prototype.create = function() {
        _Scene_Status_Create.call(this);
        this._statusWindow._windowskin = ImageManager.loadSystem('Window_Status');
        this._statusWindow._refreshAllParts();
    };

    var _Scene_Options_Create = Scene_Options.prototype.create;
    Scene_Options.prototype.create = function() {
        _Scene_Options_Create.call(this);
        this._optionsWindow._windowskin = ImageManager.loadSystem('Window_Status');
        this._optionsWindow._refreshAllParts();
    };

    var _Scene_File_Create = Scene_File.prototype.create;
    Scene_File.prototype.create = function() {
        _Scene_File_Create.call(this);
        var _image = ImageManager.loadSystem('Window_Status');
        this._helpWindow._windowskin = _image;
        this._listWindow._windowskin = _image;

        this._helpWindow._refreshAllParts();
        this._listWindow._refreshAllParts();
    };

    var _Scene_GameEnd_Create = Scene_GameEnd.prototype.create;
    Scene_GameEnd.prototype.create = function() {
        _Scene_GameEnd_Create.call(this);
        this._commandWindow._windowskin = ImageManager.loadSystem('Window_Status');
        this._commandWindow._refreshAllParts();
    };

    var _Scene_Battle_Create = Scene_Battle.prototype.create;
    Scene_Battle.prototype.create = function() {
        _Scene_Battle_Create.call(this);

        var _image = ImageManager.loadSystem('Window_Battle');

        this._logWindow._windowskin          = _image;
        this._statusWindow._windowskin       = _image;
        this._partyCommandWindow._windowskin = _image;
        this._actorCommandWindow._windowskin = _image;
        this._helpWindow._windowskin         = _image;
        this._skillWindow._windowskin        = _image;
        this._itemWindow._windowskin         = _image;
        this._actorWindow._windowskin        = _image;
        this._enemyWindow._windowskin        = _image;
        this._messageWindow._windowskin      = _image;
        this._scrollTextWindow._windowskin   = _image;

        this._logWindow._refreshAllParts();
        this._statusWindow._refreshAllParts();
        this._partyCommandWindow._refreshAllParts();
        this._actorCommandWindow._refreshAllParts();
        this._helpWindow._refreshAllParts();
        this._skillWindow._refreshAllParts();
        this._itemWindow._refreshAllParts();
        this._actorWindow._refreshAllParts();
        this._enemyWindow._refreshAllParts();
        this._messageWindow._refreshAllParts();
        this._scrollTextWindow._refreshAllParts();
    };

    var _Window_Message_Initialize = Window_Message.prototype.initialize;
    Window_Message.prototype.initialize = function() {
        _Window_Message_Initialize.call(this);
        this.windowskin = ImageManager.loadSystem('Window_Talk');
        this._refreshAllParts();
    };

    Window.prototype._refreshFrame = function() {
        var w = this._width;
        var h = this._height;
        var m = 24;
        var bitmap = new Bitmap(w, h);

        this._windowFrameSprite.bitmap = bitmap;
        this._windowFrameSprite.setFrame(0, 0, w, h);

        if (w > 0 && h > 0 && this._windowskin) {
            var skin = this._windowskin;

            // frame
            var p = 96;
            var q = 96;
            bitmap.blt(skin, p+0,   0+0,   m,     m,     0,   0,   m,     m);       // left top corner
            bitmap.blt(skin, p+0,   0+q-m, m,     m,     0,   h-m, m,     m);       // left bottom corner
            bitmap.blt(skin, p+q-m, 0+0,   m,     m,     w-m, 0,   m,     m);       // right top corner
            bitmap.blt(skin, p+q-m, 0+q-m, m,     m,     w-m, h-m, m,     m);       // right bottom corner

            var frameHeight = 48;
            var heightCount = Math.floor((h-frameHeight) / frameHeight);
            var remainder = (h-frameHeight) % frameHeight;
            for(var i = 0; i < heightCount; i++) {
                bitmap.blt(skin, p+0,   0+m, m, p-m*2, 0,   m+frameHeight*i, m, frameHeight);   // left frame
                bitmap.blt(skin, p+q-m, 0+m, m, p-m*2, w-m, m+frameHeight*i, m, frameHeight);   // right frame
            }
            if(remainder != 0) {
                bitmap.blt(skin, p+0,   0+m, m, remainder, 0,   m+frameHeight*heightCount, m, remainder);   // left frame
                bitmap.blt(skin, p+q-m, 0+m, m, remainder, w-m, m+frameHeight*heightCount, m, remainder);   // right frame
            }

            var frameWidth = 48;
            var widthCount = Math.floor((w-frameWidth) / frameWidth);
            remainder = (w-frameWidth) % frameWidth;
            for(var j = 0; j < widthCount; j++) {
                bitmap.blt(skin, p+m,   0+0,   p-m*2, m, m+frameWidth*j, 0,   frameWidth, m); // top frame
                bitmap.blt(skin, p+m,   0+q-m, p-m*2, m, m+frameWidth*j, h-m, frameWidth, m); // bottom frame
            }
            if(remainder != 0) {
                bitmap.blt(skin, p+m,   0+0,   remainder, m, m+frameWidth*widthCount, 0,   remainder, m); // top frame
                bitmap.blt(skin, p+m,   0+q-m, remainder, m, m+frameWidth*widthCount, h-m, remainder, m); // bottom frame
            }

            // corner
            var r = 48;
            var s = 48;
            bitmap.blt(skin, 0,   0+q*4, r, s, 0,   0,   r, s); // left top
            bitmap.blt(skin, r,   0+q*4, r, s, w-r, 0,   r, s); // right top
            bitmap.blt(skin, r*2, 0+q*4, r, s, 0,   h-r, r, s); // left bottom
            bitmap.blt(skin, r*3, 0+q*4, r, s, w-r, h-r, r, s); // right bottom

        }
    };

    Window.prototype._refreshBack = function() {
        var m = this._margin + 6;
        var w = this._width - m * 2;
        var h = this._height - m * 2;
        var bitmap = new Bitmap(w, h);

        this._windowBackSprite.bitmap = bitmap;
        this._windowBackSprite.setFrame(0, 0, w, h);
        this._windowBackSprite.move(m, m);

        if (w > 0 && h > 0 && this._windowskin) {
            var p = 192;
            for (var y = 0; y < h; y += p) {
                for (var x = 0; x < w; x += p) {
                    bitmap.blt(this._windowskin, 0, p, p, p, x, y, p, p);
                }
            }
        }
    };

})();


code:
/*=============================================================================
 AnimationByPoint.js
----------------------------------------------------------------------------
 (C)2020 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.2.1 2022/06/30 ヘルプ文言修正
 1.2.0 2022/06/30 アニメーションをマップのスクロールに合わせる機能を追加
 1.1.0 2021/01/03 マップ座標にアニメーションを表示できるコマンドを追加
 1.0.0 2020/12/29 初版
----------------------------------------------------------------------------
 [Blog]   : https://triacontane.blogspot.jp/
 [Twitter]: https://twitter.com/triacontane/
 [GitHub] : https://github.com/triacontane/
=============================================================================*/

/*:
 * @plugindesc AnimationByPointPlugin
 * @target MZ
 * @base PluginCommonBase
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/AnimationByPoint.js
 * @author triacontane
 *
 * @command SHOW_ANIMATION
 * @desc Displays the animation at the specified coordinates (specified in pixels) on the screen.
 *
 * @arg id
 * @text Animation ID
 * @desc The animation ID to display.
 * @default 1
 * @type animation
 *
 * @arg x
 * @text X
 * @desc The X to display the animation.
 * @default 0
 * @type number
 *
 * @arg y
 * @text Y
 * @desc The Y to display the animation.
 * @default 0
 * @type number
 *
 * @arg wait
 * @text Wait to completion
 * @desc Wait for the event to progress until the animation display finishes.
 * @default false
 * @type boolean
 *
 * @help AnimationByPoint.js
 *
 * Provides a command to display an animation at a
 * specified coordinate (pixel specification) on the screen.
 * Since the target of the animation does not exist,
 * flashing to the target is invalid.
 *
 * The base plugin "PluginCommonBase.js" is required to use this plugin.
 * The "PluginCommonBase.js" is here.
 * (MZ install path)dlc/BasicResources/plugins/official/PluginCommonBase.js
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 指定座標へのアニメ表示プラグイン
 * @target MZ
 * @base PluginCommonBase
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/AnimationByPoint.js
 * @author トリアコンタン
 *
 * @command SHOW_ANIMATION
 * @text アニメーション表示
 * @desc 画面上の指定座標(ピクセル指定)にアニメーションを表示します。
 *
 * @arg id
 * @text アニメーションID
 * @desc 表示するアニメーションIDです。
 * @default 1
 * @type animation
 *
 * @arg x
 * @text X座標
 * @desc アニメーションを表示するX座標です。
 * @default 0
 * @type number
 *
 * @arg y
 * @text Y座標
 * @desc アニメーションを表示するY座標です。
 * @default 0
 * @type number
 *
 * @arg wait
 * @text 完了までウェイト
 * @desc アニメーション表示が終わるまでイベントの進行を待機します。
 * @default false
 * @type boolean
 *
 * @arg scroll
 * @text スクロールに連動
 * @desc マップをスクロールに合わせてアニメーションの表示座標が変わります。
 * @default false
 * @type boolean
 *
 * @command SHOW_ANIMATION_BY_MAP_POINT
 * @text マップ座標にアニメーション表示
 * @desc マップ上の指定座標(マス指定)にアニメーションを表示します。
 *
 * @arg id
 * @text アニメーションID
 * @desc 表示するアニメーションIDです。
 * @default 1
 * @type animation
 *
 * @arg x
 * @text X座標
 * @desc アニメーションを表示するマップX座標です。
 * @default 0
 * @type number
 *
 * @arg y
 * @text Y座標
 * @desc アニメーションを表示するマップY座標です。
 * @default 0
 * @type number
 *
 * @arg wait
 * @text 完了までウェイト
 * @desc アニメーション表示が終わるまでイベントの進行を待機します。
 * @default false
 * @type boolean
 *
 * @arg scroll
 * @text スクロールに連動
 * @desc マップをスクロールに合わせてアニメーションの表示座標が変わります。
 * @default false
 * @type boolean
 *
 * @help AnimationByPoint.js
 *
 * 画面上の指定座標(ピクセル指定)にアニメーションを表示するコマンドを提供します。
 * アニメーションの対象が存在しないため、対象へのフラッシュは無効です。
 * またプラグインの構造上、プライオリティ変更の機能追加はできません。
 *
 * このプラグインの利用にはベースプラグイン『PluginCommonBase.js』が必要です。
 * 『PluginCommonBase.js』は、RPGツクールMZのインストールフォルダ配下の
 * 以下のフォルダに格納されています。
 * dlc/BasicResources/plugins/official
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(() => {
    'use strict';
    const script = document.currentScript;

    PluginManagerEx.registerCommand(script, 'SHOW_ANIMATION', function(args) {
        this.requestAnimationByPoint(args);
    });

    PluginManagerEx.registerCommand(script, 'SHOW_ANIMATION_BY_MAP_POINT', function(args) {
        args.x = $gameMap.convertToScreenX(args.x);
        args.y = $gameMap.convertToScreenY(args.y);
        this.requestAnimationByPoint(args);
    });

    Game_Map.prototype.convertToScreenX = function(mapX) {
        const tw = $gameMap.tileWidth();
        return Math.floor($gameMap.adjustX(mapX) * tw + tw / 2);
    };

    Game_Map.prototype.convertToScreenY = function(mapY) {
        const th = $gameMap.tileHeight();
        return Math.floor($gameMap.adjustY(mapY) * th + th / 2);
    };

    Game_Interpreter.prototype.requestAnimationByPoint = function(args) {
        const point = new Game_AnimationPoint(args);
        $gameTemp.requestAnimation([point], args.id);
        if (args.wait) {
            this.setWaitMode("pointAnimation");
        }
    };

    Spriteset_Base.prototype.findPointTargetSprite = function(point) {
        if (point instanceof Point) {
            const sprite = new Sprite_AnimationPoint(point);
            this.addChild(sprite);
            return sprite;
        } else {
            return null;
        }
    };

    const _Spriteset_Base_removeAnimation = Spriteset_Base.prototype.removeAnimation;
    Spriteset_Base.prototype.removeAnimation = function(sprite) {
        _Spriteset_Base_removeAnimation.apply(this, arguments);
        sprite._targets.forEach(targetSprite => {
            if (targetSprite instanceof Sprite_AnimationPoint) {
                this.removeChild(targetSprite);
            }
        })
    };

    const _Spriteset_Map_findTargetSprite = Spriteset_Map.prototype.findTargetSprite
    Spriteset_Map.prototype.findTargetSprite = function(target) {
        const sprite = _Spriteset_Map_findTargetSprite.apply(this, arguments);
        return sprite ? sprite : this.findPointTargetSprite(target);
    };

    const _Spriteset_Battle_findTargetSprite = Spriteset_Battle.prototype.findTargetSprite
    Spriteset_Battle.prototype.findTargetSprite = function(target) {
        const sprite = _Spriteset_Battle_findTargetSprite.apply(this, arguments);
        return sprite ? sprite : this.findPointTargetSprite(target);
    };

    let pointAnimationCount = 0;

    const _Game_Interpreter_updateWaitMode = Game_Interpreter.prototype.updateWaitMode;
    Game_Interpreter.prototype.updateWaitMode = function() {
        if (this._waitMode === 'pointAnimation') {
            if (pointAnimationCount === 0) {
                this._waitMode = '';
                return false;
            } else {
                return true;
            }
        } else {
            return _Game_Interpreter_updateWaitMode.apply(this, arguments);
        }
    };

    class Game_AnimationPoint extends Point {
        constructor(args) {
            super(args.x, args.y);
            this._wait = args.wait;
            this._scroll = args.scroll;
        }

        startAnimation() {
            if (this._wait) {
                pointAnimationCount++;
            }
        }

        endAnimation() {
            if (this._wait) {
                pointAnimationCount--;
            }
        }

        isScroll() {
            return this._scroll;
        }
    }

    class Sprite_AnimationPoint extends Sprite {
        constructor(point) {
            super();
            this._point = point;
            this._dx = $gameMap.displayX();
            this._dy = $gameMap.displayY();
            this.update();
        }

        update() {
            super.update();
            this.x = this._point.x;
            this.y = this._point.y;
            if (this._point.isScroll()) {
                this.x += (this._dx - $gameMap.displayX()) * $gameMap.tileWidth();
                this.y += (this._dy - $gameMap.displayY()) * $gameMap.tileWidth();
            }
        }
    }
})();


code:
//
//  アニメーションマップネーム ver1.03
//
// author yana
//

var Imported = Imported || {};
Imported['AnimationMapName'] = 1.03;

/*:
 * @plugindesc ver1.03/マップ名表示をアニメーションさせます。
 * @author Yana
 *
 * @param Pattern Variable ID
 * @desc パターンの変更に使う変数のIDです。
 * 0または、空欄で変数を使用しません。
 * @default
 *
 * @param Anime Font Size
 * @desc 表示マップ名のフォントサイズです。
 * @default 28
 *
 * @param Anime Pattern
 * @desc マップ名の動作パターンです。
 * Normal:普通 GrowUp:にょきにょき Stretch:うにょーん
 * @default Normal
 *
 * @param Anime Count
 * @desc マップ名の表示時間です。
 * @default 300
 *
 * @param Anime OriginalX
 * @desc 移動前の座標Xです。
 * @default 0
 *
 * @param Anime OriginalY
 * @desc 移動前の座標Yです。
 * @default -60
 *
 * @param Anime MoveX
 * @desc X座標の移動距離です。
 * @default 0
 *
 * @param Anime MoveY
 * @desc Y座標の移動距離です。
 * @default 60
 *
 * @param Fill Rect Color
 * @desc 背景の色です。
 * @default rgba(0,0,0,0.5)
 *
 * @param Back Picture
 * @desc 背景に使用するピクチャ画像です。
 * こちらを指定すると、背景を塗りつぶすRectは無効になります。
 * @default
 *
 * @help------------------------------------------------------
 * プラグインコマンド
 * ------------------------------------------------------
 * アニメーションマップネーム 設定 ～
 * AnimationMapName Setting ～
 *
 * アニメーションマップネームの設定を変更します。
 * 変更できる項目は、それぞれプラグインパラメータに対応しており、
 * size:Anime Font Size
 * pattern:Anime Pattern
 * count:Anime Count
 * ox:Anime OriginalX
 * oy:Anime OriginalY
 * mx:Anime MoveX
 * my:Anime MoveY
 * color:Fill Rect Color
 * picture:Back Picture
 * となっています。
 * 記述は以下のように「変更したい項目:変更後の設定」と記述します。
 * 例:patternをGrowUp,countを200に変更する。
 * アニメーションマップネーム 設定 pattern:GrowUp count:200
 *
 * アニメーションマップネーム 表示 ～
 * AnimationMapName Add ～
 *
 * 指定したパラメータを使って、アニメーションマップネームを呼び出します。
 * 指定できるパラメータは上記の設定に加えて、
 * text:表示するテキスト
 * が使用可能です。
 * ------------------------------------------------------
 * 使い方
 * ------------------------------------------------------
 * マップ名表示を改造し、アニメーションするように変更します。
 * また、
 * \C[x]　\I[x]　\V[x] \N[x] \P[x] \G
 * の制御文字を使用できるようになります。
 *
 * ---変数によるパターンの設定---
 * 変数IDを設定してあると、変数の値を変更するだけで、アニメーションの
 * 表示パターンが変更可能です。
 * それぞれ、対応する数値と設定は、
 * 0でNormal、-1でStretch、-2でGrowUp
 * となります。
 * この数値は、プラグインコマンドで設定が変更された際には、自動で設定された
 * 値に合わせた数値が代入されます。
 *
 * ---マップのメモによるパラメータの設定---
 * マップのメモ欄を使うことでも、アニメーションマップネームの設定を、
 * 個別に変更することが可能です。
 * マップのメモ欄に以下のように記述してください。
 *
 * <アニメーションマップネーム設定>
 *
 * 設定項目
 *
 * </アニメーションマップネーム設定>
 *
 * 設定項目は、プラグインコマンドの設定の変更の項目で記述されているものが
 * 使用可能です。
 *
 * ---各設定項目の優先度---
 * プラグインコマンドによる設定は、基本設定を書き換えると同時に、パターンが
 * 設定されている場合は、指定した変数の数値も書き換えます。
 *
 * マップのメモによる設定は、基本的に優先されます。
 * プラグインコマンドで呼び出した場合も、マップに設定がある場合は、その設定を
 * ベースとして使用します。
 * また、マップのメモによるパターンの設定は、変数の値より優先されます。
 * その際、変数の値の変更は行いません。
 *
 * なので、優先度は
 * コマンドで呼び出した際の個別設定＞マップの設定＞変数のパターン設定＞基本設定
 * となります。
 *
 * ---リージョンネームの設定---
 * マップのメモ欄を使ってリージョンネームを設定することで、そのリージョンに
 * 足を踏み入れた際にリージョンネームをポップアップさせることができます。
 *
 * マップのメモ欄に
 * <RegionName○:xxx …>
 * <リージョンネーム○:xxx …>
 * のいずれかの書式で記述がある場合、○番のリージョンに侵入した際、xxxで指定した
 * テキストが、マップ名表示としてポップアップします。
 * …の部分は、プラグインコマンドと同じ設定項目が使用できます。
 * 設定せずに、<リージョンネーム○:xxx>だけでも動作します。
 * また、このポップアップは、リージョンネームの設定されたリージョンから、
 * 別のリージョンネームの設定されたリージョンに侵入したときのみ、反応します。
 *
 * 例:3番のリージョンに侵入した際、テストエリアA-1のテキストを、
 *    パターンGrowUpで60フレームの表示時間だけ表示
 * <リージョンネーム3:テストエリアA-1 pattern:GrowUp count:60>
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.03:
 * イベントコマンドでマップ名表示が無効化できなかったバグを修正。
 * 表示パターン「GrowUp」「Stretch」を追加。
 * プラグインコマンドを追加。
 * 設定項目を追加。
 * ver1.02:
 * CommonPopupCoreの変更に合わせて処理を修正。
 * ver1.01:
 * イベントテストが正常に機能していなかったバグを修正。
 * ver1.00:
 * 公開
 */

////////////////////////////////////////////////////////////////////////////////////

(function() {
    var parameters = PluginManager.parameters('AnimationMapName');
    var patternVariableId = Number(parameters['Pattern Variable ID']) || 0;
    var animeFontSize = Number(parameters['Anime Font Size'] || 28);
    var animeCount = Number(parameters['Anime Count'] || 300);
    var animeOriginalX = Number(parameters['Anime OriginalX'] || 0);
    var animeOriginalY = Number(parameters['Anime OriginalY'] || 0);
    var animeMoveX = Number(parameters['Anime MoveX'] || 0);
    var animeMoveY = Number(parameters['Anime MoveY'] || 0);
    var animePattern = parameters['Anime Pattern'] || 'Normal';
    var fillRectColor = parameters['Fill Rect Color'] || 'rgba(0,0,0,0.5)';
    var backPicture = parameters['Back Picture'];

    ////////////////////////////////////////////////////////////////////////////////////

    var __GInterpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        __GInterpreter_pluginCommand.call(this, command, args);
        if (command === 'AnimationMapName' || command === 'アニメーションマップネーム') {
            var code = args.shift();
            if (code === 'Setting' || code === '設定') this.setAmsSetting(args);
            if (code === 'Add' || code === '表示') this.showAmn(args);
        }
    };

    Game_Interpreter.prototype.setAmsSetting = function(args) {
        var params = $gameSystem.amnParameters();
        var amnParams = DataManager.makeAmnParams(params,args);
        if (patternVariableId){
            if (amnParams.pattern === 'Normal' || amnParams.pattern == 0){
                $gameVariables._data[patternVariableId] = 0;
            } else if (amnParams.pattern === 'Stretch' || amnParams.pattern == -1){
                $gameVariables._data[patternVariableId] = -1;
            } else if (amnParams.pattern === 'GrowUp' || amnParams.pattern == -2){
                $gameVariables._data[patternVariableId] = -2;
            } else {
                $gameVariables._data[patternVariableId] = Number(amnParams.pattern);
            }
        }
        $gameSystem.setAmnParameters(amnParams);
    };

    ////////////////////////////////////////////////////////////////////////////////////

    DataManager.amnMapParams = function(map) {
        if (!map) return false;
        if (map._amsParams){ return map._amsParams }
        var texts = map.note.split('\n');
        var params = {};
        for (var i=0,max=texts.length;i<max;i++) {
            if (/^<(?:AnimationMapNameSetting|アニメーションマップネーム設定)>/.exec(texts[i])){
                for (var j=i;j<max;j++){
                    if (/^<\/(?:AnimationMapNameSetting|アニメーションマップネーム設定)>/.exec(texts[j])) {
                        i=j;
                        break;
                    } else {
                        if (/(.+?):(.+)?/.exec(texts[j])){
                            var code = RegExp.$1;
                            var value = RegExp.$2;
                            switch(code) {
                                case 'size':    params.size = Number(value) ; break;
                                case 'count':   params.count = Number(value);break;
                                case 'ox':      params.ox = Number(value)   ;break;
                                case 'oy':      params.oy = Number(value)   ;break;
                                case 'mx':      params.mx = Number(value)   ;break;
                                case 'my':      params.my = Number(value)   ;break;
                                case 'pattern': params.pattern = value      ;break;
                                case 'color':   params.color = value        ;break;
                                case 'picture': params.picture = value      ;break;
                                case 'text':    params.text = value         ;break;
                            }
                        }
                    }
                }
            }
        }
        map._amsParams = params;
        return map._amsParams;
    };

    DataManager.makeAmnParams = function(params,args) {
        var amnParams = { size:params.size, count:params.count,
            ox:params.ox, oy:params.oy, mx:params.mx, my:params.my,
            pattern:params.pattern, color:params.color, picture:params.picture,
            text:params.text };
        args.forEach(function(a){
            if (/(.+?):(.+)?/.exec(a)){
                var code = RegExp.$1;
                var value = RegExp.$2;
                switch(code){
                    case 'size':   amnParams.size = Number(value);  break;
                    case 'count':  amnParams.count = Number(value); break;
                    case 'ox':     amnParams.ox = Number(value);    break;
                    case 'oy':     amnParams.oy = Number(value);    break;
                    case 'mx':     amnParams.mx = Number(value);    break;
                    case 'my':     amnParams.my = Number(value);    break;
                    case 'pattern':amnParams.pattern = value;       break;
                    case 'color':  amnParams.color = value;         break;
                    case 'picture':amnParams.picture = value;       break;
                    case 'text':   amnParams.text = value;          break;
                }
            }
        }.bind(this));
        return amnParams;
    };

    ////////////////////////////////////////////////////////////////////////////////////

    Game_System.prototype.amnParameters = function() {
        if (!this._amnParameters) this.initAmnParameters();
        if (patternVariableId){
            this._amnParameters.pattern = $gameVariables.value(patternVariableId);
        }
        var params = DataManager.amnMapParams($dataMap);
        var amnParams = { size:this._amnParameters.size, count:this._amnParameters.count,
                          ox:this._amnParameters.ox, oy:this._amnParameters.oy,
                          mx:this._amnParameters.mx, my:this._amnParameters.my,
                          pattern:this._amnParameters.pattern, color:this._amnParameters.color,
                          picture:this._amnParameters.picture };
        for (var key in params) { amnParams[key] = params[key] }
        return amnParams;
    };

    Game_System.prototype.initAmnParameters = function() {
        this._amnParameters = { size:animeFontSize, count:animeCount, ox:animeOriginalX,
                                oy:animeOriginalY, mx:animeMoveX, my:animeMoveY,
                                pattern:animePattern, color:fillRectColor, picture:backPicture,
                                text:''};
        if (patternVariableId){
            var pattern = this._amnParameters.pattern;
            if (pattern === 'Normal'  || pattern === 0)  $gameVariables._data[patternVariableId] = 0;
            if (pattern === 'Stretch' || pattern === -1) $gameVariables._data[patternVariableId] = -1;
            if (pattern === 'GrowUp'  || pattern === -2) $gameVariables._data[patternVariableId] = -2;
        }
    };

    Game_System.prototype.setAmnParameters = function(params) {
        this._amnParameters = params;
    };

    ////////////////////////////////////////////////////////////////////////////////////

    var __GInterpreter_update = Game_Interpreter.prototype.update;
    Game_Interpreter.prototype.update = function() {
        __GInterpreter_update.call(this);
        if (this._refreshAmn){
            if (ImageManager.isReady()) {
                this.refreshMapName(this._amnParams);
                this._refreshAmn = false;
                this._amnParams = null;
            }
        }
    };

    Game_Interpreter.prototype.animationMapName = function(params) {
        if(params.picture){
            ImageManager.loadPicture(params.picture);
            this._refreshAmn = true;
            this._amnParams = params;
        } else {
            this.refreshMapName(params);
        }
    };

    Game_Interpreter.prototype.refreshMapName = function(params) {
        var text = (params.text ? params.text : $gameMap.displayName()) || '';
        var array = CommonPopupManager.window().convertEscapeCharacters(text).split("");
        var a2 = [];
        var flag = false;
        var cflag = false;
        var setIndex = -1;
        var count = 0;
        var s1 = '';
        var aX = 0;
        var aY = 0;
        if (params.pattern === 'GrowUp' || params.pattern == -2) aY = 1.0;
        var pattern = params.pattern;
        var afs = params.size + 8;
        var supY = 0;
        if (params.pattern === 'GrowUp' || params.pattern == -2) supY = afs;
        for(var i=0,max=array.length;i<max;i++){
            if (array[i] === '\x1b') {
                var cnt = a2.length;
                a2[cnt] = array[i];
                for (var j=i;j<max;j++){
                    if (array[j] === ']') {
                        a2[cnt] += ']';
                        //a2[i] = a2[i].replace(/\x1b/,'\\');
                        if (a2[cnt].match(/\x1bI\[\d+\]/i)) count++;
                        i = j;
                        break;
                    } else {
                      a2[cnt] += array[j];
                    }
                }
            } else {
                a2.push(array[i]);
                s1 += array[i];
            }
        }

        CommonPopupManager.window().resetFontSettings();
        var fs = params.size;
        var fontStr = '\\FS[' + fs + ']';
        CommonPopupManager.window().drawTextEx(fontStr,0,0);
        var textSize = CommonPopupManager.window().textWidth(s1) + params.size;
        textSize += (params.size * 1.14) * count;
        var bitmap = null;
        var bw = textSize;
        var bh = fs;

        if (params.picture) {
            bitmap = ImageManager.loadPicture(params.picture);
            var arg = CommonPopupManager.setPopup('');
            bw = bitmap.width;
            bh = bitmap.height;
            arg.x = params.ox// + textSize / 2 - bitmap.width / 2;
            arg.y = params.oy + bitmap.height * aY;
            arg.moveX = params.mx;
            arg.moveY = params.my;
            arg.bitmap = bitmap;
            arg.count = params.count;
            arg.extend = [arg.count * 0.2, arg.count * 0.8];
            arg.fixed = false;
            arg.anchorX = aX;
            arg.anchorY = aY;
            arg.pattern = pattern;
            arg.tag = 'AnimationMapName';
            supY += bitmap.height / 2 - afs / 2;
        } else {
            bitmap = new Bitmap(textSize, params.size + 8);

            bitmap.gradientFillRect(0, 0, bitmap.width / 3, bitmap.height, 'rgba(0,0,0,0)', params.color);
            bitmap.fillRect(bitmap.width / 3, 0, bitmap.width / 3, bitmap.height, params.color);
            bitmap.gradientFillRect((bitmap.width * 2) / 3, 0, bitmap.width / 3, bitmap.height, params.color, 'rgba(0,0,0,0)');

            var arg = CommonPopupManager.setPopup('');
            arg.x = params.ox;
            arg.y = params.oy + supY;
            arg.moveX = params.mx;
            arg.moveY = params.my;
            arg.bitmap = bitmap;
            arg.count = params.count;
            arg.extend = [arg.count * 0.2, arg.count * 0.8];
            arg.fixed = false;
            arg.anchorX = aX;
            arg.anchorY = aY;
            arg.pattern = pattern;
            arg.tag = 'AnimationMapName';
        }
        if(arg) CommonPopupManager._tempCommonSprites.setNullPos(arg);

        var s = Math.floor((params.count*0.4)/s1.length);
        var n = 0;
        var setColor = '';
        var ssupY = (pattern == -2 || pattern === 'GrowUp') ? 4 : 0;
        var bfs = fs;
        var cnt = 0;
        CommonPopupManager.window().contents.fontSize = fs;
        for(var i=0;i<a2.length;i++){
            if (a2[i].match(/\x1bI\[(\d+)\]/i)) a2[i] = '\\I[' + RegExp.$1 + ']';
            if (a2[i].match(/\x1bC\[(\d+)\]/i)) {
                setColor = '\\C[' + RegExp.$1 + ']';
            }else if (a2[i].match(/\x1bFS\[(\d+)\]/i)){
                fs = Number(RegExp.$1);
                fontStr = '\\FS[' + fs + ']';
            }else{
                var fsy = (bfs - fs) / 2;
                if (fsy > 0 && ssupY > 0) fsy -= 8 ;
                var arg = CommonPopupManager.setPopup('');
                var bitmap = new Bitmap(fs+12,fs+12);
                var tx = fontStr + setColor + a2[i];
                CommonPopupManager.window().contents.fontSize = fs;
                var tw = CommonPopupManager.window().textWidth(a2[i]);
                CommonPopupManager.window().contents = bitmap;
                CommonPopupManager.window().drawTextEx(tx,4,0);
                arg.bitmap = bitmap;
                arg.x = params.ox + n + (bw - textSize)/ 2 + 10;
                arg.y = params.oy + supY + ssupY + fsy;
                arg.moveX = params.mx;
                arg.moveY = params.my;
                arg.anchorX = aX;
                arg.anchorY = aY;
                arg.delay = s * (cnt + 1);
                arg.count = Math.floor((params.count-20) - (cnt * s));
                arg.extend = [arg.count*0.2,arg.count*0.8];
                arg.fixed = false;
                arg.pattern = pattern;
                arg.tag = 'AnimationMapName';
                if (a2[i].match(/\\I\[\d+\]/i)){
                    n += 34;
                }else{
                    n += tw;
                }
                CommonPopupManager._tempCommonSprites.setNullPos(arg);
                cnt++;
            }
        }
    };

    Game_Interpreter.prototype.showAmn = function(args) {
        CommonPopupManager.clearPopup('AnimationMapName');
        var amnParams = DataManager.makeAmnParams($gameSystem.amnParameters(),args);
        this.animationMapName(amnParams);
    };

    ////////////////////////////////////////////////////////////////////////////////////

    Game_Map.prototype.showMapName = function() {
        if (this.displayName() !== ''){
            this._interpreter.animationMapName($gameSystem.amnParameters());
        }
    };

    Game_Map.prototype.displayRegionAmn = function(params) {
        if(!this.isNameDisplayEnabled()) return;
        var args = params.split(' ');
        args[0] = 'text:' + args[0];
        this._interpreter.showAmn(args);
    };

    ////////////////////////////////////////////////////////////////////////////////////

    var _animeMN_GPlayer_performTransfer = Game_Player.prototype.performTransfer;
    Game_Player.prototype.performTransfer = function() {
        _animeMN_GPlayer_performTransfer.call(this);
        if($gameMap.isNameDisplayEnabled()) $gameMap.showMapName();
        $gameTemp._regionAmnArray = null;
        $gameTemp._lastRegionId = null;
    };

    var __GPlayer_update = Game_Player.prototype.update;
    Game_Player.prototype.update = function(sceneActive) {
        __GPlayer_update.call(this, sceneActive);
        var ri = this.regionId();
        if (this.regionAmnArray(ri) && ri !== $gameTemp._lastRegionId) {
            $gameTemp._lastRegionId = ri;
            if ($dataMap.meta['RegionName'+ri]) {
                $gameMap.displayRegionAmn($dataMap.meta['RegionName'+ri]);
            } else if ($dataMap.meta['リージョンネーム'+ri]){
                $gameMap.displayRegionAmn($dataMap.meta['リージョンネーム'+ri]);
            }
        }
    };

    Game_Player.prototype.regionAmnArray = function(ri) {
        if ($gameTemp._regionAmnArray) return $gameTemp._regionAmnArray[ri];
        $gameTemp._regionAmnArray = [];
        for (var i=1,max=255;i<max;i++){
            if ($dataMap.meta['RegionName' + i]) $gameTemp._regionAmnArray[i] = true;
            if ($dataMap.meta['リージョンネーム' + i]) $gameTemp._regionAmnArray[i] = true;
        }
        return $gameTemp._regionAmnArray[ri];
    };

    ////////////////////////////////////////////////////////////////////////////////////

    // 再定義　何もしなくする
    Window_MapName.prototype.open = function() {
        //this.refresh();
        this._showCount = 0;
    };

    ////////////////////////////////////////////////////////////////////////////////////

})();