phaser4-rex-plugins
Version:
1,704 lines (1,376 loc) • 78.5 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.rextriangleplugin = factory());
})(this, (function () { 'use strict';
const GetCalcMatrix = Phaser.GameObjects.GetCalcMatrix;
var WebGLRenderer = function (renderer, src, drawingContext, parentMatrix) {
src.updateData();
var camera = drawingContext.camera;
camera.addToRenderList(src);
var calcMatrix = GetCalcMatrix(src, camera, parentMatrix, !drawingContext.useCanvas).calc;
var dx = src._displayOriginX;
var dy = src._displayOriginY;
var alpha = src.alpha;
var submitter = src.customRenderNodes.Submitter || src.defaultRenderNodes.Submitter;
var shapes = src.geom,
shape;
for (var i = 0, cnt = shapes.length; i < cnt; i++) {
shape = shapes[i];
if (shape.visible) {
shape.webglRender(drawingContext, submitter, calcMatrix, src, alpha, dx, dy);
}
}
};
const SetTransform = Phaser.Renderer.Canvas.SetTransform;
var CanvasRenderer = function (renderer, src, camera, parentMatrix) {
src.updateData();
camera.addToRenderList(src);
var ctx = renderer.currentContext;
if (SetTransform(renderer, ctx, src, camera, parentMatrix)) {
var dx = src._displayOriginX;
var dy = src._displayOriginY;
var shapes = src.geom,
shape;
for (var i = 0, cnt = shapes.length; i < cnt; i++) {
shape = shapes[i];
if (shape.visible) {
shape.canvasRender(ctx, dx, dy);
}
}
// Restore the context saved in SetTransform
ctx.restore();
}
};
var Render = {
renderWebGL: WebGLRenderer,
renderCanvas: CanvasRenderer
};
var Clear = function (obj) {
if ((typeof (obj) !== 'object') || (obj === null)) {
return obj;
}
if (Array.isArray(obj)) {
obj.length = 0;
} else {
for (var key in obj) {
delete obj[key];
}
}
return obj;
};
const Shape = Phaser.GameObjects.Shape;
const RemoveItem = Phaser.Utils.Array.Remove;
class BaseShapes extends Shape {
constructor(scene, x, y, width, height) {
if (x === undefined) {
x = 0;
}
if (y === undefined) {
y = 0;
}
if (width === undefined) {
width = 2;
}
if (height === undefined) {
height = width;
}
super(scene, 'rexShapes', []);
this._width = -1;
this._height = -1;
this.dirty = true;
this.isSizeChanged = true;
this.shapes = {};
this.setPosition(x, y);
this.setSize(width, height);
this.updateDisplayOrigin();
}
get width() {
return this._width;
}
set width(value) {
this.setSize(value, this._height);
}
get height() {
return this._height;
}
set height(value) {
this.setSize(this._width, value);
}
setDirty(value) {
if (value === undefined) {
value = true;
}
this.dirty = value;
return this;
}
setSize(width, height) {
this.isSizeChanged = this.isSizeChanged || (this._width !== width) || (this._height !== height);
this.dirty = this.dirty || this.isSizeChanged;
this._width = width;
this._height = height;
this.updateDisplayOrigin();
var input = this.input;
if (input && !input.customHitArea) {
input.hitArea.width = width;
input.hitArea.height = height;
}
return this;
}
resize(width, height) {
this.setSize(width, height);
return this;
}
get fillColor() {
return this._fillColor;
}
set fillColor(value) {
this.setFillStyle(value, this._fillAlpha);
}
get fillAlpha() {
return this._fillAlpha;
}
set fillAlpha(value) {
this.setFillStyle(this._fillColor, value);
}
setFillStyle(color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.fillColor !== color) ||
(this.fillAlpha !== alpha);
this._fillColor = color;
this._fillAlpha = alpha;
return this;
}
get lineWidth() {
return this._lineWidth;
}
set lineWidth(value) {
this.setStrokeStyle(value, this._strokeColor, this._strokeAlpha);
}
get strokeColor() {
return this._strokeColor;
}
set strokeColor(value) {
this.setStrokeStyle(this._lineWidth, value, this._strokeAlpha);
}
get strokeAlpha() {
return this._strokeAlpha;
}
set strokeAlpha(value) {
this.setStrokeStyle(this._lineWidth, this._strokeColor, value);
}
setStrokeStyle(lineWidth, color, alpha) {
if (alpha === undefined) {
alpha = 1;
}
this.dirty = this.dirty ||
(this.lineWidth !== lineWidth) ||
(this.strokeColor !== color) ||
(this.strokeAlpha !== alpha);
this._lineWidth = lineWidth;
this._strokeColor = color;
this._strokeAlpha = alpha;
return this;
}
updateShapes() {
}
updateData() {
if (!this.dirty) {
return this;
}
this.updateShapes();
var shapes = this.geom;
for (var i = 0, cnt = shapes.length; i < cnt; i++) {
var shape = shapes[i];
if (shape.dirty) {
shape.updateData();
}
}
this.isSizeChanged = false;
this.dirty = false;
return this;
}
clear() {
this.geom.length = 0;
Clear(this.shapes);
this.dirty = true;
return this;
}
getShape(name) {
return this.shapes[name];
}
getShapes() {
return this.geom;
}
addShape(shape) {
this.geom.push(shape);
var name = shape.name;
if (name) {
this.shapes[name] = shape;
}
this.dirty = true;
return this;
}
deleteShape(name) {
var shape = this.getShape(name);
if (shape) {
delete this.shapes[name];
RemoveItem(this.geom, shape);
}
return this;
}
}
Object.assign(
BaseShapes.prototype,
Render
);
var FillStyle = function (color, alpha) {
if (color == null) {
this.isFilled = false;
} else {
if (alpha === undefined) {
alpha = 1;
}
this.isFilled = true;
this.fillColor = color;
this.fillAlpha = alpha;
}
return this;
};
var LineStyle = function (lineWidth, color, alpha) {
if ((lineWidth == null) || (color == null)) {
this.isStroked = false;
} else {
if (alpha === undefined) {
alpha = 1;
}
this.isStroked = true;
this.lineWidth = lineWidth;
this.strokeColor = color;
this.strokeAlpha = alpha;
}
return this;
};
var StyleMethods = {
fillStyle: FillStyle,
lineStyle: LineStyle
};
var GetValue$7 = function (source, key, defaultValue) {
if (!source || typeof source === 'number') {
return defaultValue;
}
if (typeof (key) === 'string') {
if (source.hasOwnProperty(key)) {
return source[key];
}
if (key.indexOf('.') !== -1) {
key = key.split('.');
} else {
return defaultValue;
}
}
var keys = key;
var parent = source;
var value = defaultValue;
// Use for loop here so we can break early
for (var i = 0; i < keys.length; i++) {
key = keys[i];
if (parent.hasOwnProperty(key)) {
// Yes it has a key property, let's carry on down
value = parent[key];
parent = value;
}
else {
// Can't go any further, so reset to default
value = defaultValue;
break;
}
}
return value;
};
var DataMethods = {
enableData() {
if (this.data === undefined) {
this.data = {};
}
return this;
},
setData(key, value) {
this.enableData();
if (arguments.length === 1) {
var data = key;
for (key in data) {
this.data[key] = data[key];
}
} else {
this.data[key] = value;
}
return this;
},
getData(key, defaultValue) {
this.enableData();
return (key === undefined) ? this.data : GetValue$7(this.data, key, defaultValue);
},
incData(key, inc, defaultValue) {
if (defaultValue === undefined) {
defaultValue = 0;
}
this.enableData();
this.setData(key, this.getData(key, defaultValue) + inc);
return this;
},
mulData(key, mul, defaultValue) {
if (defaultValue === undefined) {
defaultValue = 0;
}
this.enableData();
this.setData(key, this.getData(key, defaultValue) * mul);
return this;
},
clearData() {
if (this.data) {
Clear(this.data);
}
return this;
},
};
class BaseGeom {
constructor() {
this.name = undefined;
this.dirty = true;
this.visible = true;
this.data = undefined;
this.isFilled = false;
this.fillColor = undefined;
this.fillAlpha = 1;
this.isStroked = false;
this.lineWidth = 1;
this.strokeColor = undefined;
this.strokeAlpha = 1;
}
setName(name) {
this.name = name;
return this;
}
setVisible(visible) {
if (visible === undefined) {
visible = true;
}
this.visible = visible;
return this;
}
reset() {
this
.setVisible()
.fillStyle()
.lineStyle();
return this;
}
webglRender(drawingContext, submitter, gameObject, calcMatrix, alpha, dx, dy) {
}
canvasRender(ctx, dx, dy) {
}
updateData() {
this.dirty = false;
}
}
Object.assign(
BaseGeom.prototype,
StyleMethods,
DataMethods
);
/*
shapeData: {
fillColor,
fillAlpha,
pathData,
pathIndexes // Earcut(pathData)
}
*/
var Utils$1 = Phaser.Renderer.WebGL.Utils;
var FillPathWebGL = function (drawingContext, submitter, calcMatrix, gameObject, shapeData, alpha, dx, dy) {
// This is very similar to the FillPath RenderNode, but it already
// has access to the Earcut indexes, so it doesn't need to calculate them.
var fillTintColor = Utils$1.getTintAppendFloatAlpha(shapeData.fillColor, shapeData.fillAlpha * alpha);
var path = shapeData.pathData;
var pathIndexes = shapeData.pathIndexes;
var length = path.length;
var pathIndex, pointX, pointY, x, y;
var vertices = Array(length * 2);
var colors = Array(length);
var verticesIndex = 0;
var colorsIndex = 0;
for (pathIndex = 0; pathIndex < length; pathIndex += 2) {
pointX = path[pathIndex] - dx;
pointY = path[pathIndex + 1] - dy;
// Transform the point.
x = calcMatrix.getX(pointX, pointY);
y = calcMatrix.getY(pointX, pointY);
vertices[verticesIndex++] = x;
vertices[verticesIndex++] = y;
colors[colorsIndex++] = fillTintColor;
}
submitter.batch(
drawingContext,
pathIndexes,
vertices,
colors
);
};
/*
shapeData: {
strokeColor,
strokeAlpha,
pathData,
lineWidth,
closePath
}
*/
var Utils = Phaser.Renderer.WebGL.Utils;
var StrokePathWebGL = function (drawingContext, submitter, matrix, gameObject, shapeData, alpha, dx, dy) {
var strokeTintColor = Utils.getTintAppendFloatAlpha(shapeData.strokeColor, shapeData.strokeAlpha * alpha);
var path = shapeData.pathData;
var pathLength = path.length - 1;
var lineWidth = shapeData.lineWidth;
var openPath = !shapeData.closePath;
var strokePath = gameObject.customRenderNodes.StrokePath || gameObject.defaultRenderNodes.StrokePath;
var pointPath = [];
// Don't add the last point to open paths.
if (openPath) {
pathLength -= 2;
}
for (var i = 0; i < pathLength; i += 2) {
var x = path[i] - dx;
var y = path[i + 1] - dy;
if (i > 0) {
if (x === path[i - 2] && y === path[i - 1]) {
// Duplicate point, skip it
continue;
}
}
pointPath.push({
x: x,
y: y,
width: lineWidth
});
}
strokePath.run(
drawingContext,
submitter,
pointPath,
lineWidth,
openPath,
matrix,
strokeTintColor, strokeTintColor, strokeTintColor, strokeTintColor
);
};
var FillStyleCanvas = function (ctx, src, altColor, altAlpha)
{
var fillColor = (altColor) ? altColor : src.fillColor;
var fillAlpha = (altAlpha) ? altAlpha : src.fillAlpha;
var red = ((fillColor & 0xFF0000) >>> 16);
var green = ((fillColor & 0xFF00) >>> 8);
var blue = (fillColor & 0xFF);
ctx.fillStyle = 'rgba(' + red + ',' + green + ',' + blue + ',' + fillAlpha + ')';
};
var LineStyleCanvas = function (ctx, src, altColor, altAlpha)
{
var strokeColor = (altColor) ? altColor : src.strokeColor;
var strokeAlpha = (altAlpha) ? altAlpha : src.strokeAlpha;
var red = ((strokeColor & 0xFF0000) >>> 16);
var green = ((strokeColor & 0xFF00) >>> 8);
var blue = (strokeColor & 0xFF);
ctx.strokeStyle = 'rgba(' + red + ',' + green + ',' + blue + ',' + strokeAlpha + ')';
ctx.lineWidth = src.lineWidth;
};
const Earcut = Phaser.Geom.Polygon.Earcut;
class PathBase extends BaseGeom {
constructor() {
super();
this.pathData = [];
this.pathIndexes = [];
this.closePath = false;
}
updateData() {
this.pathIndexes = Earcut(this.pathData);
super.updateData();
return this;
}
webglRender(drawingContext, submitter, calcMatrix, gameObject, alpha, dx, dy) {
if (this.isFilled) {
FillPathWebGL(drawingContext, submitter, calcMatrix, gameObject, this, alpha, dx, dy);
}
if (this.isStroked) {
StrokePathWebGL(drawingContext, submitter, calcMatrix, gameObject, this, alpha, dx, dy);
}
}
canvasRender(ctx, dx, dy) {
var path = this.pathData;
var pathLength = path.length - 1;
var px1 = path[0] - dx;
var py1 = path[1] - dy;
ctx.beginPath();
ctx.moveTo(px1, py1);
if (!this.closePath) {
pathLength -= 2;
}
for (var i = 2; i < pathLength; i += 2) {
var px2 = path[i] - dx;
var py2 = path[i + 1] - dy;
ctx.lineTo(px2, py2);
}
if (this.closePath) {
ctx.closePath();
}
if (this.isFilled) {
FillStyleCanvas(ctx, this);
ctx.fill();
}
if (this.isStroked) {
LineStyleCanvas(ctx, this);
ctx.stroke();
}
}
}
var LineTo = function (x, y, pathData) {
var cnt = pathData.length;
if (cnt >= 2) {
var lastX = pathData[cnt - 2];
var lastY = pathData[cnt - 1];
if ((x === lastX) && (y === lastY)) {
return pathData;
}
}
pathData.push(x, y);
return pathData;
};
const DegToRad$3 = Phaser.Math.DegToRad;
var ArcTo = function (centerX, centerY, radiusX, radiusY, startAngle, endAngle, antiClockWise, iteration, pathData) {
// startAngle, endAngle: 0 ~ 360
if (antiClockWise && (endAngle > startAngle)) {
endAngle -= 360;
} else if (!antiClockWise && (endAngle < startAngle)) {
endAngle += 360;
}
var deltaAngle = endAngle - startAngle;
var step = DegToRad$3(deltaAngle) / iteration;
startAngle = DegToRad$3(startAngle);
for (var i = 0; i <= iteration; i++) {
var angle = startAngle + (step * i);
var x = centerX + (radiusX * Math.cos(angle));
var y = centerY + (radiusY * Math.sin(angle));
LineTo(x, y, pathData);
}
return pathData;
};
Phaser.Math.DegToRad;
var StartAt = function (x, y, pathData) {
pathData.length = 0;
if (x != null) {
pathData.push(x, y);
}
return pathData;
};
//import QuadraticBezierInterpolation from '../../utils/math/interpolation/QuadraticBezierInterpolation.js';
const QuadraticBezierInterpolation = Phaser.Math.Interpolation.QuadraticBezier;
var QuadraticBezierTo = function (cx, cy, x, y, iterations, pathData) {
var pathDataCnt = pathData.length;
var p0x = pathData[pathDataCnt - 2];
var p0y = pathData[pathDataCnt - 1];
for (var i = 1, last = iterations - 1; i <= last; i++) {
var t = i / last;
pathData.push(
QuadraticBezierInterpolation(t, p0x, cx, x),
QuadraticBezierInterpolation(t, p0y, cy, y)
);
}
return pathData;
};
// import CubicBezierInterpolation from '../../utils/math/interpolation/CubicBezierInterpolation.js';
const CubicBezierInterpolation = Phaser.Math.Interpolation.CubicBezier;
var CubicBezierCurveTo = function (cx0, cy0, cx1, cy1, x, y, iterations, pathData) {
var pathDataCnt = pathData.length;
var p0x = pathData[pathDataCnt - 2];
var p0y = pathData[pathDataCnt - 1];
for (var i = 1, last = iterations - 1; i <= last; i++) {
var t = i / last;
pathData.push(
CubicBezierInterpolation(t, p0x, cx0, cx1, x),
CubicBezierInterpolation(t, p0y, cy0, cy1, y)
);
}
return pathData;
};
//import CatmullRomInterpolation from '../../utils/math/interpolation/CatmullRomInterpolation.js';
const CatmullRomInterpolation = Phaser.Math.Interpolation.CatmullRom;
var CatmullRomTo = function (points, iterations, pathData) {
var pathDataCnt = pathData.length;
var p0x = pathData[pathDataCnt - 2];
var p0y = pathData[pathDataCnt - 1];
var xList = [p0x];
var yList = [p0y];
for (var i = 0, cnt = points.length; i < cnt; i += 2) {
xList.push(points[i]);
yList.push(points[i + 1]);
}
for (var i = 1, last = iterations - 1; i <= last; i++) {
var t = i / last;
pathData.push(
CatmullRomInterpolation(xList, t),
CatmullRomInterpolation(yList, t)
);
}
return pathData;
};
var DuplicateLast = function (pathData) {
var len = pathData.length;
if (len < 2) {
return pathData;
}
var lastX = pathData[len - 2];
var lastY = pathData[len - 1];
pathData.push(lastX);
pathData.push(lastY);
return pathData;
};
var AddPathMethods = {
clear() {
this.start();
return this;
},
start() {
this.startAt();
return this;
},
startAt(x, y) {
this.restorePathData();
this.accumulationLengths = undefined;
StartAt(x, y, this.pathData);
this.firstPointX = x;
this.firstPointY = y;
this.lastPointX = x;
this.lastPointY = y;
return this;
},
lineTo(x, y, relative) {
if (relative === undefined) {
relative = false;
}
if (relative) {
x += this.lastPointX;
y += this.lastPointY;
}
LineTo(x, y, this.pathData);
this.lastPointX = x;
this.lastPointY = y;
return this;
},
verticalLineTo(x, relative) {
this.lineTo(x, this.lastPointY, relative);
return this;
},
horizontalLineTo(y, relative) {
this.lineTo(this.lastPointX, y, relative);
return this;
},
ellipticalArc(centerX, centerY, radiusX, radiusY, startAngle, endAngle, anticlockwise) {
if (anticlockwise === undefined) {
anticlockwise = false;
}
ArcTo(
centerX, centerY,
radiusX, radiusY,
startAngle, endAngle, anticlockwise,
this.iterations,
this.pathData
);
this.lastPointX = this.pathData[this.pathData.length - 2];
this.lastPointY = this.pathData[this.pathData.length - 1];
return this;
},
arc(centerX, centerY, radius, startAngle, endAngle, anticlockwise) {
this.ellipticalArc(centerX, centerY, radius, radius, startAngle, endAngle, anticlockwise);
return this;
},
quadraticBezierTo(cx, cy, x, y) {
QuadraticBezierTo(
cx, cy, x, y,
this.iterations,
this.pathData
);
this.lastPointX = x;
this.lastPointY = y;
return this;
},
cubicBezierTo(cx0, cy0, cx1, cy1, x, y) {
CubicBezierCurveTo(
cx0, cy0, cx1, cy1, x, y,
this.iterations,
this.pathData
);
this.lastPointX = x;
this.lastPointY = y;
return this;
},
catmullRomTo(...points) {
CatmullRomTo(
points,
this.iterations,
this.pathData
);
this.lastPointX = points[points.length-2];
this.lastPointY = points[points.length-1];
return this;
},
close() {
// Line to first point
var startX = this.pathData[0],
startY = this.pathData[1];
if ((startX !== this.lastPointX) || (startY !== this.lastPointY)) {
this.lineTo(startX, startY);
}
this.closePath = true;
return this;
},
end() {
DuplicateLast(this.pathData);
return this;
},
};
//import PointRotateAround from '../../utils/math/RotateAround.js';
const PointRotateAround = Phaser.Math.RotateAround;
var RotateAround = function (centerX, centerY, angle, pathData) {
var point = { x: 0, y: 0 };
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
point.x = pathData[i];
point.y = pathData[i + 1];
PointRotateAround(point, centerX, centerY, angle);
pathData[i] = point.x;
pathData[i + 1] = point.y;
}
return pathData;
};
var Scale = function (centerX, centerY, scaleX, scaleY, pathData) {
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
var x = pathData[i] - centerX;
var y = pathData[i + 1] - centerY;
x *= scaleX;
y *= scaleY;
pathData[i] = x + centerX;
pathData[i + 1] = y + centerY;
}
return pathData;
};
var Offset = function (x, y, pathData) {
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
pathData[i] += x;
pathData[i + 1] += y;
}
return pathData;
};
const DegToRad$2 = Phaser.Math.DegToRad;
Phaser.Math.RotateAround;
var TransformPointsMethods = {
rotateAround(centerX, centerY, angle) {
if (this.pathData.length === 0) {
return this;
}
angle = DegToRad$2(angle);
RotateAround(centerX, centerY, angle, this.pathData);
var pathDataCnt = this.pathData.length;
this.lastPointX = this.pathData[pathDataCnt - 2];
this.lastPointY = this.pathData[pathDataCnt - 1];
return this;
},
scale(centerX, centerY, scaleX, scaleY) {
if (this.pathData.length === 0) {
return this;
}
Scale(centerX, centerY, scaleX, scaleY, this.pathData);
this.lastPointX = this.pathData[pathDataCnt - 2];
this.lastPointY = this.pathData[pathDataCnt - 1];
return this;
},
offset(x, y) {
Offset(x, y, this.pathData);
return this;
}
};
var Copy = function (dest, src, startIdx, endIdx) {
if (startIdx === undefined) {
startIdx = 0;
} if (endIdx === undefined) {
endIdx = src.length;
}
dest.length = endIdx - startIdx;
for (var i = 0, len = dest.length; i < len; i++) {
dest[i] = src[i + startIdx];
}
return dest;
};
var SavePathDataMethods = {
savePathData() {
if (this.pathDataSaved) {
return this;
}
this.pathDataSave = [...this.pathData];
this.pathData.length = 0;
this.pathDataSaved = true;
return this;
},
restorePathData() {
if (!this.pathDataSaved) {
return this;
}
Copy(this.pathData, this.pathDataSave);
this.pathDataSave = undefined;
this.pathDataSaved = false;
return this;
},
};
const DistanceBetween = Phaser.Math.Distance.Between;
const Wrap = Phaser.Math.Wrap;
const Linear$2 = Phaser.Math.Linear;
var AppendFromPathSegment = function (srcPathData, accumulationLengths, startT, endT, destPathData) {
if (endT === undefined) {
endT = startT;
startT = 0;
}
startT = WrapT(startT);
endT = WrapT(endT);
if (startT === endT) {
return;
}
var totalPathLength = accumulationLengths[accumulationLengths.length - 1];
var startL = totalPathLength * startT;
var endL = totalPathLength * endT;
if (startT < endT) {
AddPathSegment(srcPathData, accumulationLengths, startL, endL, destPathData);
} else {
AddPathSegment(srcPathData, accumulationLengths, startL, totalPathLength, destPathData);
AddPathSegment(srcPathData, accumulationLengths, 0, endL, destPathData);
}
DuplicateLast(destPathData);
};
var AddPathSegment = function (srcPathData, accumulationLengths, startL, endL, destPathData) {
var skipState = (startL > 0);
for (var i = 0, cnt = accumulationLengths.length; i < cnt; i++) {
var pIdx = i * 2;
var d = accumulationLengths[i];
if (skipState) {
if (d < startL) {
continue;
} else if (d == startL) {
skipState = false;
} else { // d > startL
var deltaD = d - accumulationLengths[i - 1];
var t = 1 - ((d - startL) / deltaD);
destPathData.push(GetInterpolation(srcPathData, pIdx - 2, pIdx, t));
destPathData.push(GetInterpolation(srcPathData, pIdx - 1, pIdx + 1, t));
skipState = false;
}
}
if (d <= endL) {
destPathData.push(srcPathData[pIdx]);
destPathData.push(srcPathData[pIdx + 1]);
if (d === endL) {
break;
}
} else { // d > endL
var deltaD = d - accumulationLengths[i - 1];
var t = 1 - ((d - endL) / deltaD);
destPathData.push(GetInterpolation(srcPathData, pIdx - 2, pIdx, t));
destPathData.push(GetInterpolation(srcPathData, pIdx - 1, pIdx + 1, t));
break;
}
}
};
var GetInterpolation = function (pathData, i0, i1, t) {
var p0 = pathData[i0], p1 = pathData[i1];
return Linear$2(p0, p1, t);
};
var WrapT = function (t) {
if (t === 0) {
return 0;
} else if ((t % 1) === 0) {
return 1;
}
return Wrap(t, 0, 1);
};
var PathSegmentMethods = {
updateAccumulationLengths() {
if (this.accumulationLengths == null) {
this.accumulationLengths = [];
} else if (this.accumulationLengths.length === (this.pathData.length / 2)) {
return this;
}
var accumulationLengths = this.accumulationLengths;
var pathData = this.pathData;
var prevX, prevY, x, y;
var d, accumulationLength = 0;
for (var i = 0, cnt = pathData.length; i < cnt; i += 2) {
x = pathData[i];
y = pathData[i + 1];
d = (prevX === undefined) ? 0 : DistanceBetween(prevX, prevY, x, y);
accumulationLength += d;
accumulationLengths.push(accumulationLength);
prevX = x;
prevY = y;
}
this.totalPathLength = accumulationLength;
return this;
},
setDisplayPathSegment(startT, endT) {
if (!this.pathDataSaved) {
this.updateAccumulationLengths();
this.savePathData();
}
this.pathData.length = 0;
AppendFromPathSegment(this.pathDataSave, this.accumulationLengths, startT, endT, this.pathData);
return this;
},
appendFromPathSegment(src, startT, endT) {
if (startT === undefined) {
this.pathData.push(...src.pathData);
} else {
src.updateAccumulationLengths();
AppendFromPathSegment(src.pathData, src.accumulationLengths, startT, endT, this.pathData);
}
this.firstPointX = this.pathData[0];
this.firstPointY = this.pathData[1];
this.lastPointX = this.pathData[this.pathData.length - 2];
this.lastPointY = this.pathData[this.pathData.length - 1];
return this;
},
};
var GraphicsMethods = {
draw(graphics, isFill, isStroke) {
var points = this.toPoints();
if (isFill) {
graphics.fillPoints(points, this.closePath, this.closePath);
}
if (isStroke) {
graphics.strokePoints(points, this.closePath, this.closePath);
}
return this;
}
};
var ToPoints = function (pathData, points) {
if (points === undefined) {
points = [];
}
for (var i = 0, cnt = pathData.length - 1; i < cnt; i += 2) {
points.push({
x: pathData[i],
y: pathData[i + 1]
});
}
return points;
};
//import Polygon from '../../utils/geom/polygon/Polygon.js';
const Polygon = Phaser.Geom.Polygon;
var ToPolygon = function (pathData, polygon) {
if (polygon === undefined) {
polygon = new Polygon();
}
polygon.setTo(pathData);
return polygon;
};
class PathDataBuilder {
constructor(pathData) {
if (pathData === undefined) {
pathData = [];
}
this.pathData = pathData;
this.closePath = false;
this.setIterations(32);
this.firstPointX = undefined;
this.firstPointY = undefined;
this.lastPointX = undefined;
this.lastPointY = undefined;
this.accumulationLengths = undefined;
}
setIterations(iterations) {
this.iterations = iterations;
return this;
}
toPoints() {
return ToPoints(this.pathData);
}
toPolygon(polygon) {
return ToPolygon(this.pathData, polygon);
}
}
Object.assign(
PathDataBuilder.prototype,
AddPathMethods,
TransformPointsMethods,
SavePathDataMethods,
PathSegmentMethods,
GraphicsMethods,
);
class Lines extends PathBase {
constructor() {
super();
this.builder = new PathDataBuilder(this.pathData);
}
get iterations() {
return this.builder.iterations;
}
set iterations(value) {
this.dirty = this.dirty || (this.builder.iterations !== value);
this.builder.setIterations(value);
}
setIterations(iterations) {
this.iterations = iterations;
return this;
}
get lastPointX() {
return this.builder.lastPointX;
}
get lastPointY() {
return this.builder.lastPointY;
}
start() {
this.builder.start();
this.dirty = true;
return this;
}
startAt(x, y) {
this.builder.startAt(x, y);
this.dirty = true;
return this;
}
lineTo(x, y, relative) {
this.builder.lineTo(x, y, relative);
this.dirty = true;
return this;
}
verticalLineTo(x, relative) {
this.builder.verticalLineTo(x, relative);
this.dirty = true;
return this;
}
horizontalLineTo(y, relative) {
this.builder.horizontalLineTo(y, relative);
this.dirty = true;
return this;
}
ellipticalArc(centerX, centerY, radiusX, radiusY, startAngle, endAngle, anticlockwise) {
this.builder.ellipticalArc(centerX, centerY, radiusX, radiusY, startAngle, endAngle, anticlockwise);
this.dirty = true;
return this;
}
arc(centerX, centerY, radius, startAngle, endAngle, anticlockwise) {
this.builder.arc(centerX, centerY, radius, startAngle, endAngle, anticlockwise);
this.dirty = true;
return this;
}
quadraticBezierTo(cx, cy, x, y) {
this.builder.quadraticBezierTo(cx, cy, x, y);
this.dirty = true;
return this;
}
cubicBezierTo(cx0, cy0, cx1, cy1, x, y) {
this.builder.cubicBezierTo(cx0, cy0, cx1, cy1, x, y);
this.dirty = true;
return this;
}
catmullRomTo(...points) {
this.builder.catmullRomTo(...points);
this.dirty = true;
return this;
}
close() {
this.builder.close();
this.closePath = this.builder.closePath;
this.dirty = true;
return this;
}
end() {
this.builder.end();
this.dirty = true;
return this;
}
rotateAround(centerX, centerY, angle) {
this.builder.rotateAround(centerX, centerY, angle);
this.dirty = true;
return this;
}
scale(centerX, centerY, scaleX, scaleY) {
this.builder.scale(centerX, centerY, scaleX, scaleY);
this.dirty = true;
return this;
}
offset(x, y) {
this.builder.offset(x, y);
this.dirty = true;
return this;
}
toPolygon(polygon) {
return this.builder.toPolygon(polygon);
}
appendPathFrom(src, startT, endT) {
this.builder.appendFromPathSegment(src.builder, startT, endT);
return this;
}
copyPathFrom(src, startT, endT) {
this.builder.clear().appendFromPathSegment(src.builder, startT, endT);
return this;
}
setDisplayPathSegment(startT, endT) {
this.builder.setDisplayPathSegment(startT, endT);
return this;
}
}
Phaser.Renderer.WebGL.Utils;
Phaser.Utils.Objects.GetValue;
Phaser.Renderer.WebGL.Utils;
Phaser.Math.Wrap;
const Linear$1 = Phaser.Math.Linear;
var DrawFitTriangle = function () {
var triangle = this.getShape('triangle');
var padding = this.padding;
var right = this.width - padding.right;
var left = 0 + padding.left;
var bottom = this.height - padding.bottom;
var top = 0 + padding.top;
var centerX = (left + right) / 2;
var centerY = (top + bottom) / 2;
var points = {
0: { // right
a: { x: left, y: top }, b: { x: right, y: centerY }, c: { x: left, y: bottom },
},
1: { // down
a: { x: left, y: top }, b: { x: centerX, y: bottom }, c: { x: right, y: top },
},
2: { // left
a: { x: right, y: top }, b: { x: left, y: centerY }, c: { x: right, y: bottom },
},
3: { // up
a: { x: left, y: bottom }, b: { x: centerX, y: top }, c: { x: right, y: bottom },
}
};
var pax, pay, pbx, pby, pcx, pcy;
if (this.previousDirection === undefined) {
var currentTrianglePoints = points[this.direction];
var pa = currentTrianglePoints.a,
pb = currentTrianglePoints.b,
pc = currentTrianglePoints.c;
pax = pa.x; pay = pa.y;
pbx = pb.x; pby = pb.y;
pcx = pc.x; pcy = pc.y;
} else {
var p0 = points[this.previousDirection];
var p1 = points[this.direction];
var t = this.easeDirectionProgress;
pax = Linear$1(p0.a.x, p1.a.x, t);
pay = Linear$1(p0.a.y, p1.a.y, t);
pbx = Linear$1(p0.b.x, p1.b.x, t);
pby = Linear$1(p0.b.y, p1.b.y, t);
pcx = Linear$1(p0.c.x, p1.c.x, t);
pcy = Linear$1(p0.c.y, p1.c.y, t);
}
triangle.startAt(pax, pay).lineTo(pbx, pby).lineTo(pcx, pcy);
if (!this.arrowOnly) {
triangle.close();
} else {
triangle.end();
}
};
const DegToRad$1 = Phaser.Math.DegToRad;
const Rad120 = DegToRad$1(120);
var DrawCircleVerticesTriangle = function (triangle) {
var triangle = this.getShape('triangle');
var centerX = this.width / 2,
centerY = this.height / 2;
var radius = Math.min(centerX, centerY) * this.radius,
verticeRotation = this.verticeRotation;
triangle
.startAt(
centerX + radius * Math.cos(verticeRotation + Rad120),
centerY + radius * Math.sin(verticeRotation + Rad120)
)
.lineTo(
centerX + radius * Math.cos(verticeRotation),
centerY + radius * Math.sin(verticeRotation)
)
.lineTo(
centerX + radius * Math.cos(verticeRotation - Rad120),
centerY + radius * Math.sin(verticeRotation - Rad120)
);
if (!this.arrowOnly) {
triangle.close();
} else {
triangle.end();
}
};
var ShapesUpdateMethods = {
buildShapes() {
this
.addShape(new Lines().setName('triangle'));
},
updateShapes() {
// Set style
var triangle = this.getShape('triangle');
if (!this.arrowOnly) {
triangle
.fillStyle(this.fillColor, this.fillAlpha)
.lineStyle(this.lineWidth, this.strokeColor, this.strokeAlpha);
} else {
triangle
.fillStyle()
.lineStyle(this.lineWidth, this.strokeColor, this.strokeAlpha);
}
// Set points
if (this.shapeMode === 0) {
DrawFitTriangle.call(this);
} else {
DrawCircleVerticesTriangle.call(this);
}
}
};
var EventEmitterMethods = {
setEventEmitter(eventEmitter, EventEmitterClass) {
if (EventEmitterClass === undefined) {
EventEmitterClass = Phaser.Events.EventEmitter; // Use built-in EventEmitter class by default
}
this._privateEE = (eventEmitter === true) || (eventEmitter === undefined);
this._eventEmitter = (this._privateEE) ? (new EventEmitterClass()) : eventEmitter;
return this;
},
destroyEventEmitter() {
if (this._eventEmitter && this._privateEE) {
this._eventEmitter.shutdown();
}
return this;
},
getEventEmitter() {
return this._eventEmitter;
},
on() {
if (this._eventEmitter) {
this._eventEmitter.on.apply(this._eventEmitter, arguments);
}
return this;
},
once() {
if (this._eventEmitter) {
this._eventEmitter.once.apply(this._eventEmitter, arguments);
}
return this;
},
off() {
if (this._eventEmitter) {
this._eventEmitter.off.apply(this._eventEmitter, arguments);
}
return this;
},
emit(event) {
if (this._eventEmitter && event) {
this._eventEmitter.emit.apply(this._eventEmitter, arguments);
}
return this;
},
addListener() {
if (this._eventEmitter) {
this._eventEmitter.addListener.apply(this._eventEmitter, arguments);
}
return this;
},
removeListener() {
if (this._eventEmitter) {
this._eventEmitter.removeListener.apply(this._eventEmitter, arguments);
}
return this;
},
removeAllListeners() {
if (this._eventEmitter) {
this._eventEmitter.removeAllListeners.apply(this._eventEmitter, arguments);
}
return this;
},
listenerCount() {
if (this._eventEmitter) {
return this._eventEmitter.listenerCount.apply(this._eventEmitter, arguments);
}
return 0;
},
listeners() {
if (this._eventEmitter) {
return this._eventEmitter.listeners.apply(this._eventEmitter, arguments);
}
return [];
},
eventNames() {
if (this._eventEmitter) {
return this._eventEmitter.eventNames.apply(this._eventEmitter, arguments);
}
return [];
},
};
const SceneClass = Phaser.Scene;
var IsSceneObject = function (object) {
return (object instanceof SceneClass);
};
var GetSceneObject = function (object) {
if ((object == null) || (typeof (object) !== 'object')) {
return null;
} else if (IsSceneObject(object)) { // object = scene
return object;
} else if (object.scene && IsSceneObject(object.scene)) { // object = game object
return object.scene;
} else if (object.parent && object.parent.scene && IsSceneObject(object.parent.scene)) { // parent = bob object
return object.parent.scene;
} else {
return null;
}
};
const GameClass = Phaser.Game;
var IsGame = function (object) {
return (object instanceof GameClass);
};
var GetGame = function (object) {
if ((object == null) || (typeof (object) !== 'object')) {
return null;
} else if (IsGame(object)) {
return object;
} else if (IsGame(object.game)) {
return object.game;
} else if (IsSceneObject(object)) { // object = scene object
return object.sys.game;
} else if (IsSceneObject(object.scene)) { // object = game object
return object.scene.sys.game;
}
};
const GetValue$6 = Phaser.Utils.Objects.GetValue;
class ComponentBase {
constructor(parent, config) {
this.setParent(parent); // gameObject, scene, or game
this.isShutdown = false;
// Event emitter, default is private event emitter
this.setEventEmitter(GetValue$6(config, 'eventEmitter', true));
// Register callback of parent destroy event, also see `shutdown` method
if (this.parent) {
if (this.parent === this.scene) { // parent is a scene
this.scene.sys.events.once('shutdown', this.onEnvDestroy, this);
} else if (this.parent === this.game) { // parent is game
this.game.events.once('shutdown', this.onEnvDestroy, this);
} else if (this.parent.once) { // parent is game object or something else
this.parent.once('destroy', this.onParentDestroy, this);
}
// bob object does not have event emitter
}
}
shutdown(fromScene) {
// Already shutdown
if (this.isShutdown) {
return;
}
// parent might not be shutdown yet
if (this.parent) {
if (this.parent === this.scene) { // parent is a scene
this.scene.sys