phaser
Version:
A fast, free and fun HTML5 Game Framework for Desktop and Mobile web browsers from the team at Phaser Studio Inc.
1,633 lines (1,571 loc) • 2.1 MB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ "../../../node_modules/eventemitter3/index.js":
/*!****************************************************!*\
!*** ../../../node_modules/eventemitter3/index.js ***!
\****************************************************/
/***/ ((module) => {
"use strict";
var has = Object.prototype.hasOwnProperty
, prefix = '~';
/**
* Constructor to create a storage for our `EE` objects.
* An `Events` instance is a plain object whose properties are event names.
*
* @constructor
* @private
*/
function Events() {}
//
// We try to not inherit from `Object.prototype`. In some engines creating an
// instance in this way is faster than calling `Object.create(null)` directly.
// If `Object.create(null)` is not supported we prefix the event names with a
// character to make sure that the built-in object properties are not
// overridden or used as an attack vector.
//
if (Object.create) {
Events.prototype = Object.create(null);
//
// This hack is needed because the `__proto__` property is still inherited in
// some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
//
if (!new Events().__proto__) prefix = false;
}
/**
* Representation of a single event listener.
*
* @param {Function} fn The listener function.
* @param {*} context The context to invoke the listener with.
* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
* @constructor
* @private
*/
function EE(fn, context, once) {
this.fn = fn;
this.context = context;
this.once = once || false;
}
/**
* Add a listener for a given event.
*
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} context The context to invoke the listener with.
* @param {Boolean} once Specify if the listener is a one-time listener.
* @returns {EventEmitter}
* @private
*/
function addListener(emitter, event, fn, context, once) {
if (typeof fn !== 'function') {
throw new TypeError('The listener must be a function');
}
var listener = new EE(fn, context || emitter, once)
, evt = prefix ? prefix + event : event;
if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
else emitter._events[evt] = [emitter._events[evt], listener];
return emitter;
}
/**
* Clear event by name.
*
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
* @param {(String|Symbol)} evt The Event name.
* @private
*/
function clearEvent(emitter, evt) {
if (--emitter._eventsCount === 0) emitter._events = new Events();
else delete emitter._events[evt];
}
/**
* Minimal `EventEmitter` interface that is molded against the Node.js
* `EventEmitter` interface.
*
* @constructor
* @public
*/
function EventEmitter() {
this._events = new Events();
this._eventsCount = 0;
}
/**
* Return an array listing the events for which the emitter has registered
* listeners.
*
* @returns {Array}
* @public
*/
EventEmitter.prototype.eventNames = function eventNames() {
var names = []
, events
, name;
if (this._eventsCount === 0) return names;
for (name in (events = this._events)) {
if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
}
if (Object.getOwnPropertySymbols) {
return names.concat(Object.getOwnPropertySymbols(events));
}
return names;
};
/**
* Return the listeners registered for a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Array} The registered listeners.
* @public
*/
EventEmitter.prototype.listeners = function listeners(event) {
var evt = prefix ? prefix + event : event
, handlers = this._events[evt];
if (!handlers) return [];
if (handlers.fn) return [handlers.fn];
for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
ee[i] = handlers[i].fn;
}
return ee;
};
/**
* Return the number of listeners listening to a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Number} The number of listeners.
* @public
*/
EventEmitter.prototype.listenerCount = function listenerCount(event) {
var evt = prefix ? prefix + event : event
, listeners = this._events[evt];
if (!listeners) return 0;
if (listeners.fn) return 1;
return listeners.length;
};
/**
* Calls each of the listeners registered for a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Boolean} `true` if the event had listeners, else `false`.
* @public
*/
EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return false;
var listeners = this._events[evt]
, len = arguments.length
, args
, i;
if (listeners.fn) {
if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
switch (len) {
case 1: return listeners.fn.call(listeners.context), true;
case 2: return listeners.fn.call(listeners.context, a1), true;
case 3: return listeners.fn.call(listeners.context, a1, a2), true;
case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
}
for (i = 1, args = new Array(len -1); i < len; i++) {
args[i - 1] = arguments[i];
}
listeners.fn.apply(listeners.context, args);
} else {
var length = listeners.length
, j;
for (i = 0; i < length; i++) {
if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
switch (len) {
case 1: listeners[i].fn.call(listeners[i].context); break;
case 2: listeners[i].fn.call(listeners[i].context, a1); break;
case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
default:
if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
args[j - 1] = arguments[j];
}
listeners[i].fn.apply(listeners[i].context, args);
}
}
}
return true;
};
/**
* Add a listener for a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.on = function on(event, fn, context) {
return addListener(this, event, fn, context, false);
};
/**
* Add a one-time listener for a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.once = function once(event, fn, context) {
return addListener(this, event, fn, context, true);
};
/**
* Remove the listeners of a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn Only remove the listeners that match this function.
* @param {*} context Only remove the listeners that have this context.
* @param {Boolean} once Only remove one-time listeners.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return this;
if (!fn) {
clearEvent(this, evt);
return this;
}
var listeners = this._events[evt];
if (listeners.fn) {
if (
listeners.fn === fn &&
(!once || listeners.once) &&
(!context || listeners.context === context)
) {
clearEvent(this, evt);
}
} else {
for (var i = 0, events = [], length = listeners.length; i < length; i++) {
if (
listeners[i].fn !== fn ||
(once && !listeners[i].once) ||
(context && listeners[i].context !== context)
) {
events.push(listeners[i]);
}
}
//
// Reset the array, or remove it completely if we have no more listeners.
//
if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
else clearEvent(this, evt);
}
return this;
};
/**
* Remove all listeners, or those of the specified event.
*
* @param {(String|Symbol)} [event] The event name.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
var evt;
if (event) {
evt = prefix ? prefix + event : event;
if (this._events[evt]) clearEvent(this, evt);
} else {
this._events = new Events();
this._eventsCount = 0;
}
return this;
};
//
// Alias methods names because people roll like that.
//
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.addListener = EventEmitter.prototype.on;
//
// Expose the prefix.
//
EventEmitter.prefixed = prefix;
//
// Allow `EventEmitter` to be imported as module namespace.
//
EventEmitter.EventEmitter = EventEmitter;
//
// Expose the module.
//
if (true) {
module.exports = EventEmitter;
}
/***/ }),
/***/ "./runtimes/spine-canvas.js":
/*!**********************************!*\
!*** ./runtimes/spine-canvas.js ***!
\**********************************/
/***/ ((module) => {
/*** IMPORTS FROM imports-loader ***/
(function() {
"use strict";
var spine = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// spine-canvas/src/index.ts
var src_exports = {};
__export(src_exports, {
AlphaTimeline: () => AlphaTimeline,
Animation: () => Animation,
AnimationState: () => AnimationState,
AnimationStateAdapter: () => AnimationStateAdapter,
AnimationStateData: () => AnimationStateData,
AssetManager: () => AssetManager,
AssetManagerBase: () => AssetManagerBase,
AtlasAttachmentLoader: () => AtlasAttachmentLoader,
Attachment: () => Attachment,
AttachmentTimeline: () => AttachmentTimeline,
BinaryInput: () => BinaryInput,
BlendMode: () => BlendMode,
Bone: () => Bone,
BoneData: () => BoneData,
BoundingBoxAttachment: () => BoundingBoxAttachment,
CURRENT: () => CURRENT,
CanvasTexture: () => CanvasTexture,
ClippingAttachment: () => ClippingAttachment,
Color: () => Color,
ConstraintData: () => ConstraintData,
CurveTimeline: () => CurveTimeline,
CurveTimeline1: () => CurveTimeline1,
CurveTimeline2: () => CurveTimeline2,
DebugUtils: () => DebugUtils,
DeformTimeline: () => DeformTimeline,
Downloader: () => Downloader,
DrawOrderTimeline: () => DrawOrderTimeline,
Event: () => Event,
EventData: () => EventData,
EventQueue: () => EventQueue,
EventTimeline: () => EventTimeline,
EventType: () => EventType,
FIRST: () => FIRST,
FakeTexture: () => FakeTexture,
HOLD_FIRST: () => HOLD_FIRST,
HOLD_MIX: () => HOLD_MIX,
HOLD_SUBSEQUENT: () => HOLD_SUBSEQUENT,
IkConstraint: () => IkConstraint,
IkConstraintData: () => IkConstraintData,
IkConstraintTimeline: () => IkConstraintTimeline,
IntSet: () => IntSet,
Interpolation: () => Interpolation,
MathUtils: () => MathUtils,
MeshAttachment: () => MeshAttachment,
MixBlend: () => MixBlend,
MixDirection: () => MixDirection,
PathAttachment: () => PathAttachment,
PathConstraint: () => PathConstraint,
PathConstraintData: () => PathConstraintData,
PathConstraintMixTimeline: () => PathConstraintMixTimeline,
PathConstraintPositionTimeline: () => PathConstraintPositionTimeline,
PathConstraintSpacingTimeline: () => PathConstraintSpacingTimeline,
PointAttachment: () => PointAttachment,
Pool: () => Pool,
PositionMode: () => PositionMode,
Pow: () => Pow,
PowOut: () => PowOut,
RGB2Timeline: () => RGB2Timeline,
RGBA2Timeline: () => RGBA2Timeline,
RGBATimeline: () => RGBATimeline,
RGBTimeline: () => RGBTimeline,
RegionAttachment: () => RegionAttachment,
RotateMode: () => RotateMode,
RotateTimeline: () => RotateTimeline,
SETUP: () => SETUP,
SUBSEQUENT: () => SUBSEQUENT,
ScaleTimeline: () => ScaleTimeline,
ScaleXTimeline: () => ScaleXTimeline,
ScaleYTimeline: () => ScaleYTimeline,
SequenceTimeline: () => SequenceTimeline,
ShearTimeline: () => ShearTimeline,
ShearXTimeline: () => ShearXTimeline,
ShearYTimeline: () => ShearYTimeline,
Skeleton: () => Skeleton,
SkeletonBinary: () => SkeletonBinary,
SkeletonBounds: () => SkeletonBounds,
SkeletonClipping: () => SkeletonClipping,
SkeletonData: () => SkeletonData,
SkeletonJson: () => SkeletonJson,
SkeletonRenderer: () => SkeletonRenderer,
Skin: () => Skin,
SkinEntry: () => SkinEntry,
Slot: () => Slot,
SlotData: () => SlotData,
SpacingMode: () => SpacingMode,
StringSet: () => StringSet,
Texture: () => Texture,
TextureAtlas: () => TextureAtlas,
TextureAtlasPage: () => TextureAtlasPage,
TextureAtlasRegion: () => TextureAtlasRegion,
TextureFilter: () => TextureFilter,
TextureRegion: () => TextureRegion,
TextureWrap: () => TextureWrap,
TimeKeeper: () => TimeKeeper,
Timeline: () => Timeline,
TrackEntry: () => TrackEntry,
TransformConstraint: () => TransformConstraint,
TransformConstraintData: () => TransformConstraintData,
TransformConstraintTimeline: () => TransformConstraintTimeline,
TransformMode: () => TransformMode,
TranslateTimeline: () => TranslateTimeline,
TranslateXTimeline: () => TranslateXTimeline,
TranslateYTimeline: () => TranslateYTimeline,
Triangulator: () => Triangulator,
Utils: () => Utils,
Vector2: () => Vector2,
VertexAttachment: () => VertexAttachment,
WindowedMean: () => WindowedMean
});
// spine-core/src/Utils.ts
var IntSet = class {
constructor() {
this.array = new Array();
}
add(value) {
let contains = this.contains(value);
this.array[value | 0] = value | 0;
return !contains;
}
contains(value) {
return this.array[value | 0] != void 0;
}
remove(value) {
this.array[value | 0] = void 0;
}
clear() {
this.array.length = 0;
}
};
var StringSet = class {
constructor() {
this.entries = {};
this.size = 0;
}
add(value) {
let contains = this.entries[value];
this.entries[value] = true;
if (!contains) {
this.size++;
return true;
}
return false;
}
addAll(values) {
let oldSize = this.size;
for (var i = 0, n = values.length; i < n; i++)
this.add(values[i]);
return oldSize != this.size;
}
contains(value) {
return this.entries[value];
}
clear() {
this.entries = {};
this.size = 0;
}
};
var _Color = class {
constructor(r = 0, g = 0, b = 0, a = 0) {
this.r = r;
this.g = g;
this.b = b;
this.a = a;
}
set(r, g, b, a) {
this.r = r;
this.g = g;
this.b = b;
this.a = a;
return this.clamp();
}
setFromColor(c) {
this.r = c.r;
this.g = c.g;
this.b = c.b;
this.a = c.a;
return this;
}
setFromString(hex) {
hex = hex.charAt(0) == "#" ? hex.substr(1) : hex;
this.r = parseInt(hex.substr(0, 2), 16) / 255;
this.g = parseInt(hex.substr(2, 2), 16) / 255;
this.b = parseInt(hex.substr(4, 2), 16) / 255;
this.a = hex.length != 8 ? 1 : parseInt(hex.substr(6, 2), 16) / 255;
return this;
}
add(r, g, b, a) {
this.r += r;
this.g += g;
this.b += b;
this.a += a;
return this.clamp();
}
clamp() {
if (this.r < 0)
this.r = 0;
else if (this.r > 1)
this.r = 1;
if (this.g < 0)
this.g = 0;
else if (this.g > 1)
this.g = 1;
if (this.b < 0)
this.b = 0;
else if (this.b > 1)
this.b = 1;
if (this.a < 0)
this.a = 0;
else if (this.a > 1)
this.a = 1;
return this;
}
static rgba8888ToColor(color, value) {
color.r = ((value & 4278190080) >>> 24) / 255;
color.g = ((value & 16711680) >>> 16) / 255;
color.b = ((value & 65280) >>> 8) / 255;
color.a = (value & 255) / 255;
}
static rgb888ToColor(color, value) {
color.r = ((value & 16711680) >>> 16) / 255;
color.g = ((value & 65280) >>> 8) / 255;
color.b = (value & 255) / 255;
}
static fromString(hex) {
return new _Color().setFromString(hex);
}
};
var Color = _Color;
Color.WHITE = new _Color(1, 1, 1, 1);
Color.RED = new _Color(1, 0, 0, 1);
Color.GREEN = new _Color(0, 1, 0, 1);
Color.BLUE = new _Color(0, 0, 1, 1);
Color.MAGENTA = new _Color(1, 0, 1, 1);
var _MathUtils = class {
static clamp(value, min, max) {
if (value < min)
return min;
if (value > max)
return max;
return value;
}
static cosDeg(degrees) {
return Math.cos(degrees * _MathUtils.degRad);
}
static sinDeg(degrees) {
return Math.sin(degrees * _MathUtils.degRad);
}
static signum(value) {
return value > 0 ? 1 : value < 0 ? -1 : 0;
}
static toInt(x) {
return x > 0 ? Math.floor(x) : Math.ceil(x);
}
static cbrt(x) {
let y = Math.pow(Math.abs(x), 1 / 3);
return x < 0 ? -y : y;
}
static randomTriangular(min, max) {
return _MathUtils.randomTriangularWith(min, max, (min + max) * 0.5);
}
static randomTriangularWith(min, max, mode) {
let u = Math.random();
let d = max - min;
if (u <= (mode - min) / d)
return min + Math.sqrt(u * d * (mode - min));
return max - Math.sqrt((1 - u) * d * (max - mode));
}
static isPowerOfTwo(value) {
return value && (value & value - 1) === 0;
}
};
var MathUtils = _MathUtils;
MathUtils.PI = 3.1415927;
MathUtils.PI2 = _MathUtils.PI * 2;
MathUtils.radiansToDegrees = 180 / _MathUtils.PI;
MathUtils.radDeg = _MathUtils.radiansToDegrees;
MathUtils.degreesToRadians = _MathUtils.PI / 180;
MathUtils.degRad = _MathUtils.degreesToRadians;
var Interpolation = class {
apply(start, end, a) {
return start + (end - start) * this.applyInternal(a);
}
};
var Pow = class extends Interpolation {
constructor(power) {
super();
this.power = 2;
this.power = power;
}
applyInternal(a) {
if (a <= 0.5)
return Math.pow(a * 2, this.power) / 2;
return Math.pow((a - 1) * 2, this.power) / (this.power % 2 == 0 ? -2 : 2) + 1;
}
};
var PowOut = class extends Pow {
constructor(power) {
super(power);
}
applyInternal(a) {
return Math.pow(a - 1, this.power) * (this.power % 2 == 0 ? -1 : 1) + 1;
}
};
var _Utils = class {
static arrayCopy(source, sourceStart, dest, destStart, numElements) {
for (let i = sourceStart, j = destStart; i < sourceStart + numElements; i++, j++) {
dest[j] = source[i];
}
}
static arrayFill(array, fromIndex, toIndex, value) {
for (let i = fromIndex; i < toIndex; i++)
array[i] = value;
}
static setArraySize(array, size, value = 0) {
let oldSize = array.length;
if (oldSize == size)
return array;
array.length = size;
if (oldSize < size) {
for (let i = oldSize; i < size; i++)
array[i] = value;
}
return array;
}
static ensureArrayCapacity(array, size, value = 0) {
if (array.length >= size)
return array;
return _Utils.setArraySize(array, size, value);
}
static newArray(size, defaultValue) {
let array = new Array(size);
for (let i = 0; i < size; i++)
array[i] = defaultValue;
return array;
}
static newFloatArray(size) {
if (_Utils.SUPPORTS_TYPED_ARRAYS)
return new Float32Array(size);
else {
let array = new Array(size);
for (let i = 0; i < array.length; i++)
array[i] = 0;
return array;
}
}
static newShortArray(size) {
if (_Utils.SUPPORTS_TYPED_ARRAYS)
return new Int16Array(size);
else {
let array = new Array(size);
for (let i = 0; i < array.length; i++)
array[i] = 0;
return array;
}
}
static toFloatArray(array) {
return _Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array;
}
static toSinglePrecision(value) {
return _Utils.SUPPORTS_TYPED_ARRAYS ? Math.fround(value) : value;
}
static webkit602BugfixHelper(alpha, blend) {
}
static contains(array, element, identity = true) {
for (var i = 0; i < array.length; i++)
if (array[i] == element)
return true;
return false;
}
static enumValue(type, name) {
return type[name[0].toUpperCase() + name.slice(1)];
}
};
var Utils = _Utils;
Utils.SUPPORTS_TYPED_ARRAYS = typeof Float32Array !== "undefined";
var DebugUtils = class {
static logBones(skeleton) {
for (let i = 0; i < skeleton.bones.length; i++) {
let bone = skeleton.bones[i];
console.log(bone.data.name + ", " + bone.a + ", " + bone.b + ", " + bone.c + ", " + bone.d + ", " + bone.worldX + ", " + bone.worldY);
}
}
};
var Pool = class {
constructor(instantiator) {
this.items = new Array();
this.instantiator = instantiator;
}
obtain() {
return this.items.length > 0 ? this.items.pop() : this.instantiator();
}
free(item) {
if (item.reset)
item.reset();
this.items.push(item);
}
freeAll(items) {
for (let i = 0; i < items.length; i++)
this.free(items[i]);
}
clear() {
this.items.length = 0;
}
};
var Vector2 = class {
constructor(x = 0, y = 0) {
this.x = x;
this.y = y;
}
set(x, y) {
this.x = x;
this.y = y;
return this;
}
length() {
let x = this.x;
let y = this.y;
return Math.sqrt(x * x + y * y);
}
normalize() {
let len = this.length();
if (len != 0) {
this.x /= len;
this.y /= len;
}
return this;
}
};
var TimeKeeper = class {
constructor() {
this.maxDelta = 0.064;
this.framesPerSecond = 0;
this.delta = 0;
this.totalTime = 0;
this.lastTime = Date.now() / 1e3;
this.frameCount = 0;
this.frameTime = 0;
}
update() {
let now = Date.now() / 1e3;
this.delta = now - this.lastTime;
this.frameTime += this.delta;
this.totalTime += this.delta;
if (this.delta > this.maxDelta)
this.delta = this.maxDelta;
this.lastTime = now;
this.frameCount++;
if (this.frameTime > 1) {
this.framesPerSecond = this.frameCount / this.frameTime;
this.frameTime = 0;
this.frameCount = 0;
}
}
};
var WindowedMean = class {
constructor(windowSize = 32) {
this.addedValues = 0;
this.lastValue = 0;
this.mean = 0;
this.dirty = true;
this.values = new Array(windowSize);
}
hasEnoughData() {
return this.addedValues >= this.values.length;
}
addValue(value) {
if (this.addedValues < this.values.length)
this.addedValues++;
this.values[this.lastValue++] = value;
if (this.lastValue > this.values.length - 1)
this.lastValue = 0;
this.dirty = true;
}
getMean() {
if (this.hasEnoughData()) {
if (this.dirty) {
let mean = 0;
for (let i = 0; i < this.values.length; i++)
mean += this.values[i];
this.mean = mean / this.values.length;
this.dirty = false;
}
return this.mean;
}
return 0;
}
};
// spine-core/src/attachments/Attachment.ts
var Attachment = class {
constructor(name) {
if (!name)
throw new Error("name cannot be null.");
this.name = name;
}
};
var _VertexAttachment = class extends Attachment {
constructor(name) {
super(name);
this.id = _VertexAttachment.nextID++;
this.bones = null;
this.vertices = [];
this.worldVerticesLength = 0;
this.timelineAttachment = this;
}
computeWorldVertices(slot, start, count, worldVertices2, offset, stride) {
count = offset + (count >> 1) * stride;
let skeleton = slot.bone.skeleton;
let deformArray = slot.deform;
let vertices = this.vertices;
let bones = this.bones;
if (!bones) {
if (deformArray.length > 0)
vertices = deformArray;
let bone = slot.bone;
let x = bone.worldX;
let y = bone.worldY;
let a = bone.a, b = bone.b, c = bone.c, d = bone.d;
for (let v2 = start, w = offset; w < count; v2 += 2, w += stride) {
let vx = vertices[v2], vy = vertices[v2 + 1];
worldVertices2[w] = vx * a + vy * b + x;
worldVertices2[w + 1] = vx * c + vy * d + y;
}
return;
}
let v = 0, skip = 0;
for (let i = 0; i < start; i += 2) {
let n = bones[v];
v += n + 1;
skip += n;
}
let skeletonBones = skeleton.bones;
if (deformArray.length == 0) {
for (let w = offset, b = skip * 3; w < count; w += stride) {
let wx = 0, wy = 0;
let n = bones[v++];
n += v;
for (; v < n; v++, b += 3) {
let bone = skeletonBones[bones[v]];
let vx = vertices[b], vy = vertices[b + 1], weight = vertices[b + 2];
wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
}
worldVertices2[w] = wx;
worldVertices2[w + 1] = wy;
}
} else {
let deform = deformArray;
for (let w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) {
let wx = 0, wy = 0;
let n = bones[v++];
n += v;
for (; v < n; v++, b += 3, f += 2) {
let bone = skeletonBones[bones[v]];
let vx = vertices[b] + deform[f], vy = vertices[b + 1] + deform[f + 1], weight = vertices[b + 2];
wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
}
worldVertices2[w] = wx;
worldVertices2[w + 1] = wy;
}
}
}
copyTo(attachment) {
if (this.bones) {
attachment.bones = new Array(this.bones.length);
Utils.arrayCopy(this.bones, 0, attachment.bones, 0, this.bones.length);
} else
attachment.bones = null;
if (this.vertices) {
attachment.vertices = Utils.newFloatArray(this.vertices.length);
Utils.arrayCopy(this.vertices, 0, attachment.vertices, 0, this.vertices.length);
}
attachment.worldVerticesLength = this.worldVerticesLength;
attachment.timelineAttachment = this.timelineAttachment;
}
};
var VertexAttachment = _VertexAttachment;
VertexAttachment.nextID = 0;
// spine-core/src/attachments/Sequence.ts
var _Sequence = class {
constructor(count) {
this.id = _Sequence.nextID();
this.start = 0;
this.digits = 0;
this.setupIndex = 0;
this.regions = new Array(count);
}
copy() {
let copy = new _Sequence(this.regions.length);
Utils.arrayCopy(this.regions, 0, copy.regions, 0, this.regions.length);
copy.start = this.start;
copy.digits = this.digits;
copy.setupIndex = this.setupIndex;
return copy;
}
apply(slot, attachment) {
let index = slot.sequenceIndex;
if (index == -1)
index = this.setupIndex;
if (index >= this.regions.length)
index = this.regions.length - 1;
let region = this.regions[index];
if (attachment.region != region) {
attachment.region = region;
attachment.updateRegion();
}
}
getPath(basePath, index) {
let result = basePath;
let frame = (this.start + index).toString();
for (let i = this.digits - frame.length; i > 0; i--)
result += "0";
result += frame;
return result;
}
static nextID() {
return _Sequence._nextID++;
}
};
var Sequence = _Sequence;
Sequence._nextID = 0;
var SequenceMode = /* @__PURE__ */ ((SequenceMode2) => {
SequenceMode2[SequenceMode2["hold"] = 0] = "hold";
SequenceMode2[SequenceMode2["once"] = 1] = "once";
SequenceMode2[SequenceMode2["loop"] = 2] = "loop";
SequenceMode2[SequenceMode2["pingpong"] = 3] = "pingpong";
SequenceMode2[SequenceMode2["onceReverse"] = 4] = "onceReverse";
SequenceMode2[SequenceMode2["loopReverse"] = 5] = "loopReverse";
SequenceMode2[SequenceMode2["pingpongReverse"] = 6] = "pingpongReverse";
return SequenceMode2;
})(SequenceMode || {});
var SequenceModeValues = [
0 /* hold */,
1 /* once */,
2 /* loop */,
3 /* pingpong */,
4 /* onceReverse */,
5 /* loopReverse */,
6 /* pingpongReverse */
];
// spine-core/src/Animation.ts
var Animation = class {
constructor(name, timelines, duration) {
this.timelines = [];
this.timelineIds = new StringSet();
if (!name)
throw new Error("name cannot be null.");
this.name = name;
this.setTimelines(timelines);
this.duration = duration;
}
setTimelines(timelines) {
if (!timelines)
throw new Error("timelines cannot be null.");
this.timelines = timelines;
this.timelineIds.clear();
for (var i = 0; i < timelines.length; i++)
this.timelineIds.addAll(timelines[i].getPropertyIds());
}
hasTimeline(ids) {
for (let i = 0; i < ids.length; i++)
if (this.timelineIds.contains(ids[i]))
return true;
return false;
}
apply(skeleton, lastTime, time, loop, events, alpha, blend, direction) {
if (!skeleton)
throw new Error("skeleton cannot be null.");
if (loop && this.duration != 0) {
time %= this.duration;
if (lastTime > 0)
lastTime %= this.duration;
}
let timelines = this.timelines;
for (let i = 0, n = timelines.length; i < n; i++)
timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction);
}
};
var MixBlend = /* @__PURE__ */ ((MixBlend2) => {
MixBlend2[MixBlend2["setup"] = 0] = "setup";
MixBlend2[MixBlend2["first"] = 1] = "first";
MixBlend2[MixBlend2["replace"] = 2] = "replace";
MixBlend2[MixBlend2["add"] = 3] = "add";
return MixBlend2;
})(MixBlend || {});
var MixDirection = /* @__PURE__ */ ((MixDirection2) => {
MixDirection2[MixDirection2["mixIn"] = 0] = "mixIn";
MixDirection2[MixDirection2["mixOut"] = 1] = "mixOut";
return MixDirection2;
})(MixDirection || {});
var Property = {
rotate: 0,
x: 1,
y: 2,
scaleX: 3,
scaleY: 4,
shearX: 5,
shearY: 6,
rgb: 7,
alpha: 8,
rgb2: 9,
attachment: 10,
deform: 11,
event: 12,
drawOrder: 13,
ikConstraint: 14,
transformConstraint: 15,
pathConstraintPosition: 16,
pathConstraintSpacing: 17,
pathConstraintMix: 18,
sequence: 19
};
var Timeline = class {
constructor(frameCount, propertyIds) {
this.propertyIds = propertyIds;
this.frames = Utils.newFloatArray(frameCount * this.getFrameEntries());
}
getPropertyIds() {
return this.propertyIds;
}
getFrameEntries() {
return 1;
}
getFrameCount() {
return this.frames.length / this.getFrameEntries();
}
getDuration() {
return this.frames[this.frames.length - this.getFrameEntries()];
}
static search1(frames, time) {
let n = frames.length;
for (let i = 1; i < n; i++)
if (frames[i] > time)
return i - 1;
return n - 1;
}
static search(frames, time, step) {
let n = frames.length;
for (let i = step; i < n; i += step)
if (frames[i] > time)
return i - step;
return n - step;
}
};
var CurveTimeline = class extends Timeline {
constructor(frameCount, bezierCount, propertyIds) {
super(frameCount, propertyIds);
this.curves = Utils.newFloatArray(frameCount + bezierCount * 18);
this.curves[frameCount - 1] = 1;
}
setLinear(frame) {
this.curves[frame] = 0;
}
setStepped(frame) {
this.curves[frame] = 1;
}
shrink(bezierCount) {
let size = this.getFrameCount() + bezierCount * 18;
if (this.curves.length > size) {
let newCurves = Utils.newFloatArray(size);
Utils.arrayCopy(this.curves, 0, newCurves, 0, size);
this.curves = newCurves;
}
}
setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2) {
let curves = this.curves;
let i = this.getFrameCount() + bezier * 18;
if (value == 0)
curves[frame] = 2 + i;
let tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = (value1 - cy1 * 2 + cy2) * 0.03;
let dddx = ((cx1 - cx2) * 3 - time1 + time2) * 6e-3, dddy = ((cy1 - cy2) * 3 - value1 + value2) * 6e-3;
let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy;
let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = (cy1 - value1) * 0.3 + tmpy + dddy * 0.16666667;
let x = time1 + dx, y = value1 + dy;
for (let n = i + 18; i < n; i += 2) {
curves[i] = x;
curves[i + 1] = y;
dx += ddx;
dy += ddy;
ddx += dddx;
ddy += dddy;
x += dx;
y += dy;
}
}
getBezierValue(time, frameIndex, valueOffset, i) {
let curves = this.curves;
if (curves[i] > time) {
let x2 = this.frames[frameIndex], y2 = this.frames[frameIndex + valueOffset];
return y2 + (time - x2) / (curves[i] - x2) * (curves[i + 1] - y2);
}
let n = i + 18;
for (i += 2; i < n; i += 2) {
if (curves[i] >= time) {
let x2 = curves[i - 2], y2 = curves[i - 1];
return y2 + (time - x2) / (curves[i] - x2) * (curves[i + 1] - y2);
}
}
frameIndex += this.getFrameEntries();
let x = curves[n - 2], y = curves[n - 1];
return y + (time - x) / (this.frames[frameIndex] - x) * (this.frames[frameIndex + valueOffset] - y);
}
};
var CurveTimeline1 = class extends CurveTimeline {
constructor(frameCount, bezierCount, propertyId) {
super(frameCount, bezierCount, [propertyId]);
}
getFrameEntries() {
return 2;
}
setFrame(frame, time, value) {
frame <<= 1;
this.frames[frame] = time;
this.frames[frame + 1] = value;
}
getCurveValue(time) {
let frames = this.frames;
let i = frames.length - 2;
for (let ii = 2; ii <= i; ii += 2) {
if (frames[ii] > time) {
i = ii - 2;
break;
}
}
let curveType = this.curves[i >> 1];
switch (curveType) {
case 0:
let before = frames[i], value = frames[i + 1];
return value + (time - before) / (frames[i + 2] - before) * (frames[i + 2 + 1] - value);
case 1:
return frames[i + 1];
}
return this.getBezierValue(time, i, 1, curveType - 2);
}
};
var CurveTimeline2 = class extends CurveTimeline {
constructor(frameCount, bezierCount, propertyId1, propertyId2) {
super(frameCount, bezierCount, [propertyId1, propertyId2]);
}
getFrameEntries() {
return 3;
}
setFrame(frame, time, value1, value2) {
frame *= 3;
this.frames[frame] = time;
this.frames[frame + 1] = value1;
this.frames[frame + 2] = value2;
}
};
var RotateTimeline = class extends CurveTimeline1 {
constructor(frameCount, bezierCount, boneIndex) {
super(frameCount, bezierCount, Property.rotate + "|" + boneIndex);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.rotation = bone.data.rotation;
return;
case 1 /* first */:
bone.rotation += (bone.data.rotation - bone.rotation) * alpha;
}
return;
}
let r = this.getCurveValue(time);
switch (blend) {
case 0 /* setup */:
bone.rotation = bone.data.rotation + r * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
r += bone.data.rotation - bone.rotation;
case 3 /* add */:
bone.rotation += r * alpha;
}
}
};
var TranslateTimeline = class extends CurveTimeline2 {
constructor(frameCount, bezierCount, boneIndex) {
super(
frameCount,
bezierCount,
Property.x + "|" + boneIndex,
Property.y + "|" + boneIndex
);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.x = bone.data.x;
bone.y = bone.data.y;
return;
case 1 /* first */:
bone.x += (bone.data.x - bone.x) * alpha;
bone.y += (bone.data.y - bone.y) * alpha;
}
return;
}
let x = 0, y = 0;
let i = Timeline.search(frames, time, 3);
let curveType = this.curves[i / 3];
switch (curveType) {
case 0:
let before = frames[i];
x = frames[i + 1];
y = frames[i + 2];
let t = (time - before) / (frames[i + 3] - before);
x += (frames[i + 3 + 1] - x) * t;
y += (frames[i + 3 + 2] - y) * t;
break;
case 1:
x = frames[i + 1];
y = frames[i + 2];
break;
default:
x = this.getBezierValue(time, i, 1, curveType - 2);
y = this.getBezierValue(time, i, 2, curveType + 18 - 2);
}
switch (blend) {
case 0 /* setup */:
bone.x = bone.data.x + x * alpha;
bone.y = bone.data.y + y * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bone.x += (bone.data.x + x - bone.x) * alpha;
bone.y += (bone.data.y + y - bone.y) * alpha;
break;
case 3 /* add */:
bone.x += x * alpha;
bone.y += y * alpha;
}
}
};
var TranslateXTimeline = class extends CurveTimeline1 {
constructor(frameCount, bezierCount, boneIndex) {
super(frameCount, bezierCount, Property.x + "|" + boneIndex);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.x = bone.data.x;
return;
case 1 /* first */:
bone.x += (bone.data.x - bone.x) * alpha;
}
return;
}
let x = this.getCurveValue(time);
switch (blend) {
case 0 /* setup */:
bone.x = bone.data.x + x * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bone.x += (bone.data.x + x - bone.x) * alpha;
break;
case 3 /* add */:
bone.x += x * alpha;
}
}
};
var TranslateYTimeline = class extends CurveTimeline1 {
constructor(frameCount, bezierCount, boneIndex) {
super(frameCount, bezierCount, Property.y + "|" + boneIndex);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.y = bone.data.y;
return;
case 1 /* first */:
bone.y += (bone.data.y - bone.y) * alpha;
}
return;
}
let y = this.getCurveValue(time);
switch (blend) {
case 0 /* setup */:
bone.y = bone.data.y + y * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bone.y += (bone.data.y + y - bone.y) * alpha;
break;
case 3 /* add */:
bone.y += y * alpha;
}
}
};
var ScaleTimeline = class extends CurveTimeline2 {
constructor(frameCount, bezierCount, boneIndex) {
super(
frameCount,
bezierCount,
Property.scaleX + "|" + boneIndex,
Property.scaleY + "|" + boneIndex
);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.scaleX = bone.data.scaleX;
bone.scaleY = bone.data.scaleY;
return;
case 1 /* first */:
bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
}
return;
}
let x, y;
let i = Timeline.search(frames, time, 3);
let curveType = this.curves[i / 3];
switch (curveType) {
case 0:
let before = frames[i];
x = frames[i + 1];
y = frames[i + 2];
let t = (time - before) / (frames[i + 3] - before);
x += (frames[i + 3 + 1] - x) * t;
y += (frames[i + 3 + 2] - y) * t;
break;
case 1:
x = frames[i + 1];
y = frames[i + 2];
break;
default:
x = this.getBezierValue(time, i, 1, curveType - 2);
y = this.getBezierValue(time, i, 2, curveType + 18 - 2);
}
x *= bone.data.scaleX;
y *= bone.data.scaleY;
if (alpha == 1) {
if (blend == 3 /* add */) {
bone.scaleX += x - bone.data.scaleX;
bone.scaleY += y - bone.data.scaleY;
} else {
bone.scaleX = x;
bone.scaleY = y;
}
} else {
let bx = 0, by = 0;
if (direction == 1 /* mixOut */) {
switch (blend) {
case 0 /* setup */:
bx = bone.data.scaleX;
by = bone.data.scaleY;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bx = bone.scaleX;
by = bone.scaleY;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
break;
case 3 /* add */:
bone.scaleX += (x - bone.data.scaleX) * alpha;
bone.scaleY += (y - bone.data.scaleY) * alpha;
}
} else {
switch (blend) {
case 0 /* setup */:
bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
bone.scaleX = bx + (x - bx) * alpha;
bone.scaleY = by + (y - by) * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
by = Math.abs(bone.scaleY) * MathUtils.signum(y);
bone.scaleX = bx + (x - bx) * alpha;
bone.scaleY = by + (y - by) * alpha;
break;
case 3 /* add */:
bone.scaleX += (x - bone.data.scaleX) * alpha;
bone.scaleY += (y - bone.data.scaleY) * alpha;
}
}
}
}
};
var ScaleXTimeline = class extends CurveTimeline1 {
constructor(frameCount, bezierCount, boneIndex) {
super(frameCount, bezierCount, Property.scaleX + "|" + boneIndex);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.scaleX = bone.data.scaleX;
return;
case 1 /* first */:
bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
}
return;
}
let x = this.getCurveValue(time) * bone.data.scaleX;
if (alpha == 1) {
if (blend == 3 /* add */)
bone.scaleX += x - bone.data.scaleX;
else
bone.scaleX = x;
} else {
let bx = 0;
if (direction == 1 /* mixOut */) {
switch (blend) {
case 0 /* setup */:
bx = bone.data.scaleX;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bx = bone.scaleX;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
break;
case 3 /* add */:
bone.scaleX += (x - bone.data.scaleX) * alpha;
}
} else {
switch (blend) {
case 0 /* setup */:
bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
bone.scaleX = bx + (x - bx) * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
bone.scaleX = bx + (x - bx) * alpha;
break;
case 3 /* add */:
bone.scaleX += (x - bone.data.scaleX) * alpha;
}
}
}
}
};
var ScaleYTimeline = class extends CurveTimeline1 {
constructor(frameCount, bezierCount, boneIndex) {
super(frameCount, bezierCount, Property.scaleY + "|" + boneIndex);
this.boneIndex = 0;
this.boneIndex = boneIndex;
}
apply(skeleton, lastTime, time, events, alpha, blend, direction) {
let bone = skeleton.bones[this.boneIndex];
if (!bone.active)
return;
let frames = this.frames;
if (time < frames[0]) {
switch (blend) {
case 0 /* setup */:
bone.scaleY = bone.data.scaleY;
return;
case 1 /* first */:
bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
}
return;
}
let y = this.getCurveValue(time) * bone.data.scaleY;
if (alpha == 1) {
if (blend == 3 /* add */)
bone.scaleY += y - bone.data.scaleY;
else
bone.scaleY = y;
} else {
let by = 0;
if (direction == 1 /* mixOut */) {
switch (blend) {
case 0 /* setup */:
by = bone.data.scaleY;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
by = bone.scaleY;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
break;
case 3 /* add */:
bone.scaleY += (y - bone.data.scaleY) * alpha;
}
} else {
switch (blend) {
case 0 /* setup */:
by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
bone.scaleY = by + (y - by) * alpha;
break;
case 1 /* first */:
case 2 /* replace */:
by = Math.abs(bone.scaleY) * MathUtils.signum(y);
bone.scaleY = by + (y - by) * alpha;
break;
case 3 /* add */:
bone.scaleY += (y - bone.data.scaleY) * alpha;
}
}
}
}
};
var ShearTimeline = class extends CurveTimeline2 {
constructor(frameCount, bezierCount, boneIndex) {
super(
frameCount,
bezierCount,