5251 lines
166 KiB
JavaScript
5251 lines
166 KiB
JavaScript
(window.framework = {}),
|
|
(window.__extends =
|
|
(this && this.__extends) ||
|
|
(function () {
|
|
var t =
|
|
Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array &&
|
|
function (t, e) {
|
|
t.__proto__ = e;
|
|
}) ||
|
|
function (t, e) {
|
|
for (var n in e) e.hasOwnProperty(n) && (t[n] = e[n]);
|
|
};
|
|
return function (e, n) {
|
|
function i() {
|
|
this.constructor = e;
|
|
}
|
|
t(e, n),
|
|
(e.prototype =
|
|
null === n
|
|
? Object.create(n)
|
|
: ((i.prototype = n.prototype), new i()));
|
|
};
|
|
})());
|
|
var __awaiter =
|
|
(this && this.__awaiter) ||
|
|
function (t, e, n, i) {
|
|
return new (n || (n = Promise))(function (o, r) {
|
|
function s(t) {
|
|
try {
|
|
h(i.next(t));
|
|
} catch (t) {
|
|
r(t);
|
|
}
|
|
}
|
|
function a(t) {
|
|
try {
|
|
h(i.throw(t));
|
|
} catch (t) {
|
|
r(t);
|
|
}
|
|
}
|
|
function h(t) {
|
|
t.done
|
|
? o(t.value)
|
|
: new n(function (e) {
|
|
e(t.value);
|
|
}).then(s, a);
|
|
}
|
|
h((i = i.apply(t, e || [])).next());
|
|
});
|
|
},
|
|
__generator =
|
|
(this && this.__generator) ||
|
|
function (t, e) {
|
|
var n,
|
|
i,
|
|
o,
|
|
r,
|
|
s = {
|
|
label: 0,
|
|
sent: function () {
|
|
if (1 & o[0]) throw o[1];
|
|
return o[1];
|
|
},
|
|
trys: [],
|
|
ops: [],
|
|
};
|
|
return (
|
|
(r = { next: a(0), throw: a(1), return: a(2) }),
|
|
"function" == typeof Symbol &&
|
|
(r[Symbol.iterator] = function () {
|
|
return this;
|
|
}),
|
|
r
|
|
);
|
|
function a(r) {
|
|
return function (a) {
|
|
return (function (r) {
|
|
if (n) throw new TypeError("Generator is already executing.");
|
|
for (; s; )
|
|
try {
|
|
if (
|
|
((n = 1),
|
|
i &&
|
|
(o =
|
|
2 & r[0]
|
|
? i.return
|
|
: r[0]
|
|
? i.throw || ((o = i.return) && o.call(i), 0)
|
|
: i.next) &&
|
|
!(o = o.call(i, r[1])).done)
|
|
)
|
|
return o;
|
|
switch (((i = 0), o && (r = [2 & r[0], o.value]), r[0])) {
|
|
case 0:
|
|
case 1:
|
|
o = r;
|
|
break;
|
|
case 4:
|
|
return s.label++, { value: r[1], done: !1 };
|
|
case 5:
|
|
s.label++, (i = r[1]), (r = [0]);
|
|
continue;
|
|
case 7:
|
|
(r = s.ops.pop()), s.trys.pop();
|
|
continue;
|
|
default:
|
|
if (
|
|
!(o = (o = s.trys).length > 0 && o[o.length - 1]) &&
|
|
(6 === r[0] || 2 === r[0])
|
|
) {
|
|
s = 0;
|
|
continue;
|
|
}
|
|
if (3 === r[0] && (!o || (r[1] > o[0] && r[1] < o[3]))) {
|
|
s.label = r[1];
|
|
break;
|
|
}
|
|
if (6 === r[0] && s.label < o[1]) {
|
|
(s.label = o[1]), (o = r);
|
|
break;
|
|
}
|
|
if (o && s.label < o[2]) {
|
|
(s.label = o[2]), s.ops.push(r);
|
|
break;
|
|
}
|
|
o[2] && s.ops.pop(), s.trys.pop();
|
|
continue;
|
|
}
|
|
r = e.call(t, s);
|
|
} catch (t) {
|
|
(r = [6, t]), (i = 0);
|
|
} finally {
|
|
n = o = 0;
|
|
}
|
|
if (5 & r[0]) throw r[1];
|
|
return { value: r[0] ? r[1] : void 0, done: !0 };
|
|
})([r, a]);
|
|
};
|
|
}
|
|
};
|
|
(Array.prototype.findIndex = function (t) {
|
|
return (function (t, e) {
|
|
for (var n = 0, i = t.length; n < i; n++)
|
|
if (e.call(arguments[2], t[n], n, t)) return n;
|
|
return -1;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.any = function (t) {
|
|
return (function (t, e) {
|
|
return t.findIndex(e) > -1;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.firstOrDefault = function (t) {
|
|
return (function (t, e) {
|
|
var n = t.findIndex(e);
|
|
return -1 == n ? null : t[n];
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.find = function (t) {
|
|
return (function (t, e) {
|
|
return t.firstOrDefault(e);
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.where = function (t) {
|
|
return (function (t, e) {
|
|
if ("function" == typeof t.reduce)
|
|
return t.reduce(function (n, i, o) {
|
|
return e.call(arguments[2], i, o, t) && n.push(i), n;
|
|
}, []);
|
|
for (var n = [], i = 0, o = t.length; i < o; i++) {
|
|
var r = t[i];
|
|
e.call(arguments[2], r, i, t) && n.push(r);
|
|
}
|
|
return n;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.count = function (t) {
|
|
return (function (t, e) {
|
|
return t.where(e).length;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.findAll = function (t) {
|
|
return (function (t, e) {
|
|
return t.where(e);
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.contains = function (t) {
|
|
return (function (t, e) {
|
|
for (var n = 0, i = t.length; n < i; n++) if (t[n] == e) return !0;
|
|
return !1;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.removeAll = function (t) {
|
|
!(function (t, e) {
|
|
var n;
|
|
do {
|
|
(n = t.findIndex(e)) >= 0 && t.splice(n, 1);
|
|
} while (n >= 0);
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.remove = function (t) {
|
|
return (function (t, e) {
|
|
var n = t.findIndex(function (t) {
|
|
return t === e;
|
|
});
|
|
return n >= 0 && (t.splice(n, 1), !0);
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.removeAt = function (t) {
|
|
return (function (t, e) {
|
|
t.splice(e, 1);
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.removeRange = function (t, e) {
|
|
return (function (t, e, n) {
|
|
t.splice(e, n);
|
|
})(this, t, e);
|
|
}),
|
|
(Array.prototype.select = function (t) {
|
|
return (function (t, e) {
|
|
if ("function" == typeof t.reduce)
|
|
return t.reduce(function (n, i, o) {
|
|
return n.push(e.call(arguments[2], i, o, t)), n;
|
|
}, []);
|
|
for (var n = [], i = 0, o = t.length; i < o; i++)
|
|
n.push(e.call(arguments[2], t[i], i, t));
|
|
return n;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.orderBy = function (t, e) {
|
|
return (function (t, e, n) {
|
|
return (
|
|
t.sort(function (t, i) {
|
|
var o = e(t),
|
|
r = e(i);
|
|
return n ? n(o, r) : o > r ? 1 : -1;
|
|
}),
|
|
t
|
|
);
|
|
})(this, t, e);
|
|
}),
|
|
(Array.prototype.orderByDescending = function (t, e) {
|
|
return (function (t, e, n) {
|
|
return (
|
|
t.sort(function (t, i) {
|
|
var o = e(t),
|
|
r = e(i);
|
|
return n ? -n(o, r) : o < r ? 1 : -1;
|
|
}),
|
|
t
|
|
);
|
|
})(this, t, e);
|
|
}),
|
|
(Array.prototype.groupBy = function (t) {
|
|
return (function (t, e) {
|
|
if ("function" == typeof t.reduce) {
|
|
var n = [];
|
|
return t.reduce(function (i, o, r) {
|
|
var s = JSON.stringify(e.call(arguments[1], o, r, t)),
|
|
a = n.findIndex(function (t) {
|
|
return t === s;
|
|
});
|
|
return (
|
|
a < 0 && (a = n.push(s) - 1), i[a] || (i[a] = []), i[a].push(o), i
|
|
);
|
|
}, []);
|
|
}
|
|
for (
|
|
var i = [],
|
|
o = [],
|
|
r = function (n, r) {
|
|
var a = JSON.stringify(e.call(s[1], t[n], n, t)),
|
|
h = o.findIndex(function (t) {
|
|
return t === a;
|
|
});
|
|
h < 0 && (h = o.push(a) - 1), i[h] || (i[h] = []), i[h].push(t[n]);
|
|
},
|
|
s = arguments,
|
|
a = 0,
|
|
h = t.length;
|
|
a < h;
|
|
a++
|
|
)
|
|
r(a);
|
|
return i;
|
|
})(this, t);
|
|
}),
|
|
(Array.prototype.sum = function (t) {
|
|
return (function (t, e) {
|
|
for (var n, i = 0, o = t.length; i < o; i++)
|
|
0 == i
|
|
? (n = e ? e.call(arguments[2], t[i], i, t) : t[i])
|
|
: (n += e ? e.call(arguments[2], t[i], i, t) : t[i]);
|
|
return n;
|
|
})(this, t);
|
|
});
|
|
var DirtyType,
|
|
ComponentTransform,
|
|
PriorityQueueNode = (function () {
|
|
return function () {
|
|
(this.priority = 0), (this.insertionIndex = 0), (this.queueIndex = 0);
|
|
};
|
|
})(),
|
|
AStarPathfinder = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.search = function (t, e, n) {
|
|
var i = this,
|
|
o = !1,
|
|
r = new Map();
|
|
r.set(e, e);
|
|
var s = new Map(),
|
|
a = new PriorityQueue(1e3);
|
|
a.enqueue(new AStarNode(e), 0), s.set(e, 0);
|
|
for (
|
|
var h = function () {
|
|
var e = a.dequeue();
|
|
if (JSON.stringify(e.data) == JSON.stringify(n))
|
|
return (o = !0), "break";
|
|
t.getNeighbors(e.data).forEach(function (o) {
|
|
var h = s.get(e.data) + t.cost(e.data, o);
|
|
if (!i.hasKey(s, o) || h < s.get(o)) {
|
|
s.set(o, h);
|
|
var c = h + t.heuristic(o, n);
|
|
a.enqueue(new AStarNode(o), c), r.set(o, e.data);
|
|
}
|
|
});
|
|
};
|
|
a.count > 0;
|
|
|
|
) {
|
|
if ("break" === h()) break;
|
|
}
|
|
return o ? this.recontructPath(r, e, n) : null;
|
|
}),
|
|
(t.hasKey = function (t, e) {
|
|
for (var n, i = t.keys(); !(n = i.next()).done; )
|
|
if (JSON.stringify(n.value) == JSON.stringify(e)) return !0;
|
|
return !1;
|
|
}),
|
|
(t.getKey = function (t, e) {
|
|
for (
|
|
var n, i, o = t.keys(), r = t.values();
|
|
(n = o.next()), (i = r.next()), !n.done;
|
|
|
|
)
|
|
if (JSON.stringify(n.value) == JSON.stringify(e)) return i.value;
|
|
return null;
|
|
}),
|
|
(t.recontructPath = function (t, e, n) {
|
|
var i = [],
|
|
o = n;
|
|
for (i.push(n); o != e; ) (o = this.getKey(t, o)), i.push(o);
|
|
return i.reverse(), i;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
AStarNode = (function (t) {
|
|
function e(e) {
|
|
var n = t.call(this) || this;
|
|
return (n.data = e), n;
|
|
}
|
|
return __extends(e, t), e;
|
|
})(PriorityQueueNode),
|
|
AstarGridGraph = (function () {
|
|
function t(t, e) {
|
|
(this.dirs = [
|
|
new Point(1, 0),
|
|
new Point(0, -1),
|
|
new Point(-1, 0),
|
|
new Point(0, 1),
|
|
]),
|
|
(this.walls = []),
|
|
(this.weightedNodes = []),
|
|
(this.defaultWeight = 1),
|
|
(this.weightedNodeWeight = 5),
|
|
(this._neighbors = new Array(4)),
|
|
(this._width = t),
|
|
(this._height = e);
|
|
}
|
|
return (
|
|
(t.prototype.isNodeInBounds = function (t) {
|
|
return 0 <= t.x && t.x < this._width && 0 <= t.y && t.y < this._height;
|
|
}),
|
|
(t.prototype.isNodePassable = function (t) {
|
|
return !this.walls.firstOrDefault(function (e) {
|
|
return JSON.stringify(e) == JSON.stringify(t);
|
|
});
|
|
}),
|
|
(t.prototype.search = function (t, e) {
|
|
return AStarPathfinder.search(this, t, e);
|
|
}),
|
|
(t.prototype.getNeighbors = function (t) {
|
|
var e = this;
|
|
return (
|
|
(this._neighbors.length = 0),
|
|
this.dirs.forEach(function (n) {
|
|
var i = new Point(t.x + n.x, t.y + n.y);
|
|
e.isNodeInBounds(i) && e.isNodePassable(i) && e._neighbors.push(i);
|
|
}),
|
|
this._neighbors
|
|
);
|
|
}),
|
|
(t.prototype.cost = function (t, e) {
|
|
return this.weightedNodes.find(function (t) {
|
|
return JSON.stringify(t) == JSON.stringify(e);
|
|
})
|
|
? this.weightedNodeWeight
|
|
: this.defaultWeight;
|
|
}),
|
|
(t.prototype.heuristic = function (t, e) {
|
|
return Math.abs(t.x - e.x) + Math.abs(t.y - e.y);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
PriorityQueue = (function () {
|
|
function t(t) {
|
|
(this._numNodes = 0),
|
|
(this._nodes = new Array(t + 1)),
|
|
(this._numNodesEverEnqueued = 0);
|
|
}
|
|
return (
|
|
(t.prototype.clear = function () {
|
|
this._nodes.splice(1, this._numNodes), (this._numNodes = 0);
|
|
}),
|
|
Object.defineProperty(t.prototype, "count", {
|
|
get: function () {
|
|
return this._numNodes;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.contains = function (t) {
|
|
return this._nodes[t.queueIndex] == t;
|
|
}),
|
|
(t.prototype.enqueue = function (t, e) {
|
|
(t.priority = e),
|
|
this._numNodes++,
|
|
(this._nodes[this._numNodes] = t),
|
|
(t.queueIndex = this._numNodes),
|
|
(t.insertionIndex = this._numNodesEverEnqueued++),
|
|
this.cascadeUp(this._nodes[this._numNodes]);
|
|
}),
|
|
(t.prototype.dequeue = function () {
|
|
var t = this._nodes[1];
|
|
return this.remove(t), t;
|
|
}),
|
|
(t.prototype.remove = function (t) {
|
|
if (t.queueIndex == this._numNodes)
|
|
return (this._nodes[this._numNodes] = null), void this._numNodes--;
|
|
var e = this._nodes[this._numNodes];
|
|
this.swap(t, e),
|
|
delete this._nodes[this._numNodes],
|
|
this._numNodes--,
|
|
this.onNodeUpdated(e);
|
|
}),
|
|
(t.prototype.isValidQueue = function () {
|
|
for (var t = 1; t < this._nodes.length; t++)
|
|
if (this._nodes[t]) {
|
|
var e = 2 * t;
|
|
if (
|
|
e < this._nodes.length &&
|
|
this._nodes[e] &&
|
|
this.hasHigherPriority(this._nodes[e], this._nodes[t])
|
|
)
|
|
return !1;
|
|
var n = e + 1;
|
|
if (
|
|
n < this._nodes.length &&
|
|
this._nodes[n] &&
|
|
this.hasHigherPriority(this._nodes[n], this._nodes[t])
|
|
)
|
|
return !1;
|
|
}
|
|
return !0;
|
|
}),
|
|
(t.prototype.onNodeUpdated = function (t) {
|
|
var e = Math.floor(t.queueIndex / 2),
|
|
n = this._nodes[e];
|
|
e > 0 && this.hasHigherPriority(t, n)
|
|
? this.cascadeUp(t)
|
|
: this.cascadeDown(t);
|
|
}),
|
|
(t.prototype.cascadeDown = function (t) {
|
|
for (var e, n = t.queueIndex; ; ) {
|
|
e = t;
|
|
var i = 2 * n;
|
|
if (i > this._numNodes) {
|
|
(t.queueIndex = n), (this._nodes[n] = t);
|
|
break;
|
|
}
|
|
var o = this._nodes[i];
|
|
this.hasHigherPriority(o, e) && (e = o);
|
|
var r = i + 1;
|
|
if (r <= this._numNodes) {
|
|
var s = this._nodes[r];
|
|
this.hasHigherPriority(s, e) && (e = s);
|
|
}
|
|
if (e == t) {
|
|
(t.queueIndex = n), (this._nodes[n] = t);
|
|
break;
|
|
}
|
|
this._nodes[n] = e;
|
|
var a = e.queueIndex;
|
|
(e.queueIndex = n), (n = a);
|
|
}
|
|
}),
|
|
(t.prototype.cascadeUp = function (t) {
|
|
for (var e = Math.floor(t.queueIndex / 2); e >= 1; ) {
|
|
var n = this._nodes[e];
|
|
if (this.hasHigherPriority(n, t)) break;
|
|
this.swap(t, n), (e = Math.floor(t.queueIndex / 2));
|
|
}
|
|
}),
|
|
(t.prototype.swap = function (t, e) {
|
|
(this._nodes[t.queueIndex] = e), (this._nodes[e.queueIndex] = t);
|
|
var n = t.queueIndex;
|
|
(t.queueIndex = e.queueIndex), (e.queueIndex = n);
|
|
}),
|
|
(t.prototype.hasHigherPriority = function (t, e) {
|
|
return (
|
|
t.priority < e.priority ||
|
|
(t.priority == e.priority && t.insertionIndex < e.insertionIndex)
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
BreadthFirstPathfinder = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.search = function (t, e, n) {
|
|
var i = this,
|
|
o = !1,
|
|
r = [];
|
|
r.unshift(e);
|
|
var s = new Map();
|
|
s.set(e, e);
|
|
for (
|
|
var a = function () {
|
|
var e = r.shift();
|
|
if (JSON.stringify(e) == JSON.stringify(n))
|
|
return (o = !0), "break";
|
|
t.getNeighbors(e).forEach(function (t) {
|
|
i.hasKey(s, t) || (r.unshift(t), s.set(t, e));
|
|
});
|
|
};
|
|
r.length > 0;
|
|
|
|
) {
|
|
if ("break" === a()) break;
|
|
}
|
|
return o ? AStarPathfinder.recontructPath(s, e, n) : null;
|
|
}),
|
|
(t.hasKey = function (t, e) {
|
|
for (var n, i = t.keys(); !(n = i.next()).done; )
|
|
if (JSON.stringify(n.value) == JSON.stringify(e)) return !0;
|
|
return !1;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
UnweightedGraph = (function () {
|
|
function t() {
|
|
this.edges = new Map();
|
|
}
|
|
return (
|
|
(t.prototype.addEdgesForNode = function (t, e) {
|
|
return this.edges.set(t, e), this;
|
|
}),
|
|
(t.prototype.getNeighbors = function (t) {
|
|
return this.edges.get(t);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Point = (function () {
|
|
return function (t, e) {
|
|
(this.x = t || 0), (this.y = e || this.x);
|
|
};
|
|
})(),
|
|
UnweightedGridGraph = (function () {
|
|
function t(e, n, i) {
|
|
void 0 === i && (i = !1),
|
|
(this.walls = []),
|
|
(this._neighbors = new Array(4)),
|
|
(this._width = e),
|
|
(this._hegiht = n),
|
|
(this._dirs = i ? t.COMPASS_DIRS : t.CARDINAL_DIRS);
|
|
}
|
|
return (
|
|
(t.prototype.isNodeInBounds = function (t) {
|
|
return 0 <= t.x && t.x < this._width && 0 <= t.y && t.y < this._hegiht;
|
|
}),
|
|
(t.prototype.isNodePassable = function (t) {
|
|
return !this.walls.firstOrDefault(function (e) {
|
|
return JSON.stringify(e) == JSON.stringify(t);
|
|
});
|
|
}),
|
|
(t.prototype.getNeighbors = function (t) {
|
|
var e = this;
|
|
return (
|
|
(this._neighbors.length = 0),
|
|
this._dirs.forEach(function (n) {
|
|
var i = new Point(t.x + n.x, t.y + n.y);
|
|
e.isNodeInBounds(i) && e.isNodePassable(i) && e._neighbors.push(i);
|
|
}),
|
|
this._neighbors
|
|
);
|
|
}),
|
|
(t.prototype.search = function (t, e) {
|
|
return BreadthFirstPathfinder.search(this, t, e);
|
|
}),
|
|
(t.CARDINAL_DIRS = [
|
|
new Point(1, 0),
|
|
new Point(0, -1),
|
|
new Point(-1, 0),
|
|
new Point(0, -1),
|
|
]),
|
|
(t.COMPASS_DIRS = [
|
|
new Point(1, 0),
|
|
new Point(1, -1),
|
|
new Point(0, -1),
|
|
new Point(-1, -1),
|
|
new Point(-1, 0),
|
|
new Point(-1, 1),
|
|
new Point(0, 1),
|
|
new Point(1, 1),
|
|
]),
|
|
t
|
|
);
|
|
})(),
|
|
WeightedGridGraph = (function () {
|
|
function t(e, n, i) {
|
|
void 0 === i && (i = !1),
|
|
(this.walls = []),
|
|
(this.weightedNodes = []),
|
|
(this.defaultWeight = 1),
|
|
(this.weightedNodeWeight = 5),
|
|
(this._neighbors = new Array(4)),
|
|
(this._width = e),
|
|
(this._height = n),
|
|
(this._dirs = i ? t.COMPASS_DIRS : t.CARDINAL_DIRS);
|
|
}
|
|
return (
|
|
(t.prototype.isNodeInBounds = function (t) {
|
|
return 0 <= t.x && t.x < this._width && 0 <= t.y && t.y < this._height;
|
|
}),
|
|
(t.prototype.isNodePassable = function (t) {
|
|
return !this.walls.firstOrDefault(function (e) {
|
|
return JSON.stringify(e) == JSON.stringify(t);
|
|
});
|
|
}),
|
|
(t.prototype.search = function (t, e) {
|
|
return WeightedPathfinder.search(this, t, e);
|
|
}),
|
|
(t.prototype.getNeighbors = function (t) {
|
|
var e = this;
|
|
return (
|
|
(this._neighbors.length = 0),
|
|
this._dirs.forEach(function (n) {
|
|
var i = new Point(t.x + n.x, t.y + n.y);
|
|
e.isNodeInBounds(i) && e.isNodePassable(i) && e._neighbors.push(i);
|
|
}),
|
|
this._neighbors
|
|
);
|
|
}),
|
|
(t.prototype.cost = function (t, e) {
|
|
return this.weightedNodes.find(function (t) {
|
|
return JSON.stringify(t) == JSON.stringify(e);
|
|
})
|
|
? this.weightedNodeWeight
|
|
: this.defaultWeight;
|
|
}),
|
|
(t.CARDINAL_DIRS = [
|
|
new Point(1, 0),
|
|
new Point(0, -1),
|
|
new Point(-1, 0),
|
|
new Point(0, 1),
|
|
]),
|
|
(t.COMPASS_DIRS = [
|
|
new Point(1, 0),
|
|
new Point(1, -1),
|
|
new Point(0, -1),
|
|
new Point(-1, -1),
|
|
new Point(-1, 0),
|
|
new Point(-1, 1),
|
|
new Point(0, 1),
|
|
new Point(1, 1),
|
|
]),
|
|
t
|
|
);
|
|
})(),
|
|
WeightedNode = (function (t) {
|
|
function e(e) {
|
|
var n = t.call(this) || this;
|
|
return (n.data = e), n;
|
|
}
|
|
return __extends(e, t), e;
|
|
})(PriorityQueueNode),
|
|
WeightedPathfinder = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.search = function (t, e, n) {
|
|
var i = this,
|
|
o = !1,
|
|
r = new Map();
|
|
r.set(e, e);
|
|
var s = new Map(),
|
|
a = new PriorityQueue(1e3);
|
|
a.enqueue(new WeightedNode(e), 0), s.set(e, 0);
|
|
for (
|
|
var h = function () {
|
|
var e = a.dequeue();
|
|
if (JSON.stringify(e.data) == JSON.stringify(n))
|
|
return (o = !0), "break";
|
|
t.getNeighbors(e.data).forEach(function (n) {
|
|
var o = s.get(e.data) + t.cost(e.data, n);
|
|
if (!i.hasKey(s, n) || o < s.get(n)) {
|
|
s.set(n, o);
|
|
var h = o;
|
|
a.enqueue(new WeightedNode(n), h), r.set(n, e.data);
|
|
}
|
|
});
|
|
};
|
|
a.count > 0;
|
|
|
|
) {
|
|
if ("break" === h()) break;
|
|
}
|
|
return o ? this.recontructPath(r, e, n) : null;
|
|
}),
|
|
(t.hasKey = function (t, e) {
|
|
for (var n, i = t.keys(); !(n = i.next()).done; )
|
|
if (JSON.stringify(n.value) == JSON.stringify(e)) return !0;
|
|
return !1;
|
|
}),
|
|
(t.getKey = function (t, e) {
|
|
for (
|
|
var n, i, o = t.keys(), r = t.values();
|
|
(n = o.next()), (i = r.next()), !n.done;
|
|
|
|
)
|
|
if (JSON.stringify(n.value) == JSON.stringify(e)) return i.value;
|
|
return null;
|
|
}),
|
|
(t.recontructPath = function (t, e, n) {
|
|
var i = [],
|
|
o = n;
|
|
for (i.push(n); o != e; ) (o = this.getKey(t, o)), i.push(o);
|
|
return i.reverse(), i;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
DebugDefaults = (function () {
|
|
function t() {}
|
|
return (t.verletParticle = 14431326), (t.verletConstraintEdge = 4406838), t;
|
|
})(),
|
|
Component = (function (t) {
|
|
function e() {
|
|
var e = (null !== t && t.apply(this, arguments)) || this;
|
|
return (e._enabled = !0), (e.updateInterval = 1), e;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "enabled", {
|
|
get: function () {
|
|
return this.entity
|
|
? this.entity.enabled && this._enabled
|
|
: this._enabled;
|
|
},
|
|
set: function (t) {
|
|
this.setEnabled(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.setEnabled = function (t) {
|
|
return (
|
|
this._enabled != t &&
|
|
((this._enabled = t),
|
|
this._enabled ? this.onEnabled() : this.onDisabled()),
|
|
this
|
|
);
|
|
}),
|
|
(e.prototype.initialize = function () {}),
|
|
(e.prototype.onAddedToEntity = function () {}),
|
|
(e.prototype.onRemovedFromEntity = function () {}),
|
|
(e.prototype.onEnabled = function () {}),
|
|
(e.prototype.onDisabled = function () {}),
|
|
(e.prototype.onEntityTransformChanged = function (t) {}),
|
|
(e.prototype.update = function () {}),
|
|
(e.prototype.debugRender = function () {}),
|
|
(e.prototype.registerComponent = function () {
|
|
this.entity.componentBits.set(
|
|
ComponentTypeManager.getIndexFor(this),
|
|
!1
|
|
),
|
|
this.entity.scene.entityProcessors.onComponentAdded(this.entity);
|
|
}),
|
|
(e.prototype.deregisterComponent = function () {
|
|
this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this)),
|
|
this.entity.scene.entityProcessors.onComponentRemoved(this.entity);
|
|
}),
|
|
e
|
|
);
|
|
})(egret.DisplayObjectContainer),
|
|
Entity = (function (t) {
|
|
function e(n) {
|
|
var i = t.call(this) || this;
|
|
return (
|
|
(i._position = Vector2.zero),
|
|
(i._updateOrder = 0),
|
|
(i._enabled = !0),
|
|
(i._tag = 0),
|
|
(i.name = n),
|
|
(i.components = new ComponentList(i)),
|
|
(i.id = e._idGenerator++),
|
|
(i.componentBits = new BitSet()),
|
|
i
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "isDestoryed", {
|
|
get: function () {
|
|
return this._isDestoryed;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "position", {
|
|
get: function () {
|
|
return this._position;
|
|
},
|
|
set: function (t) {
|
|
this._position = t;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "scale", {
|
|
get: function () {
|
|
return new Vector2(this.scaleX, this.scaleY);
|
|
},
|
|
set: function (t) {
|
|
(this.scaleX = t.x), (this.scaleY = t.y);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "enabled", {
|
|
get: function () {
|
|
return this._enabled;
|
|
},
|
|
set: function (t) {
|
|
this.setEnabled(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.setEnabled = function (t) {
|
|
return this._enabled != t && (this._enabled = t), this;
|
|
}),
|
|
Object.defineProperty(e.prototype, "tag", {
|
|
get: function () {
|
|
return this._tag;
|
|
},
|
|
set: function (t) {
|
|
this.setTag(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "stage", {
|
|
get: function () {
|
|
return this.scene ? this.scene.stage : null;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "updateOrder", {
|
|
get: function () {
|
|
return this._updateOrder;
|
|
},
|
|
set: function (t) {
|
|
this.setUpdateOrder(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.roundPosition = function () {
|
|
this.position = Vector2Ext.round(this.position);
|
|
}),
|
|
(e.prototype.setUpdateOrder = function (t) {
|
|
if (this._updateOrder != t)
|
|
return (this._updateOrder = t), this.scene, this;
|
|
}),
|
|
(e.prototype.setTag = function (t) {
|
|
return (
|
|
this._tag != t &&
|
|
(this.scene && this.scene.entities.removeFromTagList(this),
|
|
(this._tag = t),
|
|
this.scene && this.scene.entities.addToTagList(this)),
|
|
this
|
|
);
|
|
}),
|
|
(e.prototype.attachToScene = function (t) {
|
|
(this.scene = t),
|
|
t.entities.add(this),
|
|
this.components.registerAllComponents();
|
|
for (var e = 0; e < this.numChildren; e++)
|
|
this.getChildAt(e).entity.attachToScene(t);
|
|
}),
|
|
(e.prototype.detachFromScene = function () {
|
|
this.scene.entities.remove(this),
|
|
this.components.deregisterAllComponents();
|
|
for (var t = 0; t < this.numChildren; t++)
|
|
this.getChildAt(t).entity.detachFromScene();
|
|
}),
|
|
(e.prototype.addComponent = function (t) {
|
|
return (
|
|
(t.entity = this),
|
|
this.components.add(t),
|
|
this.addChild(t),
|
|
t.initialize(),
|
|
t
|
|
);
|
|
}),
|
|
(e.prototype.hasComponent = function (t) {
|
|
return null != this.components.getComponent(t, !1);
|
|
}),
|
|
(e.prototype.getOrCreateComponent = function (t) {
|
|
var e = this.components.getComponent(t, !0);
|
|
return e || (e = this.addComponent(t)), e;
|
|
}),
|
|
(e.prototype.getComponent = function (t) {
|
|
return this.components.getComponent(t, !1);
|
|
}),
|
|
(e.prototype.getComponents = function (t, e) {
|
|
return this.components.getComponents(t, e);
|
|
}),
|
|
(e.prototype.removeComponentForType = function (t) {
|
|
var e = this.getComponent(t);
|
|
return !!e && (this.removeComponent(e), !0);
|
|
}),
|
|
(e.prototype.removeComponent = function (t) {
|
|
this.components.remove(t);
|
|
}),
|
|
(e.prototype.removeAllComponents = function () {
|
|
for (var t = 0; t < this.components.count; t++)
|
|
this.removeComponent(this.components.buffer[t]);
|
|
}),
|
|
(e.prototype.update = function () {
|
|
this.components.update();
|
|
}),
|
|
(e.prototype.onAddedToScene = function () {}),
|
|
(e.prototype.onRemovedFromScene = function () {
|
|
this._isDestoryed && this.components.removeAllComponents();
|
|
}),
|
|
(e.prototype.onTransformChanged = function (t) {
|
|
this.components.onEntityTransformChanged(t);
|
|
}),
|
|
(e.prototype.destroy = function () {
|
|
(this._isDestoryed = !0),
|
|
this.scene.entities.remove(this),
|
|
this.removeChildren();
|
|
for (var t = this.numChildren - 1; t >= 0; t--) {
|
|
this.getChildAt(t).entity.destroy();
|
|
}
|
|
}),
|
|
e
|
|
);
|
|
})(egret.DisplayObjectContainer),
|
|
Scene = (function (t) {
|
|
function e() {
|
|
var e = t.call(this) || this;
|
|
return (
|
|
(e.enablePostProcessing = !0),
|
|
(e._renderers = []),
|
|
(e._postProcessors = []),
|
|
(e.entityProcessors = new EntityProcessorList()),
|
|
(e.renderableComponents = new RenderableComponentList()),
|
|
(e.entities = new EntityList(e)),
|
|
(e.content = new ContentManager()),
|
|
(e.width = SceneManager.stage.stageWidth),
|
|
(e.height = SceneManager.stage.stageHeight),
|
|
e.addEventListener(egret.Event.ACTIVATE, e.onActive, e),
|
|
e.addEventListener(egret.Event.DEACTIVATE, e.onDeactive, e),
|
|
e
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.createEntity = function (t) {
|
|
var e = new Entity(t);
|
|
return (e.position = new Vector2(0, 0)), this.addEntity(e);
|
|
}),
|
|
(e.prototype.addEntity = function (t) {
|
|
this.entities.add(t), (t.scene = this), this.addChild(t);
|
|
for (var e = 0; e < t.numChildren; e++)
|
|
this.addEntity(t.getChildAt(e).entity);
|
|
return t;
|
|
}),
|
|
(e.prototype.destroyAllEntities = function () {
|
|
for (var t = 0; t < this.entities.count; t++)
|
|
this.entities.buffer[t].destroy();
|
|
}),
|
|
(e.prototype.findEntity = function (t) {
|
|
return this.entities.findEntity(t);
|
|
}),
|
|
(e.prototype.addEntityProcessor = function (t) {
|
|
return (t.scene = this), this.entityProcessors.add(t), t;
|
|
}),
|
|
(e.prototype.removeEntityProcessor = function (t) {
|
|
this.entityProcessors.remove(t);
|
|
}),
|
|
(e.prototype.getEntityProcessor = function () {
|
|
return this.entityProcessors.getProcessor();
|
|
}),
|
|
(e.prototype.addRenderer = function (t) {
|
|
return (
|
|
this._renderers.push(t),
|
|
this._renderers.sort(),
|
|
t.onAddedToScene(this),
|
|
t
|
|
);
|
|
}),
|
|
(e.prototype.getRenderer = function (t) {
|
|
for (var e = 0; e < this._renderers.length; e++)
|
|
if (this._renderers[e] instanceof t) return this._renderers[e];
|
|
return null;
|
|
}),
|
|
(e.prototype.removeRenderer = function (t) {
|
|
this._renderers.remove(t), t.unload();
|
|
}),
|
|
(e.prototype.begin = function () {
|
|
SceneManager.sceneTransition
|
|
? SceneManager.stage.addChildAt(
|
|
this,
|
|
SceneManager.stage.numChildren - 1
|
|
)
|
|
: SceneManager.stage.addChild(this),
|
|
0 == this._renderers.length &&
|
|
(this.addRenderer(new DefaultRenderer()),
|
|
console.warn(
|
|
"场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染"
|
|
)),
|
|
(this.camera = this.createEntity("camera").getOrCreateComponent(
|
|
new Camera()
|
|
)),
|
|
Physics.reset(),
|
|
this.entityProcessors && this.entityProcessors.begin(),
|
|
this.camera.onSceneSizeChanged(
|
|
this.stage.stageWidth,
|
|
this.stage.stageHeight
|
|
),
|
|
(this._didSceneBegin = !0),
|
|
this.onStart();
|
|
}),
|
|
(e.prototype.end = function () {
|
|
(this._didSceneBegin = !1),
|
|
this.removeEventListener(
|
|
egret.Event.DEACTIVATE,
|
|
this.onDeactive,
|
|
this
|
|
),
|
|
this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
|
|
for (var t = 0; t < this._renderers.length; t++)
|
|
this._renderers[t].unload();
|
|
for (t = 0; t < this._postProcessors.length; t++)
|
|
this._postProcessors[t].unload();
|
|
this.entities.removeAllEntities(),
|
|
this.removeChildren(),
|
|
Physics.clear(),
|
|
(this.camera = null),
|
|
this.content.dispose(),
|
|
this.entityProcessors && this.entityProcessors.end(),
|
|
this.unload();
|
|
}),
|
|
(e.prototype.onStart = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (t) {
|
|
return [2];
|
|
});
|
|
});
|
|
}),
|
|
(e.prototype.onActive = function () {}),
|
|
(e.prototype.onDeactive = function () {}),
|
|
(e.prototype.unload = function () {}),
|
|
(e.prototype.update = function () {
|
|
this.entities.updateLists(),
|
|
this.entityProcessors && this.entityProcessors.update(),
|
|
this.entities.update(),
|
|
this.entityProcessors && this.entityProcessors.lateUpdate(),
|
|
this.renderableComponents.updateList();
|
|
}),
|
|
(e.prototype.postRender = function () {
|
|
var t = 0;
|
|
if (this.enablePostProcessing)
|
|
for (var e = 0; e < this._postProcessors.length; e++)
|
|
if (this._postProcessors[e].enable) {
|
|
MathHelper.isEven(t);
|
|
t++, this._postProcessors[e].process();
|
|
}
|
|
}),
|
|
(e.prototype.render = function () {
|
|
for (var t = 0; t < this._renderers.length; t++)
|
|
this._renderers[t].render(this);
|
|
}),
|
|
(e.prototype.addPostProcessor = function (t) {
|
|
return (
|
|
this._postProcessors.push(t),
|
|
this._postProcessors.sort(),
|
|
t.onAddedToScene(this),
|
|
this._didSceneBegin &&
|
|
t.onSceneBackBufferSizeChanged(
|
|
this.stage.stageWidth,
|
|
this.stage.stageHeight
|
|
),
|
|
t
|
|
);
|
|
}),
|
|
e
|
|
);
|
|
})(egret.DisplayObjectContainer),
|
|
SceneManager = (function () {
|
|
function t(e) {
|
|
e.addEventListener(egret.Event.ENTER_FRAME, t.update, this),
|
|
(t.stage = e),
|
|
t.initialize(e);
|
|
}
|
|
return (
|
|
Object.defineProperty(t, "scene", {
|
|
get: function () {
|
|
return this._scene;
|
|
},
|
|
set: function (t) {
|
|
if (!t) throw new Error("场景不能为空");
|
|
null == this._scene
|
|
? ((this._scene = t), this._scene.begin())
|
|
: (this._nextScene = t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.initialize = function (t) {
|
|
Input.initialize(t);
|
|
}),
|
|
(t.update = function () {
|
|
if ((Time.update(egret.getTimer()), t._scene)) {
|
|
for (var e = GlobalManager.globalManagers.length - 1; e >= 0; e--)
|
|
GlobalManager.globalManagers[e].enabled &&
|
|
GlobalManager.globalManagers[e].update();
|
|
if (
|
|
((t.sceneTransition &&
|
|
(!t.sceneTransition ||
|
|
(t.sceneTransition.loadsNewScene &&
|
|
!t.sceneTransition.isNewSceneLoaded))) ||
|
|
t._scene.update(),
|
|
t._nextScene)
|
|
) {
|
|
t._scene.end();
|
|
for (e = 0; e < t._scene.entities.buffer.length; e++) {
|
|
t._scene.entities.buffer[e].destroy();
|
|
}
|
|
(t._scene = t._nextScene), (t._nextScene = null), t._scene.begin();
|
|
}
|
|
}
|
|
t.render();
|
|
}),
|
|
(t.render = function () {
|
|
this.sceneTransition
|
|
? (this.sceneTransition.preRender(),
|
|
this._scene && !this.sceneTransition.hasPreviousSceneRender
|
|
? (this._scene.render(),
|
|
this._scene.postRender(),
|
|
this.sceneTransition.onBeginTransition())
|
|
: this.sceneTransition &&
|
|
(this._scene &&
|
|
this.sceneTransition.isNewSceneLoaded &&
|
|
(this._scene.render(), this._scene.postRender()),
|
|
this.sceneTransition.render()))
|
|
: this._scene && (this._scene.render(), this._scene.postRender());
|
|
}),
|
|
(t.startSceneTransition = function (t) {
|
|
if (!this.sceneTransition) return (this.sceneTransition = t), t;
|
|
console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
|
|
}),
|
|
t
|
|
);
|
|
})();
|
|
!(function (t) {
|
|
(t[(t.clean = 0)] = "clean"),
|
|
(t[(t.positionDirty = 1)] = "positionDirty"),
|
|
(t[(t.scaleDirty = 2)] = "scaleDirty"),
|
|
(t[(t.rotationDirty = 3)] = "rotationDirty");
|
|
})(DirtyType || (DirtyType = {})),
|
|
(function (t) {
|
|
(t[(t.position = 0)] = "position"),
|
|
(t[(t.scale = 1)] = "scale"),
|
|
(t[(t.rotation = 2)] = "rotation");
|
|
})(ComponentTransform || (ComponentTransform = {}));
|
|
var CameraStyle,
|
|
Transform = (function () {
|
|
function t(t) {
|
|
(this._localRotation = 0),
|
|
(this._worldTransform = Matrix2D.identity),
|
|
(this._worldToLocalTransform = Matrix2D.identity),
|
|
(this._worldInverseTransform = Matrix2D.identity),
|
|
(this._rotation = 0),
|
|
(this.entity = t),
|
|
(this._scale = this._localScale = Vector2.one),
|
|
(this._children = []);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "childCount", {
|
|
get: function () {
|
|
return this._children.length;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.getChild = function (t) {
|
|
return this._children[t];
|
|
}),
|
|
Object.defineProperty(t.prototype, "worldInverseTransform", {
|
|
get: function () {
|
|
return (
|
|
this.updateTransform(),
|
|
this._worldInverseDirty &&
|
|
((this._worldInverseTransform = Matrix2D.invert(
|
|
this._worldTransform,
|
|
this._worldInverseTransform
|
|
)),
|
|
(this._worldInverseDirty = !1)),
|
|
this._worldInverseTransform
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "localToWorldTransform", {
|
|
get: function () {
|
|
return this.updateTransform(), this._worldTransform;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "worldToLocalTransform", {
|
|
get: function () {
|
|
return (
|
|
this._worldToLocalDirty &&
|
|
(this.parent
|
|
? (this.parent.updateTransform(),
|
|
(this._worldToLocalTransform = Matrix2D.invert(
|
|
this.parent._worldTransform,
|
|
this._worldToLocalTransform
|
|
)))
|
|
: (this._worldInverseTransform = new Matrix2D()),
|
|
(this._worldToLocalDirty = !1)),
|
|
this._worldToLocalTransform
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "parent", {
|
|
get: function () {
|
|
return this._parent;
|
|
},
|
|
set: function (t) {
|
|
this.setParent(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.setParent = function (t) {
|
|
return this._parent == t
|
|
? this
|
|
: (this._parent && this._parent._children.remove(this),
|
|
t && t._children.push(this),
|
|
(this._parent = t),
|
|
this);
|
|
}),
|
|
Object.defineProperty(t.prototype, "rotation", {
|
|
get: function () {
|
|
return this.updateTransform(), this._rotation;
|
|
},
|
|
set: function (t) {
|
|
this.setRotation(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "localRotation", {
|
|
get: function () {
|
|
return this.updateTransform(), this._localRotation;
|
|
},
|
|
set: function (t) {
|
|
this.setLocalRotation(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "position", {
|
|
get: function () {
|
|
return (
|
|
this.updateTransform(),
|
|
this._positionDirty &&
|
|
(this.parent
|
|
? (this.parent.updateTransform(),
|
|
(this._position = Vector2Ext.transformR(
|
|
this._localPosition,
|
|
this.parent._worldTransform
|
|
)))
|
|
: (this._position = this._localPosition),
|
|
(this._positionDirty = !1)),
|
|
this._position
|
|
);
|
|
},
|
|
set: function (t) {
|
|
this.setPosition(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "localPosition", {
|
|
get: function () {
|
|
return this.updateTransform(), this._localPosition;
|
|
},
|
|
set: function (t) {
|
|
this.setLocalPosition(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "scale", {
|
|
get: function () {
|
|
return this.updateTransform(), this._scale;
|
|
},
|
|
set: function (t) {
|
|
this.setScale(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "localScale", {
|
|
get: function () {
|
|
return this.updateTransform(), this._localScale;
|
|
},
|
|
set: function (t) {
|
|
this.setLocalScale(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "rotationDegrees", {
|
|
get: function () {
|
|
return MathHelper.toDegrees(this._rotation);
|
|
},
|
|
set: function (t) {
|
|
this.setRotation(MathHelper.toRadians(t));
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "localRotationDegrees", {
|
|
get: function () {
|
|
return MathHelper.toDegrees(this._localRotation);
|
|
},
|
|
set: function (t) {
|
|
this.localRotation = MathHelper.toRadians(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.setLocalScale = function (t) {
|
|
return (
|
|
(this._localScale = t),
|
|
(this._localDirty = this._positionDirty = this._localScaleDirty = !0),
|
|
this.setDirty(DirtyType.scaleDirty),
|
|
this
|
|
);
|
|
}),
|
|
(t.prototype.setScale = function (t) {
|
|
return (
|
|
(this._scale = t),
|
|
this.parent
|
|
? (this.localScale = Vector2.divide(t, this.parent._scale))
|
|
: (this.localScale = t),
|
|
this
|
|
);
|
|
}),
|
|
(t.prototype.setLocalRotationDegrees = function (t) {
|
|
return this.setLocalRotation(MathHelper.toRadians(t));
|
|
}),
|
|
(t.prototype.setLocalRotation = function (t) {
|
|
return (
|
|
(this._localRotation = t),
|
|
(this._localDirty = this._positionDirty = this._localPositionDirty = this._localRotationDirty = this._localScaleDirty = !0),
|
|
this.setDirty(DirtyType.rotationDirty),
|
|
this
|
|
);
|
|
}),
|
|
(t.prototype.setRotation = function (t) {
|
|
return (
|
|
(this._rotation = t),
|
|
this.parent
|
|
? (this.localRotation = this.parent.rotation + t)
|
|
: (this.localRotation = t),
|
|
this
|
|
);
|
|
}),
|
|
(t.prototype.setRotationDegrees = function (t) {
|
|
return this.setRotation(MathHelper.toRadians(t));
|
|
}),
|
|
(t.prototype.setLocalPosition = function (t) {
|
|
return t == this._localPosition
|
|
? this
|
|
: ((this._localPosition = t),
|
|
(this._localDirty = this._positionDirty = this._localPositionDirty = this._localRotationDirty = this._localScaleDirty = !0),
|
|
this.setDirty(DirtyType.positionDirty),
|
|
this);
|
|
}),
|
|
(t.prototype.setPosition = function (t) {
|
|
return t == this._position
|
|
? this
|
|
: ((this._position = t),
|
|
this.parent
|
|
? (this.localPosition = Vector2.transform(
|
|
this._position,
|
|
this._worldToLocalTransform
|
|
))
|
|
: (this.localPosition = t),
|
|
(this._positionDirty = !1),
|
|
this);
|
|
}),
|
|
(t.prototype.setDirty = function (t) {
|
|
if (0 == (this._hierachyDirty & t)) {
|
|
switch (((this._hierachyDirty |= t), t)) {
|
|
case DirtyType.positionDirty:
|
|
this.entity.onTransformChanged(ComponentTransform.position);
|
|
break;
|
|
case DirtyType.rotationDirty:
|
|
this.entity.onTransformChanged(ComponentTransform.rotation);
|
|
break;
|
|
case DirtyType.scaleDirty:
|
|
this.entity.onTransformChanged(ComponentTransform.scale);
|
|
}
|
|
null == this._children && (this._children = []);
|
|
for (var e = 0; e < this._children.length; e++)
|
|
this._children[e].setDirty(t);
|
|
}
|
|
}),
|
|
(t.prototype.roundPosition = function () {
|
|
this.position = this._position.round();
|
|
}),
|
|
(t.prototype.updateTransform = function () {
|
|
this._hierachyDirty != DirtyType.clean &&
|
|
(this.parent && this.parent.updateTransform(),
|
|
this._localDirty &&
|
|
(this._localPositionDirty &&
|
|
((this._translationMatrix = Matrix2D.createTranslation(
|
|
this._localPosition.x,
|
|
this._localPosition.y
|
|
)),
|
|
(this._localPositionDirty = !1)),
|
|
this._localRotationDirty &&
|
|
((this._rotationMatrix = Matrix2D.createRotation(
|
|
this._localRotation
|
|
)),
|
|
(this._localRotationDirty = !1)),
|
|
this._localScaleDirty &&
|
|
((this._scaleMatrix = Matrix2D.createScale(
|
|
this._localScale.x,
|
|
this._localScale.y
|
|
)),
|
|
(this._localScaleDirty = !1)),
|
|
(this._localTransform = Matrix2D.multiply(
|
|
this._scaleMatrix,
|
|
this._rotationMatrix
|
|
)),
|
|
(this._localTransform = Matrix2D.multiply(
|
|
this._localTransform,
|
|
this._translationMatrix
|
|
)),
|
|
this.parent ||
|
|
((this._worldTransform = this._localTransform),
|
|
(this._rotation = this._localRotation),
|
|
(this._scale = this._localScale),
|
|
(this._worldInverseDirty = !0)),
|
|
(this._localDirty = !1)),
|
|
this.parent &&
|
|
((this._worldTransform = Matrix2D.multiply(
|
|
this._localTransform,
|
|
this.parent._worldTransform
|
|
)),
|
|
(this._rotation = this._localRotation + this.parent._rotation),
|
|
(this._scale = Vector2.multiply(
|
|
this.parent._scale,
|
|
this._localScale
|
|
)),
|
|
(this._worldInverseDirty = !0)),
|
|
(this._worldToLocalDirty = !0),
|
|
(this._positionDirty = !0),
|
|
(this._hierachyDirty = DirtyType.clean));
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Camera = (function (t) {
|
|
function e() {
|
|
var e = t.call(this) || this;
|
|
return (
|
|
(e._origin = Vector2.zero),
|
|
(e._minimumZoom = 0.3),
|
|
(e._maximumZoom = 3),
|
|
(e.followLerp = 0.1),
|
|
(e.deadzone = new Rectangle()),
|
|
(e.focusOffset = new Vector2()),
|
|
(e.mapLockEnabled = !1),
|
|
(e.mapSize = new Vector2()),
|
|
(e._worldSpaceDeadZone = new Rectangle()),
|
|
(e._desiredPositionDelta = new Vector2()),
|
|
(e.cameraStyle = CameraStyle.lockOn),
|
|
(e.width = SceneManager.stage.stageWidth),
|
|
(e.height = SceneManager.stage.stageHeight),
|
|
e.setZoom(0),
|
|
e
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "zoom", {
|
|
get: function () {
|
|
return 0 == this._zoom
|
|
? 1
|
|
: this._zoom < 1
|
|
? MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0)
|
|
: MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
|
|
},
|
|
set: function (t) {
|
|
this.setZoom(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "minimumZoom", {
|
|
get: function () {
|
|
return this._minimumZoom;
|
|
},
|
|
set: function (t) {
|
|
this.setMinimumZoom(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "maximumZoom", {
|
|
get: function () {
|
|
return this._maximumZoom;
|
|
},
|
|
set: function (t) {
|
|
this.setMaximumZoom(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "origin", {
|
|
get: function () {
|
|
return this._origin;
|
|
},
|
|
set: function (t) {
|
|
this._origin != t && (this._origin = t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "position", {
|
|
get: function () {
|
|
return this.entity.position;
|
|
},
|
|
set: function (t) {
|
|
this.entity.position = t;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.onSceneSizeChanged = function (t, e) {
|
|
var n = this._origin;
|
|
(this.origin = new Vector2(t / 2, e / 2)),
|
|
(this.entity.position = Vector2.add(
|
|
this.entity.position,
|
|
Vector2.subtract(this._origin, n)
|
|
));
|
|
}),
|
|
(e.prototype.setMinimumZoom = function (t) {
|
|
return (
|
|
this._zoom < t && (this._zoom = this.minimumZoom),
|
|
(this._minimumZoom = t),
|
|
this
|
|
);
|
|
}),
|
|
(e.prototype.setMaximumZoom = function (t) {
|
|
return (
|
|
this._zoom > t && (this._zoom = t), (this._maximumZoom = t), this
|
|
);
|
|
}),
|
|
(e.prototype.setZoom = function (t) {
|
|
var e = MathHelper.clamp(t, -1, 1);
|
|
return (
|
|
(this._zoom =
|
|
0 == e
|
|
? 1
|
|
: e < 0
|
|
? MathHelper.map(e, -1, 0, this._minimumZoom, 1)
|
|
: MathHelper.map(e, 0, 1, 1, this._maximumZoom)),
|
|
(SceneManager.scene.scaleX = this._zoom),
|
|
(SceneManager.scene.scaleY = this._zoom),
|
|
this
|
|
);
|
|
}),
|
|
(e.prototype.setRotation = function (t) {
|
|
return (SceneManager.scene.rotation = t), this;
|
|
}),
|
|
(e.prototype.setPosition = function (t) {
|
|
return (this.entity.position = t), this;
|
|
}),
|
|
(e.prototype.follow = function (t, e) {
|
|
void 0 === e && (e = CameraStyle.cameraWindow),
|
|
(this.targetEntity = t),
|
|
(this.cameraStyle = e);
|
|
var n = new Rectangle(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
);
|
|
switch (this.cameraStyle) {
|
|
case CameraStyle.cameraWindow:
|
|
var i = n.width / 6,
|
|
o = n.height / 3;
|
|
this.deadzone = new Rectangle(
|
|
(n.width - i) / 2,
|
|
(n.height - o) / 2,
|
|
i,
|
|
o
|
|
);
|
|
break;
|
|
case CameraStyle.lockOn:
|
|
this.deadzone = new Rectangle(n.width / 2, n.height / 2, 10, 10);
|
|
}
|
|
}),
|
|
(e.prototype.update = function () {
|
|
var t = new Rectangle(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
),
|
|
e = Vector2.multiply(
|
|
new Vector2(t.width, t.height),
|
|
new Vector2(0.5)
|
|
);
|
|
(this._worldSpaceDeadZone.x =
|
|
this.position.x - e.x + this.deadzone.x + this.focusOffset.x),
|
|
(this._worldSpaceDeadZone.y =
|
|
this.position.y - e.y + this.deadzone.y + this.focusOffset.y),
|
|
(this._worldSpaceDeadZone.width = this.deadzone.width),
|
|
(this._worldSpaceDeadZone.height = this.deadzone.height),
|
|
this.targetEntity && this.updateFollow(),
|
|
(this.position = Vector2.lerp(
|
|
this.position,
|
|
Vector2.add(this.position, this._desiredPositionDelta),
|
|
this.followLerp
|
|
)),
|
|
this.entity.roundPosition(),
|
|
this.mapLockEnabled &&
|
|
((this.position = this.clampToMapSize(this.position)),
|
|
this.entity.roundPosition());
|
|
}),
|
|
(e.prototype.clampToMapSize = function (t) {
|
|
var e = new Rectangle(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
),
|
|
n = Vector2.multiply(
|
|
new Vector2(e.width, e.height),
|
|
new Vector2(0.5)
|
|
),
|
|
i = new Vector2(this.mapSize.x - n.x, this.mapSize.y - n.y);
|
|
return Vector2.clamp(t, n, i);
|
|
}),
|
|
(e.prototype.updateFollow = function () {
|
|
if (
|
|
((this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0),
|
|
this.cameraStyle == CameraStyle.lockOn)
|
|
) {
|
|
var t = this.targetEntity.position.x,
|
|
e = this.targetEntity.position.y;
|
|
this._worldSpaceDeadZone.x > t
|
|
? (this._desiredPositionDelta.x = t - this._worldSpaceDeadZone.x)
|
|
: this._worldSpaceDeadZone.x < t &&
|
|
(this._desiredPositionDelta.x = t - this._worldSpaceDeadZone.x),
|
|
this._worldSpaceDeadZone.y < e
|
|
? (this._desiredPositionDelta.y = e - this._worldSpaceDeadZone.y)
|
|
: this._worldSpaceDeadZone.y > e &&
|
|
(this._desiredPositionDelta.y = e - this._worldSpaceDeadZone.y);
|
|
} else {
|
|
if (
|
|
!this._targetCollider &&
|
|
((this._targetCollider = this.targetEntity.getComponent(Collider)),
|
|
!this._targetCollider)
|
|
)
|
|
return;
|
|
var n = this.targetEntity.getComponent(Collider).bounds;
|
|
this._worldSpaceDeadZone.containsRect(n) ||
|
|
(this._worldSpaceDeadZone.left > n.left
|
|
? (this._desiredPositionDelta.x =
|
|
n.left - this._worldSpaceDeadZone.left)
|
|
: this._worldSpaceDeadZone.right < n.right &&
|
|
(this._desiredPositionDelta.x =
|
|
n.right - this._worldSpaceDeadZone.right),
|
|
this._worldSpaceDeadZone.bottom < n.bottom
|
|
? (this._desiredPositionDelta.y =
|
|
n.bottom - this._worldSpaceDeadZone.bottom)
|
|
: this._worldSpaceDeadZone.top > n.top &&
|
|
(this._desiredPositionDelta.y =
|
|
n.top - this._worldSpaceDeadZone.top));
|
|
}
|
|
}),
|
|
e
|
|
);
|
|
})(Component);
|
|
!(function (t) {
|
|
(t[(t.lockOn = 0)] = "lockOn"), (t[(t.cameraWindow = 1)] = "cameraWindow");
|
|
})(CameraStyle || (CameraStyle = {}));
|
|
var PointSectors,
|
|
ComponentPool = (function () {
|
|
function t(t) {
|
|
(this._type = t), (this._cache = []);
|
|
}
|
|
return (
|
|
(t.prototype.obtain = function () {
|
|
try {
|
|
return this._cache.length > 0
|
|
? this._cache.shift()
|
|
: new this._type();
|
|
} catch (t) {
|
|
throw new Error(this._type + t);
|
|
}
|
|
}),
|
|
(t.prototype.free = function (t) {
|
|
t.reset(), this._cache.push(t);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Mesh = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.initialize = function () {}),
|
|
(e.prototype.setVertPosition = function (t) {
|
|
(!this._verts || this._verts.length != t.length) &&
|
|
(this._verts = new Array(t.length));
|
|
for (var e = 0; e < this._verts.length; e++)
|
|
this._verts[e] = new VertexPosition(t[e]);
|
|
return this;
|
|
}),
|
|
(e.prototype.setTriangles = function (t) {
|
|
return (
|
|
(this._primitiveCount = t.length / 3), (this._triangles = t), this
|
|
);
|
|
}),
|
|
(e.prototype.recalculateBounds = function () {
|
|
this._topLeftVertPosition = new Vector2(
|
|
Number.MAX_VALUE,
|
|
Number.MAX_VALUE
|
|
);
|
|
for (
|
|
var t = new Vector2(Number.MIN_VALUE, Number.MIN_VALUE), e = 0;
|
|
e < this._verts.length;
|
|
e++
|
|
)
|
|
(this._topLeftVertPosition.x = Math.min(
|
|
this._topLeftVertPosition.x,
|
|
this._verts[e].position.x
|
|
)),
|
|
(this._topLeftVertPosition.y = Math.min(
|
|
this._topLeftVertPosition.y,
|
|
this._verts[e].position.y
|
|
)),
|
|
(t.x = Math.max(t.x, this._verts[e].position.x)),
|
|
(t.y = Math.max(t.y, this._verts[e].position.y));
|
|
return (
|
|
(this._width = t.x - this._topLeftVertPosition.x),
|
|
(this._height = t.y - this._topLeftVertPosition.y),
|
|
this
|
|
);
|
|
}),
|
|
(e.prototype.render = function () {}),
|
|
e
|
|
);
|
|
})(Component),
|
|
VertexPosition = (function () {
|
|
return function (t) {
|
|
this.position = t;
|
|
};
|
|
})(),
|
|
PolygonMesh = (function (t) {
|
|
function e(e, n) {
|
|
void 0 === n && (n = !0);
|
|
var i = t.call(this) || this,
|
|
o = new Triangulator();
|
|
return (
|
|
o.triangulate(e, n),
|
|
i.setVertPosition(e),
|
|
i.setTriangles(o.triangleIndices),
|
|
i.recalculateBounds(),
|
|
i
|
|
);
|
|
}
|
|
return __extends(e, t), e;
|
|
})(Mesh),
|
|
PooledComponent = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return __extends(e, t), e;
|
|
})(Component),
|
|
RenderableComponent = (function (t) {
|
|
function e() {
|
|
var e = (null !== t && t.apply(this, arguments)) || this;
|
|
return (
|
|
(e._areBoundsDirty = !0),
|
|
(e._bounds = new Rectangle()),
|
|
(e._localOffset = Vector2.zero),
|
|
(e.color = 0),
|
|
e
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "width", {
|
|
get: function () {
|
|
return this.getWidth();
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "height", {
|
|
get: function () {
|
|
return this.getHeight();
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "isVisible", {
|
|
get: function () {
|
|
return this._isVisible;
|
|
},
|
|
set: function (t) {
|
|
(this._isVisible = t),
|
|
this._isVisible ? this.onBecameVisible() : this.onBecameInvisible();
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "bounds", {
|
|
get: function () {
|
|
return new Rectangle(
|
|
this.getBounds().x,
|
|
this.getBounds().y,
|
|
this.getBounds().width,
|
|
this.getBounds().height
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.getWidth = function () {
|
|
return this.bounds.width;
|
|
}),
|
|
(e.prototype.getHeight = function () {
|
|
return this.bounds.height;
|
|
}),
|
|
(e.prototype.onBecameVisible = function () {}),
|
|
(e.prototype.onBecameInvisible = function () {}),
|
|
(e.prototype.isVisibleFromCamera = function (t) {
|
|
return (
|
|
(this.isVisible = t.getBounds().intersects(this.getBounds())),
|
|
this.isVisible
|
|
);
|
|
}),
|
|
(e.prototype.onEntityTransformChanged = function (t) {
|
|
this._areBoundsDirty = !0;
|
|
}),
|
|
e
|
|
);
|
|
})(PooledComponent),
|
|
ScreenSpaceCamera = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return __extends(e, t), (e.prototype.updateMatrixes = function () {}), e;
|
|
})(Camera),
|
|
Sprite = (function () {
|
|
return function (t, e, n) {
|
|
void 0 === e &&
|
|
(e = new Rectangle(0, 0, t.textureWidth, t.textureHeight)),
|
|
void 0 === n && (n = e.getHalfSize()),
|
|
(this.uvs = new Rectangle()),
|
|
(this.texture2D = t),
|
|
(this.sourceRect = e),
|
|
(this.center = new Vector2(0.5 * e.width, 0.5 * e.height)),
|
|
(this.origin = n);
|
|
var i = 1 / t.textureWidth,
|
|
o = 1 / t.textureHeight;
|
|
(this.uvs.x = e.x * i),
|
|
(this.uvs.y = e.y * o),
|
|
(this.uvs.width = e.width * i),
|
|
(this.uvs.height = e.height * o);
|
|
};
|
|
})(),
|
|
SpriteRenderer = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "origin", {
|
|
get: function () {
|
|
return this._origin;
|
|
},
|
|
set: function (t) {
|
|
this.setOrigin(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.setOrigin = function (t) {
|
|
return this._origin != t && (this._origin = t), this;
|
|
}),
|
|
(e.prototype.setSprite = function (t) {
|
|
return (
|
|
this.removeChildren(),
|
|
(this._sprite = t),
|
|
this._sprite && (this._origin = this._sprite.origin),
|
|
(this._bitmap = new egret.Bitmap(t.texture2D)),
|
|
this.addChild(this._bitmap),
|
|
this
|
|
);
|
|
}),
|
|
(e.prototype.setColor = function (t) {
|
|
var e = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
|
|
(e[0] = Math.floor(t / 256 / 256) / 255),
|
|
(e[6] = Math.floor((t / 256) % 256) / 255),
|
|
(e[12] = (t % 256) / 255);
|
|
var n = new egret.ColorMatrixFilter(e);
|
|
return (this.filters = [n]), this;
|
|
}),
|
|
(e.prototype.isVisibleFromCamera = function (t) {
|
|
return (
|
|
(this.isVisible = new Rectangle(
|
|
0,
|
|
0,
|
|
this.stage.stageWidth,
|
|
this.stage.stageHeight
|
|
).intersects(this.bounds)),
|
|
(this.visible = this.isVisible),
|
|
this.isVisible
|
|
);
|
|
}),
|
|
(e.prototype.render = function (t) {
|
|
(this.x =
|
|
this.entity.position.x - this.origin.x - t.position.x + t.origin.x),
|
|
(this.y =
|
|
this.entity.position.y - this.origin.y - t.position.y + t.origin.y);
|
|
}),
|
|
(e.prototype.onRemovedFromEntity = function () {
|
|
this.parent && this.parent.removeChild(this);
|
|
}),
|
|
(e.prototype.reset = function () {}),
|
|
e
|
|
);
|
|
})(RenderableComponent),
|
|
Mover = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.onAddedToEntity = function () {
|
|
this._triggerHelper = new ColliderTriggerHelper(this.entity);
|
|
}),
|
|
(e.prototype.calculateMovement = function (t) {
|
|
var e = new CollisionResult();
|
|
if (!this.entity.getComponent(Collider) || !this._triggerHelper)
|
|
return null;
|
|
for (
|
|
var n = this.entity.getComponents(Collider), i = 0;
|
|
i < n.length;
|
|
i++
|
|
) {
|
|
var o = n[i];
|
|
if (!o.isTrigger) {
|
|
var r = o.bounds;
|
|
(r.x += t.x), (r.y += t.y);
|
|
for (
|
|
var s = Physics.boxcastBroadphaseExcludingSelf(
|
|
o,
|
|
r,
|
|
o.collidesWithLayers
|
|
),
|
|
a = 0;
|
|
a < s.length;
|
|
a++
|
|
) {
|
|
var h = s[a];
|
|
if (!h.isTrigger) {
|
|
var c = o.collidesWith(h, t);
|
|
c &&
|
|
((t = Vector2.subtract(t, c.minimumTranslationVector)),
|
|
c.collider && (e = c));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ListPool.free(n), e;
|
|
}),
|
|
(e.prototype.applyMovement = function (t) {
|
|
(this.entity.position = Vector2.add(this.entity.position, t)),
|
|
this._triggerHelper && this._triggerHelper.update();
|
|
}),
|
|
(e.prototype.move = function (t) {
|
|
var e = this.calculateMovement(t);
|
|
return this.applyMovement(t), e;
|
|
}),
|
|
e
|
|
);
|
|
})(Component),
|
|
Collider = (function (t) {
|
|
function e() {
|
|
var e = (null !== t && t.apply(this, arguments)) || this;
|
|
return (
|
|
(e.physicsLayer = 1),
|
|
(e.shouldColliderScaleAndRotationWithTransform = !0),
|
|
(e.collidesWithLayers = Physics.allLayers),
|
|
(e._isPositionDirty = !0),
|
|
(e._isRotationDirty = !0),
|
|
(e._localOffset = new Vector2(0, 0)),
|
|
e
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "bounds", {
|
|
get: function () {
|
|
return (
|
|
(this._isPositionDirty || this._isRotationDirty) &&
|
|
(this.shape.recalculateBounds(this),
|
|
(this._isPositionDirty = this._isRotationDirty = !1)),
|
|
this.shape.bounds
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "localOffset", {
|
|
get: function () {
|
|
return this._localOffset;
|
|
},
|
|
set: function (t) {
|
|
this.setLocalOffset(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.setLocalOffset = function (t) {
|
|
this._localOffset != t &&
|
|
(this.unregisterColliderWithPhysicsSystem(),
|
|
(this._localOffset = t),
|
|
(this._localOffsetLength = this._localOffset.length()),
|
|
(this._isPositionDirty = !0),
|
|
this.registerColliderWithPhysicsSystem());
|
|
}),
|
|
(e.prototype.registerColliderWithPhysicsSystem = function () {
|
|
this._isParentEntityAddedToScene &&
|
|
!this._isColliderRegistered &&
|
|
(Physics.addCollider(this), (this._isColliderRegistered = !0));
|
|
}),
|
|
(e.prototype.unregisterColliderWithPhysicsSystem = function () {
|
|
this._isParentEntityAddedToScene &&
|
|
this._isColliderRegistered &&
|
|
Physics.removeCollider(this),
|
|
(this._isColliderRegistered = !1);
|
|
}),
|
|
(e.prototype.overlaps = function (t) {
|
|
return this.shape.overlaps(t.shape);
|
|
}),
|
|
(e.prototype.collidesWith = function (t, e) {
|
|
var n = this.shape.position;
|
|
this.shape.position = Vector2.add(this.shape.position, e);
|
|
var i = this.shape.collidesWithShape(t.shape);
|
|
return i && (i.collider = t), (this.shape.position = n), i;
|
|
}),
|
|
(e.prototype.onAddedToEntity = function () {
|
|
if (this._colliderRequiresAutoSizing) {
|
|
this instanceof BoxCollider ||
|
|
console.error(
|
|
"Only box and circle colliders can be created automatically"
|
|
);
|
|
var t = this.entity.getComponent(RenderableComponent);
|
|
if (t) {
|
|
var e = t.bounds,
|
|
n = e.width / this.entity.scale.x,
|
|
i = e.height / this.entity.scale.y;
|
|
if (this instanceof BoxCollider) {
|
|
(this.width = n),
|
|
(this.height = i),
|
|
(this.localOffset = Vector2.subtract(
|
|
e.center,
|
|
this.entity.position
|
|
));
|
|
}
|
|
}
|
|
}
|
|
(this._isParentEntityAddedToScene = !0),
|
|
this.registerColliderWithPhysicsSystem();
|
|
}),
|
|
(e.prototype.onRemovedFromEntity = function () {
|
|
this.unregisterColliderWithPhysicsSystem(),
|
|
(this._isParentEntityAddedToScene = !1);
|
|
}),
|
|
(e.prototype.onEntityTransformChanged = function (t) {
|
|
switch (t) {
|
|
case ComponentTransform.position:
|
|
case ComponentTransform.scale:
|
|
this._isPositionDirty = !0;
|
|
break;
|
|
case ComponentTransform.rotation:
|
|
this._isRotationDirty = !0;
|
|
}
|
|
this._isColliderRegistered && Physics.updateCollider(this);
|
|
}),
|
|
(e.prototype.onEnabled = function () {
|
|
this.registerColliderWithPhysicsSystem(),
|
|
(this._isPositionDirty = this._isRotationDirty = !0);
|
|
}),
|
|
(e.prototype.onDisabled = function () {
|
|
this.unregisterColliderWithPhysicsSystem();
|
|
}),
|
|
e
|
|
);
|
|
})(Component),
|
|
BoxCollider = (function (t) {
|
|
function e() {
|
|
var e = t.call(this) || this;
|
|
return (e.shape = new Box(1, 1)), (e._colliderRequiresAutoSizing = !0), e;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "width", {
|
|
get: function () {
|
|
return this.shape.width;
|
|
},
|
|
set: function (t) {
|
|
this.setWidth(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.setWidth = function (t) {
|
|
this._colliderRequiresAutoSizing = !1;
|
|
var e = this.shape;
|
|
return (
|
|
t != e.width &&
|
|
(e.updateBox(t, e.height),
|
|
(this._isPositionDirty = !0),
|
|
this.entity &&
|
|
this._isParentEntityAddedToScene &&
|
|
Physics.updateCollider(this)),
|
|
this
|
|
);
|
|
}),
|
|
Object.defineProperty(e.prototype, "height", {
|
|
get: function () {
|
|
return this.shape.height;
|
|
},
|
|
set: function (t) {
|
|
this.setHeight(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.setHeight = function (t) {
|
|
this._colliderRequiresAutoSizing = !1;
|
|
var e = this.shape;
|
|
t != e.height &&
|
|
(e.updateBox(e.width, t),
|
|
(this._isPositionDirty = !0),
|
|
this.entity &&
|
|
this._isParentEntityAddedToScene &&
|
|
Physics.updateCollider(this));
|
|
}),
|
|
(e.prototype.setSize = function (t, e) {
|
|
this._colliderRequiresAutoSizing = !1;
|
|
var n = this.shape;
|
|
return (
|
|
(t == n.width && e == n.height) ||
|
|
(n.updateBox(t, e),
|
|
(this._isPositionDirty = !0),
|
|
this.entity &&
|
|
this._isParentEntityAddedToScene &&
|
|
Physics.updateCollider(this)),
|
|
this
|
|
);
|
|
}),
|
|
e
|
|
);
|
|
})(Collider),
|
|
EntitySystem = (function () {
|
|
function t(t) {
|
|
(this._entities = []), (this._matcher = t || Matcher.empty());
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "matcher", {
|
|
get: function () {
|
|
return this._matcher;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "scene", {
|
|
get: function () {
|
|
return this._scene;
|
|
},
|
|
set: function (t) {
|
|
(this._scene = t), (this._entities = []);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.initialize = function () {}),
|
|
(t.prototype.onChanged = function (t) {
|
|
var e = this._entities.contains(t),
|
|
n = this._matcher.IsIntersted(t);
|
|
n && !e ? this.add(t) : !n && e && this.remove(t);
|
|
}),
|
|
(t.prototype.add = function (t) {
|
|
this._entities.push(t), this.onAdded(t);
|
|
}),
|
|
(t.prototype.onAdded = function (t) {}),
|
|
(t.prototype.remove = function (t) {
|
|
this._entities.remove(t), this.onRemoved(t);
|
|
}),
|
|
(t.prototype.onRemoved = function (t) {}),
|
|
(t.prototype.update = function () {
|
|
this.begin(), this.process(this._entities);
|
|
}),
|
|
(t.prototype.lateUpdate = function () {
|
|
this.lateProcess(this._entities), this.end();
|
|
}),
|
|
(t.prototype.begin = function () {}),
|
|
(t.prototype.process = function (t) {}),
|
|
(t.prototype.lateProcess = function (t) {}),
|
|
(t.prototype.end = function () {}),
|
|
t
|
|
);
|
|
})(),
|
|
EntityProcessingSystem = (function (t) {
|
|
function e(e) {
|
|
return t.call(this, e) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.lateProcessEntity = function (t) {}),
|
|
(e.prototype.process = function (t) {
|
|
var e = this;
|
|
t.forEach(function (t) {
|
|
return e.processEntity(t);
|
|
});
|
|
}),
|
|
(e.prototype.lateProcess = function (t) {
|
|
var e = this;
|
|
t.forEach(function (t) {
|
|
return e.lateProcessEntity(t);
|
|
});
|
|
}),
|
|
e
|
|
);
|
|
})(EntitySystem),
|
|
PassiveSystem = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.onChanged = function (t) {}),
|
|
(e.prototype.process = function (t) {
|
|
this.begin(), this.end();
|
|
}),
|
|
e
|
|
);
|
|
})(EntitySystem),
|
|
ProcessingSystem = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.onChanged = function (t) {}),
|
|
(e.prototype.process = function (t) {
|
|
this.begin(), this.processSystem(), this.end();
|
|
}),
|
|
e
|
|
);
|
|
})(EntitySystem),
|
|
BitSet = (function () {
|
|
function t(e) {
|
|
void 0 === e && (e = 64);
|
|
var n = e >> 6;
|
|
0 != (e & t.LONG_MASK) && n++, (this._bits = new Array(n));
|
|
}
|
|
return (
|
|
(t.prototype.and = function (t) {
|
|
for (
|
|
var e, n = Math.min(this._bits.length, t._bits.length), i = 0;
|
|
i < n;
|
|
++i
|
|
)
|
|
this._bits[i] &= t._bits[i];
|
|
for (; e < this._bits.length; ) this._bits[e++] = 0;
|
|
}),
|
|
(t.prototype.andNot = function (t) {
|
|
for (var e = Math.min(this._bits.length, t._bits.length); --e >= 0; )
|
|
this._bits[e] &= ~t._bits[e];
|
|
}),
|
|
(t.prototype.cardinality = function () {
|
|
for (var t = 0, e = this._bits.length - 1; e >= 0; e--) {
|
|
var n = this._bits[e];
|
|
if (0 != n)
|
|
if (-1 != n) {
|
|
var i =
|
|
((n =
|
|
(((n =
|
|
((n >> 1) & 0x5555555555555400) +
|
|
(0x5555555555555400 & n)) >>
|
|
2) &
|
|
0x3333333333333400) +
|
|
(0x3333333333333400 & n)) >>
|
|
32) +
|
|
n;
|
|
t +=
|
|
(((i =
|
|
(((i = ((i >> 4) & 252645135) + (252645135 & i)) >> 8) &
|
|
16711935) +
|
|
(16711935 & i)) >>
|
|
16) &
|
|
65535) +
|
|
(65535 & i);
|
|
} else t += 64;
|
|
}
|
|
return t;
|
|
}),
|
|
(t.prototype.clear = function (t) {
|
|
if (null != t) {
|
|
var e = t >> 6;
|
|
this.ensure(e), (this._bits[e] &= ~(1 << t));
|
|
} else for (var n = 0; n < this._bits.length; n++) this._bits[n] = 0;
|
|
}),
|
|
(t.prototype.ensure = function (t) {
|
|
if (t >= this._bits.length) {
|
|
var e = new Number[t + 1]();
|
|
(e = this._bits.copyWithin(0, 0, this._bits.length)),
|
|
(this._bits = e);
|
|
}
|
|
}),
|
|
(t.prototype.get = function (t) {
|
|
var e = t >> 6;
|
|
return !(e >= this._bits.length) && 0 != (this._bits[e] & (1 << t));
|
|
}),
|
|
(t.prototype.intersects = function (t) {
|
|
for (var e = Math.min(this._bits.length, t._bits.length); --e >= 0; )
|
|
if (0 != (this._bits[e] & t._bits[e])) return !0;
|
|
return !1;
|
|
}),
|
|
(t.prototype.isEmpty = function () {
|
|
for (var t = this._bits.length - 1; t >= 0; t--)
|
|
if (this._bits[t]) return !1;
|
|
return !0;
|
|
}),
|
|
(t.prototype.nextSetBit = function (t) {
|
|
for (var e = t >> 6, n = 1 << t; e < this._bits.length; ) {
|
|
var i = this._bits[e];
|
|
do {
|
|
if (0 != (i & n)) return t;
|
|
(n <<= 1), t++;
|
|
} while (0 != n);
|
|
(n = 1), e++;
|
|
}
|
|
return -1;
|
|
}),
|
|
(t.prototype.set = function (t, e) {
|
|
if ((void 0 === e && (e = !0), e)) {
|
|
var n = t >> 6;
|
|
this.ensure(n), (this._bits[n] |= 1 << t);
|
|
} else this.clear(t);
|
|
}),
|
|
(t.LONG_MASK = 63),
|
|
t
|
|
);
|
|
})(),
|
|
ComponentList = (function () {
|
|
function t(t) {
|
|
(this._components = []),
|
|
(this._componentsToAdd = []),
|
|
(this._componentsToRemove = []),
|
|
(this._tempBufferList = []),
|
|
(this._entity = t);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "count", {
|
|
get: function () {
|
|
return this._components.length;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "buffer", {
|
|
get: function () {
|
|
return this._components;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.add = function (t) {
|
|
this._componentsToAdd.push(t);
|
|
}),
|
|
(t.prototype.remove = function (t) {
|
|
this._componentsToAdd.contains(t)
|
|
? this._componentsToAdd.remove(t)
|
|
: this._componentsToRemove.push(t);
|
|
}),
|
|
(t.prototype.removeAllComponents = function () {
|
|
for (var t = 0; t < this._components.length; t++)
|
|
this.handleRemove(this._components[t]);
|
|
(this._components.length = 0),
|
|
(this._componentsToAdd.length = 0),
|
|
(this._componentsToRemove.length = 0);
|
|
}),
|
|
(t.prototype.deregisterAllComponents = function () {
|
|
for (var t = 0; t < this._components.length; t++) {
|
|
var e = this._components[t];
|
|
e instanceof RenderableComponent &&
|
|
this._entity.scene.renderableComponents.remove(e),
|
|
this._entity.componentBits.set(
|
|
ComponentTypeManager.getIndexFor(e),
|
|
!1
|
|
),
|
|
this._entity.scene.entityProcessors.onComponentRemoved(
|
|
this._entity
|
|
);
|
|
}
|
|
}),
|
|
(t.prototype.registerAllComponents = function () {
|
|
for (var t = 0; t < this._components.length; t++) {
|
|
var e = this._components[t];
|
|
e instanceof RenderableComponent &&
|
|
this._entity.scene.renderableComponents.add(e),
|
|
this._entity.componentBits.set(ComponentTypeManager.getIndexFor(e)),
|
|
this._entity.scene.entityProcessors.onComponentAdded(this._entity);
|
|
}
|
|
}),
|
|
(t.prototype.updateLists = function () {
|
|
if (this._componentsToRemove.length > 0) {
|
|
for (var t = 0; t < this._componentsToRemove.length; t++)
|
|
this.handleRemove(this._componentsToRemove[t]),
|
|
this._components.remove(this._componentsToRemove[t]);
|
|
this._componentsToRemove.length = 0;
|
|
}
|
|
if (this._componentsToAdd.length > 0) {
|
|
t = 0;
|
|
for (var e = this._componentsToAdd.length; t < e; t++) {
|
|
(n = this._componentsToAdd[t]) instanceof RenderableComponent &&
|
|
this._entity.scene.renderableComponents.add(n),
|
|
this._entity.componentBits.set(
|
|
ComponentTypeManager.getIndexFor(n)
|
|
),
|
|
this._entity.scene.entityProcessors.onComponentAdded(
|
|
this._entity
|
|
),
|
|
this._components.push(n),
|
|
this._tempBufferList.push(n);
|
|
}
|
|
this._componentsToAdd.length = 0;
|
|
for (t = 0; t < this._tempBufferList.length; t++) {
|
|
var n;
|
|
(n = this._tempBufferList[t]).onAddedToEntity(),
|
|
n.enabled && n.onEnabled();
|
|
}
|
|
this._tempBufferList.length = 0;
|
|
}
|
|
}),
|
|
(t.prototype.handleRemove = function (t) {
|
|
t instanceof RenderableComponent &&
|
|
this._entity.scene.renderableComponents.remove(t),
|
|
this._entity.componentBits.set(
|
|
ComponentTypeManager.getIndexFor(t),
|
|
!1
|
|
),
|
|
this._entity.scene.entityProcessors.onComponentRemoved(this._entity),
|
|
t.onRemovedFromEntity(),
|
|
(t.entity = null);
|
|
}),
|
|
(t.prototype.getComponent = function (t, e) {
|
|
for (var n = 0; n < this._components.length; n++) {
|
|
if ((i = this._components[n]) instanceof t) return i;
|
|
}
|
|
if (!e)
|
|
for (n = 0; n < this._componentsToAdd.length; n++) {
|
|
var i;
|
|
if ((i = this._componentsToAdd[n]) instanceof t) return i;
|
|
}
|
|
return null;
|
|
}),
|
|
(t.prototype.getComponents = function (t, e) {
|
|
e || (e = []);
|
|
for (var n = 0; n < this._components.length; n++) {
|
|
var i = this._components[n];
|
|
"string" == typeof t
|
|
? egret.is(i, t) && e.push(i)
|
|
: i instanceof t && e.push(i);
|
|
}
|
|
for (n = 0; n < this._componentsToAdd.length; n++) {
|
|
i = this._componentsToAdd[n];
|
|
"string" == typeof t
|
|
? egret.is(i, t) && e.push(i)
|
|
: i instanceof t && e.push(i);
|
|
}
|
|
return e;
|
|
}),
|
|
(t.prototype.update = function () {
|
|
this.updateLists();
|
|
for (var t = 0; t < this._components.length; t++) {
|
|
var e = this._components[t];
|
|
!e.enabled ||
|
|
(1 != e.updateInterval &&
|
|
Time.frameCount % e.updateInterval != 0) ||
|
|
e.update();
|
|
}
|
|
}),
|
|
(t.prototype.onEntityTransformChanged = function (t) {
|
|
for (var e = 0; e < this._components.length; e++)
|
|
this._components[e].enabled &&
|
|
this._components[e].onEntityTransformChanged(t);
|
|
for (e = 0; e < this._componentsToAdd.length; e++)
|
|
this._componentsToAdd[e].enabled &&
|
|
this._componentsToAdd[e].onEntityTransformChanged(t);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
ComponentTypeManager = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.add = function (t) {
|
|
this._componentTypesMask.has(t) ||
|
|
(this._componentTypesMask[t] = this._componentTypesMask.size);
|
|
}),
|
|
(t.getIndexFor = function (t) {
|
|
var e = -1;
|
|
return (
|
|
this._componentTypesMask.has(t) ||
|
|
(this.add(t), (e = this._componentTypesMask.get(t))),
|
|
e
|
|
);
|
|
}),
|
|
(t._componentTypesMask = new Map()),
|
|
t
|
|
);
|
|
})(),
|
|
EntityList = (function () {
|
|
function t(t) {
|
|
(this._entitiesToRemove = []),
|
|
(this._entitiesToAdded = []),
|
|
(this._tempEntityList = []),
|
|
(this._entities = []),
|
|
(this._entityDict = new Map()),
|
|
(this._unsortedTags = []),
|
|
(this.scene = t);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "count", {
|
|
get: function () {
|
|
return this._entities.length;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "buffer", {
|
|
get: function () {
|
|
return this._entities;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.add = function (t) {
|
|
-1 == this._entitiesToAdded.indexOf(t) && this._entitiesToAdded.push(t);
|
|
}),
|
|
(t.prototype.remove = function (t) {
|
|
this._entitiesToAdded.contains(t)
|
|
? this._entitiesToAdded.remove(t)
|
|
: this._entitiesToRemove.contains(t) ||
|
|
this._entitiesToRemove.push(t);
|
|
}),
|
|
(t.prototype.findEntity = function (t) {
|
|
for (var e = 0; e < this._entities.length; e++)
|
|
if (this._entities[e].name == t) return this._entities[e];
|
|
return this._entitiesToAdded.firstOrDefault(function (e) {
|
|
return e.name == t;
|
|
});
|
|
}),
|
|
(t.prototype.getTagList = function (t) {
|
|
var e = this._entityDict.get(t);
|
|
return (
|
|
e || ((e = []), this._entityDict.set(t, e)), this._entityDict.get(t)
|
|
);
|
|
}),
|
|
(t.prototype.addToTagList = function (t) {
|
|
var e = this.getTagList(t.tag);
|
|
e.contains(t) || (e.push(t), this._unsortedTags.push(t.tag));
|
|
}),
|
|
(t.prototype.removeFromTagList = function (t) {
|
|
var e = this._entityDict.get(t.tag);
|
|
e && e.remove(t);
|
|
}),
|
|
(t.prototype.update = function () {
|
|
for (var t = 0; t < this._entities.length; t++) {
|
|
var e = this._entities[t];
|
|
e.enabled && e.update();
|
|
}
|
|
}),
|
|
(t.prototype.removeAllEntities = function () {
|
|
(this._entitiesToAdded.length = 0), this.updateLists();
|
|
for (var t = 0; t < this._entities.length; t++)
|
|
(this._entities[t]._isDestoryed = !0),
|
|
this._entities[t].onRemovedFromScene(),
|
|
(this._entities[t].scene = null);
|
|
(this._entities.length = 0), this._entityDict.clear();
|
|
}),
|
|
(t.prototype.updateLists = function () {
|
|
var t = this;
|
|
if (this._entitiesToRemove.length > 0) {
|
|
var e = this._entitiesToRemove;
|
|
(this._entitiesToRemove = this._tempEntityList),
|
|
(this._tempEntityList = e),
|
|
this._tempEntityList.forEach(function (e) {
|
|
t._entities.remove(e),
|
|
(e.scene = null),
|
|
t.scene.entityProcessors.onEntityRemoved(e);
|
|
}),
|
|
(this._tempEntityList.length = 0);
|
|
}
|
|
if (this._entitiesToAdded.length > 0) {
|
|
e = this._entitiesToAdded;
|
|
(this._entitiesToAdded = this._tempEntityList),
|
|
(this._tempEntityList = e),
|
|
this._tempEntityList.forEach(function (e) {
|
|
t._entities.contains(e) ||
|
|
(t._entities.push(e),
|
|
(e.scene = t.scene),
|
|
t.scene.entityProcessors.onEntityAdded(e));
|
|
}),
|
|
this._tempEntityList.forEach(function (t) {
|
|
return t.onAddedToScene();
|
|
}),
|
|
(this._tempEntityList.length = 0);
|
|
}
|
|
this._unsortedTags.length > 0 &&
|
|
(this._unsortedTags.forEach(function (e) {
|
|
t._entityDict.get(e).sort();
|
|
}),
|
|
(this._unsortedTags.length = 0));
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
EntityProcessorList = (function () {
|
|
function t() {
|
|
this._processors = [];
|
|
}
|
|
return (
|
|
(t.prototype.add = function (t) {
|
|
this._processors.push(t);
|
|
}),
|
|
(t.prototype.remove = function (t) {
|
|
this._processors.remove(t);
|
|
}),
|
|
(t.prototype.onComponentAdded = function (t) {
|
|
this.notifyEntityChanged(t);
|
|
}),
|
|
(t.prototype.onComponentRemoved = function (t) {
|
|
this.notifyEntityChanged(t);
|
|
}),
|
|
(t.prototype.onEntityAdded = function (t) {
|
|
this.notifyEntityChanged(t);
|
|
}),
|
|
(t.prototype.onEntityRemoved = function (t) {
|
|
this.removeFromProcessors(t);
|
|
}),
|
|
(t.prototype.notifyEntityChanged = function (t) {
|
|
for (var e = 0; e < this._processors.length; e++)
|
|
this._processors[e].onChanged(t);
|
|
}),
|
|
(t.prototype.removeFromProcessors = function (t) {
|
|
for (var e = 0; e < this._processors.length; e++)
|
|
this._processors[e].remove(t);
|
|
}),
|
|
(t.prototype.begin = function () {}),
|
|
(t.prototype.update = function () {
|
|
for (var t = 0; t < this._processors.length; t++)
|
|
this._processors[t].update();
|
|
}),
|
|
(t.prototype.lateUpdate = function () {
|
|
for (var t = 0; t < this._processors.length; t++)
|
|
this._processors[t].lateUpdate();
|
|
}),
|
|
(t.prototype.end = function () {}),
|
|
(t.prototype.getProcessor = function () {
|
|
for (var t = 0; t < this._processors.length; t++) {
|
|
var e = this._processors[t];
|
|
if (e instanceof EntitySystem) return e;
|
|
}
|
|
return null;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Matcher = (function () {
|
|
function t() {
|
|
(this.allSet = new BitSet()),
|
|
(this.exclusionSet = new BitSet()),
|
|
(this.oneSet = new BitSet());
|
|
}
|
|
return (
|
|
(t.empty = function () {
|
|
return new t();
|
|
}),
|
|
(t.prototype.getAllSet = function () {
|
|
return this.allSet;
|
|
}),
|
|
(t.prototype.getExclusionSet = function () {
|
|
return this.exclusionSet;
|
|
}),
|
|
(t.prototype.getOneSet = function () {
|
|
return this.oneSet;
|
|
}),
|
|
(t.prototype.IsIntersted = function (t) {
|
|
if (!this.allSet.isEmpty())
|
|
for (
|
|
var e = this.allSet.nextSetBit(0);
|
|
e >= 0;
|
|
e = this.allSet.nextSetBit(e + 1)
|
|
)
|
|
if (!t.componentBits.get(e)) return !1;
|
|
return (
|
|
!(
|
|
!this.exclusionSet.isEmpty() &&
|
|
this.exclusionSet.intersects(t.componentBits)
|
|
) &&
|
|
!(!this.oneSet.isEmpty() && !this.oneSet.intersects(t.componentBits))
|
|
);
|
|
}),
|
|
(t.prototype.all = function () {
|
|
for (var t = this, e = [], n = 0; n < arguments.length; n++)
|
|
e[n] = arguments[n];
|
|
return (
|
|
e.forEach(function (e) {
|
|
t.allSet.set(ComponentTypeManager.getIndexFor(e));
|
|
}),
|
|
this
|
|
);
|
|
}),
|
|
(t.prototype.exclude = function () {
|
|
for (var t = this, e = [], n = 0; n < arguments.length; n++)
|
|
e[n] = arguments[n];
|
|
return (
|
|
e.forEach(function (e) {
|
|
t.exclusionSet.set(ComponentTypeManager.getIndexFor(e));
|
|
}),
|
|
this
|
|
);
|
|
}),
|
|
(t.prototype.one = function () {
|
|
for (var t = this, e = [], n = 0; n < arguments.length; n++)
|
|
e[n] = arguments[n];
|
|
return (
|
|
e.forEach(function (e) {
|
|
t.oneSet.set(ComponentTypeManager.getIndexFor(e));
|
|
}),
|
|
this
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
RenderableComponentList = (function () {
|
|
function t() {
|
|
this._components = [];
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "count", {
|
|
get: function () {
|
|
return this._components.length;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "buffer", {
|
|
get: function () {
|
|
return this._components;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.add = function (t) {
|
|
this._components.push(t);
|
|
}),
|
|
(t.prototype.remove = function (t) {
|
|
this._components.remove(t);
|
|
}),
|
|
(t.prototype.updateList = function () {}),
|
|
t
|
|
);
|
|
})(),
|
|
Time = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.update = function (t) {
|
|
var e = (t - this._lastTime) / 1e3;
|
|
(this.deltaTime = e * this.timeScale),
|
|
(this.unscaledDeltaTime = e),
|
|
this.frameCount++,
|
|
(this._lastTime = t);
|
|
}),
|
|
(t.deltaTime = 0),
|
|
(t.timeScale = 1),
|
|
(t.frameCount = 0),
|
|
(t._lastTime = 0),
|
|
t
|
|
);
|
|
})(),
|
|
GraphicsCapabilities = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.prototype.initialize = function (t) {
|
|
this.platformInitialize(t);
|
|
}),
|
|
(t.prototype.platformInitialize = function (t) {
|
|
var e = new egret.sys.RenderBuffer().context.getInstance();
|
|
(this.supportsNonPowerOfTwo = !1),
|
|
(this.supportsTextureFilterAnisotropic =
|
|
null != e.getExtension("EXT_texture_filter_anisotropic")),
|
|
(this.supportsDepth24 = !0),
|
|
(this.supportsPackedDepthStencil = !0),
|
|
(this.supportsDepthNonLinear = !1),
|
|
(this.supportsTextureMaxLevel = !0),
|
|
(this.supportsS3tc =
|
|
null != e.getExtension("WEBGL_compressed_texture_s3tc") ||
|
|
null != e.getExtension("WEBGL_compressed_texture_s3tc_srgb")),
|
|
(this.supportsDxt1 = this.supportsS3tc),
|
|
(this.supportsPvrtc = !1),
|
|
(this.supportsAtitc =
|
|
null != e.getExtension("WEBGL_compressed_texture_astc")),
|
|
(this.supportsFramebufferObjectARB = !1);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
GraphicsDevice = (function () {
|
|
return function () {
|
|
(this.graphicsCapabilities = new GraphicsCapabilities()),
|
|
this.graphicsCapabilities.initialize(this);
|
|
};
|
|
})(),
|
|
Viewport = (function () {
|
|
function t(t, e, n, i) {
|
|
(this._x = t),
|
|
(this._y = e),
|
|
(this._width = n),
|
|
(this._height = i),
|
|
(this._minDepth = 0),
|
|
(this._maxDepth = 1);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "aspectRatio", {
|
|
get: function () {
|
|
return 0 != this._height && 0 != this._width
|
|
? this._width / this._height
|
|
: 0;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "bounds", {
|
|
get: function () {
|
|
return new Rectangle(this._x, this._y, this._width, this._height);
|
|
},
|
|
set: function (t) {
|
|
(this._x = t.x),
|
|
(this._y = t.y),
|
|
(this._width = t.width),
|
|
(this._height = t.height);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
GraphicsResource = (function () {
|
|
return function () {};
|
|
})(),
|
|
GaussianBlurEffect = (function (t) {
|
|
function e() {
|
|
return (
|
|
t.call(this, PostProcessor.default_vert, e.blur_frag, {
|
|
screenWidth: SceneManager.stage.stageWidth,
|
|
screenHeight: SceneManager.stage.stageHeight,
|
|
}) || this
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.blur_frag =
|
|
"precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}"),
|
|
e
|
|
);
|
|
})(egret.CustomFilter),
|
|
PolygonLightEffect = (function (t) {
|
|
function e() {
|
|
return t.call(this, e.vertSrc, e.fragmentSrc) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.vertSrc =
|
|
"attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n vTextureCoord = aTextureCoord;\n}"),
|
|
(e.fragmentSrc =
|
|
"precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}"),
|
|
e
|
|
);
|
|
})(egret.CustomFilter),
|
|
PostProcessor = (function () {
|
|
function t(t) {
|
|
void 0 === t && (t = null), (this.enable = !0), (this.effect = t);
|
|
}
|
|
return (
|
|
(t.prototype.onAddedToScene = function (t) {
|
|
(this.scene = t),
|
|
(this.shape = new egret.Shape()),
|
|
this.shape.graphics.beginFill(16777215, 1),
|
|
this.shape.graphics.drawRect(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
),
|
|
this.shape.graphics.endFill(),
|
|
t.addChild(this.shape);
|
|
}),
|
|
(t.prototype.process = function () {
|
|
this.drawFullscreenQuad();
|
|
}),
|
|
(t.prototype.onSceneBackBufferSizeChanged = function (t, e) {}),
|
|
(t.prototype.drawFullscreenQuad = function () {
|
|
this.scene.filters = [this.effect];
|
|
}),
|
|
(t.prototype.unload = function () {
|
|
this.effect && (this.effect = null),
|
|
this.scene.removeChild(this.shape),
|
|
(this.scene = null);
|
|
}),
|
|
(t.default_vert =
|
|
"attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}"),
|
|
t
|
|
);
|
|
})(),
|
|
BloomSettings = (function () {
|
|
function t(t, e, n, i, o, r) {
|
|
(this.threshold = t),
|
|
(this.blurAmount = e),
|
|
(this.intensity = n),
|
|
(this.baseIntensity = i),
|
|
(this.saturation = o),
|
|
(this.baseStaturation = r);
|
|
}
|
|
return (
|
|
(t.presetSettings = [
|
|
new t(0.1, 0.6, 2, 1, 1, 0),
|
|
new t(0, 3, 1, 1, 1, 1),
|
|
new t(0.5, 8, 2, 1, 0, 1),
|
|
new t(0.25, 8, 1.3, 1, 1, 0),
|
|
new t(0, 2, 1, 0.1, 1, 1),
|
|
new t(0.5, 2, 1, 1, 1, 1),
|
|
]),
|
|
t
|
|
);
|
|
})(),
|
|
GaussianBlurPostProcessor = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.onAddedToScene = function (e) {
|
|
t.prototype.onAddedToScene.call(this, e),
|
|
(this.effect = new GaussianBlurEffect());
|
|
}),
|
|
e
|
|
);
|
|
})(PostProcessor),
|
|
Renderer = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.prototype.onAddedToScene = function (t) {}),
|
|
(t.prototype.beginRender = function (t) {}),
|
|
(t.prototype.unload = function () {}),
|
|
(t.prototype.renderAfterStateCheck = function (t, e) {
|
|
t.render(e);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
DefaultRenderer = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.render = function (t) {
|
|
var e = this.camera ? this.camera : t.camera;
|
|
this.beginRender(e);
|
|
for (var n = 0; n < t.renderableComponents.count; n++) {
|
|
var i = t.renderableComponents.buffer[n];
|
|
i.enabled &&
|
|
i.isVisibleFromCamera(e) &&
|
|
this.renderAfterStateCheck(i, e);
|
|
}
|
|
}),
|
|
e
|
|
);
|
|
})(Renderer),
|
|
ScreenSpaceRenderer = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return __extends(e, t), (e.prototype.render = function (t) {}), e;
|
|
})(Renderer),
|
|
PolyLight = (function (t) {
|
|
function e(e, n, i) {
|
|
var o = t.call(this) || this;
|
|
return (
|
|
(o._indices = []),
|
|
(o.radius = e),
|
|
(o.power = i),
|
|
(o.color = n),
|
|
o.computeTriangleIndices(),
|
|
o
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "radius", {
|
|
get: function () {
|
|
return this._radius;
|
|
},
|
|
set: function (t) {
|
|
this.setRadius(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.computeTriangleIndices = function (t) {
|
|
void 0 === t && (t = 20), (this._indices.length = 0);
|
|
for (var e = 0; e < t; e += 2)
|
|
this._indices.push(0),
|
|
this._indices.push(e + 2),
|
|
this._indices.push(e + 1);
|
|
}),
|
|
(e.prototype.setRadius = function (t) {
|
|
t != this._radius && ((this._radius = t), (this._areBoundsDirty = !0));
|
|
}),
|
|
(e.prototype.render = function (t) {}),
|
|
(e.prototype.reset = function () {}),
|
|
e
|
|
);
|
|
})(RenderableComponent),
|
|
SceneTransition = (function () {
|
|
function t(t) {
|
|
(this.sceneLoadAction = t), (this.loadsNewScene = null != t);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "hasPreviousSceneRender", {
|
|
get: function () {
|
|
return (
|
|
!!this._hasPreviousSceneRender ||
|
|
((this._hasPreviousSceneRender = !0), !1)
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.preRender = function () {}),
|
|
(t.prototype.render = function () {}),
|
|
(t.prototype.onBeginTransition = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (t) {
|
|
switch (t.label) {
|
|
case 0:
|
|
return [4, this.loadNextScene()];
|
|
case 1:
|
|
return t.sent(), this.transitionComplete(), [2];
|
|
}
|
|
});
|
|
});
|
|
}),
|
|
(t.prototype.transitionComplete = function () {
|
|
(SceneManager.sceneTransition = null),
|
|
this.onTransitionCompleted && this.onTransitionCompleted();
|
|
}),
|
|
(t.prototype.loadNextScene = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var t;
|
|
return __generator(this, function (e) {
|
|
switch (e.label) {
|
|
case 0:
|
|
return (
|
|
this.onScreenObscured && this.onScreenObscured(),
|
|
this.loadsNewScene || (this.isNewSceneLoaded = !0),
|
|
(t = SceneManager),
|
|
[4, this.sceneLoadAction()]
|
|
);
|
|
case 1:
|
|
return (t.scene = e.sent()), (this.isNewSceneLoaded = !0), [2];
|
|
}
|
|
});
|
|
});
|
|
}),
|
|
(t.prototype.tickEffectProgressProperty = function (t, e, n, i) {
|
|
return (
|
|
void 0 === i && (i = !1),
|
|
new Promise(function (o) {
|
|
var r = i ? 1 : 0,
|
|
s = i ? 0 : 1;
|
|
egret.Tween.get(t.uniforms)
|
|
.set({ _progress: r })
|
|
.to({ _progress: s }, 1e3 * e, n)
|
|
.call(function () {
|
|
o();
|
|
});
|
|
})
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
FadeTransition = (function (t) {
|
|
function e(e) {
|
|
var n = t.call(this, e) || this;
|
|
return (
|
|
(n.fadeToColor = 0),
|
|
(n.fadeOutDuration = 0.4),
|
|
(n.fadeEaseType = egret.Ease.quadInOut),
|
|
(n.delayBeforeFadeInDuration = 0.1),
|
|
(n._alpha = 0),
|
|
(n._mask = new egret.Shape()),
|
|
n
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.onBeginTransition = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var t = this;
|
|
return __generator(this, function (e) {
|
|
return (
|
|
this._mask.graphics.beginFill(this.fadeToColor, 1),
|
|
this._mask.graphics.drawRect(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
),
|
|
this._mask.graphics.endFill(),
|
|
SceneManager.stage.addChild(this._mask),
|
|
egret.Tween.get(this)
|
|
.to(
|
|
{ _alpha: 1 },
|
|
1e3 * this.fadeOutDuration,
|
|
this.fadeEaseType
|
|
)
|
|
.call(function () {
|
|
return __awaiter(t, void 0, void 0, function () {
|
|
return __generator(this, function (t) {
|
|
switch (t.label) {
|
|
case 0:
|
|
return [4, this.loadNextScene()];
|
|
case 1:
|
|
return t.sent(), [2];
|
|
}
|
|
});
|
|
});
|
|
})
|
|
.wait(this.delayBeforeFadeInDuration)
|
|
.call(function () {
|
|
egret.Tween.get(t)
|
|
.to({ _alpha: 0 }, 1e3 * t.fadeOutDuration, t.fadeEaseType)
|
|
.call(function () {
|
|
t.transitionComplete(),
|
|
SceneManager.stage.removeChild(t._mask);
|
|
});
|
|
}),
|
|
[2]
|
|
);
|
|
});
|
|
});
|
|
}),
|
|
(e.prototype.render = function () {
|
|
this._mask.graphics.clear(),
|
|
this._mask.graphics.beginFill(this.fadeToColor, this._alpha),
|
|
this._mask.graphics.drawRect(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
),
|
|
this._mask.graphics.endFill();
|
|
}),
|
|
e
|
|
);
|
|
})(SceneTransition),
|
|
WindTransition = (function (t) {
|
|
function e(e) {
|
|
var n = t.call(this, e) || this;
|
|
(n.duration = 1), (n.easeType = egret.Ease.quadOut);
|
|
return (
|
|
(n._windEffect = new egret.CustomFilter(
|
|
"attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n vTextureCoord = aTextureCoord;\n}",
|
|
"precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",
|
|
{ _progress: 0, _size: 0.3, _windSegments: 100 }
|
|
)),
|
|
(n._mask = new egret.Shape()),
|
|
n._mask.graphics.beginFill(16777215, 1),
|
|
n._mask.graphics.drawRect(
|
|
0,
|
|
0,
|
|
SceneManager.stage.stageWidth,
|
|
SceneManager.stage.stageHeight
|
|
),
|
|
n._mask.graphics.endFill(),
|
|
(n._mask.filters = [n._windEffect]),
|
|
SceneManager.stage.addChild(n._mask),
|
|
n
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "windSegments", {
|
|
set: function (t) {
|
|
this._windEffect.uniforms._windSegments = t;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(e.prototype, "size", {
|
|
set: function (t) {
|
|
this._windEffect.uniforms._size = t;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.onBeginTransition = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (t) {
|
|
switch (t.label) {
|
|
case 0:
|
|
return (
|
|
this.loadNextScene(),
|
|
[
|
|
4,
|
|
this.tickEffectProgressProperty(
|
|
this._windEffect,
|
|
this.duration,
|
|
this.easeType
|
|
),
|
|
]
|
|
);
|
|
case 1:
|
|
return (
|
|
t.sent(),
|
|
this.transitionComplete(),
|
|
SceneManager.stage.removeChild(this._mask),
|
|
[2]
|
|
);
|
|
}
|
|
});
|
|
});
|
|
}),
|
|
e
|
|
);
|
|
})(SceneTransition),
|
|
BaseView = (function (t) {
|
|
function e() {
|
|
return (null !== t && t.apply(this, arguments)) || this;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.init = function () {}),
|
|
(e.prototype.show = function (t) {}),
|
|
(e.prototype.refreshData = function (t) {
|
|
this._data = t;
|
|
}),
|
|
(e.prototype.refreshView = function () {}),
|
|
(e.prototype.close = function () {}),
|
|
(e.prototype.destroy = function () {
|
|
for (
|
|
this.parent && this.parent.removeChild(this);
|
|
this.numChildren > 0;
|
|
|
|
)
|
|
this.removeChildAt(0);
|
|
}),
|
|
e
|
|
);
|
|
})(egret.DisplayObjectContainer),
|
|
BaseFuiView = (function (t) {
|
|
function e(e) {
|
|
var n = t.call(this) || this;
|
|
return (n.name = e), n;
|
|
}
|
|
return __extends(e, t), e;
|
|
})(BaseView),
|
|
BaseSingle = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.getInstance = function () {
|
|
return (
|
|
null == this._instance && (this._instance = new this()),
|
|
this._instance
|
|
);
|
|
}),
|
|
(t.prototype.clearFuiObj = function (t) {
|
|
return (
|
|
!!t &&
|
|
(egret.Tween.removeTweens(t.displayObject),
|
|
t.displayObject &&
|
|
t.displayObject.parent &&
|
|
t.displayObject.parent.removeChild(t.displayObject),
|
|
t.dispose(),
|
|
(t = null),
|
|
!0)
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
ViewManager = (function (t) {
|
|
function e() {
|
|
var e = (null !== t && t.apply(this, arguments)) || this;
|
|
return (e._openDic = []), e;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.refreshView = function (t, e) {
|
|
var n = this.getView(t);
|
|
n && (n.refreshData(e), n.refreshView());
|
|
}),
|
|
(e.prototype.openView = function (t, e, n) {
|
|
var i = this.getView(t);
|
|
if ((i || (i = new t()), this.existView(t)))
|
|
return i.refreshData(e), void i.refreshView();
|
|
this._openDic.push(i);
|
|
}),
|
|
(e.prototype.getView = function (t) {
|
|
return this._openDic.firstOrDefault(function (e) {
|
|
return e instanceof t;
|
|
});
|
|
}),
|
|
(e.prototype.existView = function (t) {
|
|
return (
|
|
-1 !=
|
|
this._openDic.findIndex(function (e) {
|
|
return e instanceof t;
|
|
})
|
|
);
|
|
}),
|
|
e
|
|
);
|
|
})(BaseSingle),
|
|
Flags = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.isFlagSet = function (t, e) {
|
|
return 0 != (t & e);
|
|
}),
|
|
(t.isUnshiftedFlagSet = function (t, e) {
|
|
return 0 != (t & (e = 1 << e));
|
|
}),
|
|
(t.setFlagExclusive = function (t, e) {
|
|
return 1 << e;
|
|
}),
|
|
(t.setFlag = function (t, e) {
|
|
return t | (1 << e);
|
|
}),
|
|
(t.unsetFlag = function (t, e) {
|
|
return t & ~(e = 1 << e);
|
|
}),
|
|
(t.invertFlags = function (t) {
|
|
return ~t;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
MathHelper = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.toDegrees = function (t) {
|
|
return 57.29577951308232 * t;
|
|
}),
|
|
(t.toRadians = function (t) {
|
|
return 0.017453292519943295 * t;
|
|
}),
|
|
(t.map = function (t, e, n, i, o) {
|
|
return i + ((t - e) * (o - i)) / (n - e);
|
|
}),
|
|
(t.lerp = function (t, e, n) {
|
|
return t + (e - t) * n;
|
|
}),
|
|
(t.clamp = function (t, e, n) {
|
|
return t < e ? e : t > n ? n : t;
|
|
}),
|
|
(t.pointOnCirlce = function (e, n, i) {
|
|
var o = t.toRadians(i);
|
|
return new Vector2(Math.cos(o) * o + e.x, Math.sin(o) * o + e.y);
|
|
}),
|
|
(t.isEven = function (t) {
|
|
return t % 2 == 0;
|
|
}),
|
|
(t.Epsilon = 1e-5),
|
|
(t.Rad2Deg = 57.29578),
|
|
(t.Deg2Rad = 0.0174532924),
|
|
t
|
|
);
|
|
})(),
|
|
Matrix2D = (function () {
|
|
function t(t, e, n, i, o, r) {
|
|
(this.m11 = 0),
|
|
(this.m12 = 0),
|
|
(this.m21 = 0),
|
|
(this.m22 = 0),
|
|
(this.m31 = 0),
|
|
(this.m32 = 0),
|
|
(this.m11 = t || 1),
|
|
(this.m12 = e || 0),
|
|
(this.m21 = n || 0),
|
|
(this.m22 = i || 1),
|
|
(this.m31 = o || 0),
|
|
(this.m32 = r || 0);
|
|
}
|
|
return (
|
|
Object.defineProperty(t, "identity", {
|
|
get: function () {
|
|
return t._identity;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "translation", {
|
|
get: function () {
|
|
return new Vector2(this.m31, this.m32);
|
|
},
|
|
set: function (t) {
|
|
(this.m31 = t.x), (this.m32 = t.y);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "rotation", {
|
|
get: function () {
|
|
return Math.atan2(this.m21, this.m11);
|
|
},
|
|
set: function (t) {
|
|
var e = Math.cos(t),
|
|
n = Math.sin(t);
|
|
(this.m11 = e), (this.m12 = n), (this.m21 = -n), (this.m22 = e);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "rotationDegrees", {
|
|
get: function () {
|
|
return MathHelper.toDegrees(this.rotation);
|
|
},
|
|
set: function (t) {
|
|
this.rotation = MathHelper.toRadians(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "scale", {
|
|
get: function () {
|
|
return new Vector2(this.m11, this.m22);
|
|
},
|
|
set: function (t) {
|
|
(this.m11 = t.x), (this.m12 = t.y);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.add = function (t, e) {
|
|
return (
|
|
(t.m11 += e.m11),
|
|
(t.m12 += e.m12),
|
|
(t.m21 += e.m21),
|
|
(t.m22 += e.m22),
|
|
(t.m31 += e.m31),
|
|
(t.m32 += e.m32),
|
|
t
|
|
);
|
|
}),
|
|
(t.divide = function (t, e) {
|
|
return (
|
|
(t.m11 /= e.m11),
|
|
(t.m12 /= e.m12),
|
|
(t.m21 /= e.m21),
|
|
(t.m22 /= e.m22),
|
|
(t.m31 /= e.m31),
|
|
(t.m32 /= e.m32),
|
|
t
|
|
);
|
|
}),
|
|
(t.multiply = function (e, n) {
|
|
var i = new t(),
|
|
o = e.m11 * n.m11 + e.m12 * n.m21,
|
|
r = e.m11 * n.m12 + e.m12 * n.m22,
|
|
s = e.m21 * n.m11 + e.m22 * n.m21,
|
|
a = e.m21 * n.m12 + e.m22 * n.m22,
|
|
h = e.m31 * n.m11 + e.m32 * n.m21 + n.m31,
|
|
c = e.m31 * n.m12 + e.m32 * n.m22 + n.m32;
|
|
return (
|
|
(i.m11 = o),
|
|
(i.m12 = r),
|
|
(i.m21 = s),
|
|
(i.m22 = a),
|
|
(i.m31 = h),
|
|
(i.m32 = c),
|
|
i
|
|
);
|
|
}),
|
|
(t.multiplyTranslation = function (e, n, i) {
|
|
var o = t.createTranslation(n, i);
|
|
return t.multiply(e, o);
|
|
}),
|
|
(t.prototype.determinant = function () {
|
|
return this.m11 * this.m22 - this.m12 * this.m21;
|
|
}),
|
|
(t.invert = function (e, n) {
|
|
void 0 === n && (n = new t());
|
|
var i = 1 / e.determinant();
|
|
return (
|
|
(n.m11 = e.m22 * i),
|
|
(n.m12 = -e.m12 * i),
|
|
(n.m21 = -e.m21 * i),
|
|
(n.m22 = e.m11 * i),
|
|
(n.m31 = (e.m32 * e.m21 - e.m31 * e.m22) * i),
|
|
(n.m32 = -(e.m32 * e.m11 - e.m31 * e.m12) * i),
|
|
n
|
|
);
|
|
}),
|
|
(t.createTranslation = function (e, n, i) {
|
|
return (
|
|
((i = i || new t()).m11 = 1),
|
|
(i.m12 = 0),
|
|
(i.m21 = 0),
|
|
(i.m22 = 1),
|
|
(i.m31 = e),
|
|
(i.m32 = n),
|
|
i
|
|
);
|
|
}),
|
|
(t.createRotation = function (e, n) {
|
|
n = new t();
|
|
var i = Math.cos(e),
|
|
o = Math.sin(e);
|
|
return (n.m11 = i), (n.m12 = o), (n.m21 = -o), (n.m22 = i), n;
|
|
}),
|
|
(t.createScale = function (e, n, i) {
|
|
return (
|
|
void 0 === i && (i = new t()),
|
|
(i.m11 = e),
|
|
(i.m12 = 0),
|
|
(i.m21 = 0),
|
|
(i.m22 = n),
|
|
(i.m31 = 0),
|
|
(i.m32 = 0),
|
|
i
|
|
);
|
|
}),
|
|
(t.prototype.toEgretMatrix = function () {
|
|
return new egret.Matrix(
|
|
this.m11,
|
|
this.m12,
|
|
this.m21,
|
|
this.m22,
|
|
this.m31,
|
|
this.m32
|
|
);
|
|
}),
|
|
(t._identity = new t(1, 0, 0, 1, 0, 0)),
|
|
t
|
|
);
|
|
})(),
|
|
Rectangle = (function () {
|
|
function t(t, e, n, i) {
|
|
(this.x = t || 0),
|
|
(this.y = e || 0),
|
|
(this.width = n || 0),
|
|
(this.height = i || 0);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "left", {
|
|
get: function () {
|
|
return this.x;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "right", {
|
|
get: function () {
|
|
return this.x + this.width;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "top", {
|
|
get: function () {
|
|
return this.y;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "bottom", {
|
|
get: function () {
|
|
return this.y + this.height;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "center", {
|
|
get: function () {
|
|
return new Vector2(this.x + this.width / 2, this.y + this.height / 2);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "location", {
|
|
get: function () {
|
|
return new Vector2(this.x, this.y);
|
|
},
|
|
set: function (t) {
|
|
(this.x = t.x), (this.y = t.y);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t.prototype, "size", {
|
|
get: function () {
|
|
return new Vector2(this.width, this.height);
|
|
},
|
|
set: function (t) {
|
|
(this.width = t.x), (this.height = t.y);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.intersects = function (t) {
|
|
return (
|
|
t.left < this.right &&
|
|
this.left < t.right &&
|
|
t.top < this.bottom &&
|
|
this.top < t.bottom
|
|
);
|
|
}),
|
|
(t.prototype.contains = function (t) {
|
|
return (
|
|
this.x <= t.x &&
|
|
t.x < this.x + this.width &&
|
|
this.y <= t.y &&
|
|
t.y < this.y + this.height
|
|
);
|
|
}),
|
|
(t.prototype.containsRect = function (t) {
|
|
return (
|
|
this.x <= t.x &&
|
|
t.x < this.x + this.width &&
|
|
this.y <= t.y &&
|
|
t.y < this.y + this.height
|
|
);
|
|
}),
|
|
(t.prototype.getHalfSize = function () {
|
|
return new Vector2(0.5 * this.width, 0.5 * this.height);
|
|
}),
|
|
(t.fromMinMax = function (e, n, i, o) {
|
|
return new t(e, n, i - e, o - n);
|
|
}),
|
|
(t.prototype.getClosestPointOnRectangleBorderToPoint = function (t) {
|
|
var e = new Vector2(0, 0),
|
|
n = new Vector2(0, 0);
|
|
if (
|
|
((n.x = MathHelper.clamp(t.x, this.left, this.right)),
|
|
(n.y = MathHelper.clamp(t.y, this.top, this.bottom)),
|
|
this.contains(n))
|
|
) {
|
|
var i = n.x - this.left,
|
|
o = this.right - n.x,
|
|
r = n.y - this.top,
|
|
s = this.bottom - n.y,
|
|
a = Math.min(i, o, r, s);
|
|
a == r
|
|
? ((n.y = this.top), (e.y = -1))
|
|
: a == s
|
|
? ((n.y = this.bottom), (e.y = 1))
|
|
: a == i
|
|
? ((n.x = this.left), (e.x = -1))
|
|
: ((n.x = this.right), (e.x = 1));
|
|
} else
|
|
n.x == this.left && (e.x = -1),
|
|
n.x == this.right && (e.x = 1),
|
|
n.y == this.top && (e.y = -1),
|
|
n.y == this.bottom && (e.y = 1);
|
|
return { res: n, edgeNormal: e };
|
|
}),
|
|
(t.prototype.calculateBounds = function (t, e, n, i, o, r, s) {
|
|
if (0 == o)
|
|
(this.x = t.x + e.x - n.x * i.x),
|
|
(this.y = t.y + e.y - n.y * i.y),
|
|
(this.width = r * i.x),
|
|
(this.height = s * i.y);
|
|
else {
|
|
var a = t.x + e.x,
|
|
h = t.y + e.y;
|
|
(this._transformMat = Matrix2D.createTranslation(-a - n.x, -h - n.y)),
|
|
(this._tempMat = Matrix2D.createScale(i.x, i.y)),
|
|
(this._transformMat = Matrix2D.multiply(
|
|
this._transformMat,
|
|
this._tempMat
|
|
)),
|
|
(this._tempMat = Matrix2D.createRotation(o)),
|
|
(this._transformMat = Matrix2D.multiply(
|
|
this._transformMat,
|
|
this._tempMat
|
|
)),
|
|
(this._tempMat = Matrix2D.createTranslation(a, h)),
|
|
(this._transformMat = Matrix2D.multiply(
|
|
this._transformMat,
|
|
this._tempMat
|
|
));
|
|
var c = new Vector2(a, h),
|
|
u = new Vector2(a + r, h),
|
|
l = new Vector2(a, h + s),
|
|
p = new Vector2(a + r, h + s);
|
|
(c = Vector2Ext.transformR(c, this._transformMat)),
|
|
(u = Vector2Ext.transformR(u, this._transformMat)),
|
|
(l = Vector2Ext.transformR(l, this._transformMat)),
|
|
(p = Vector2Ext.transformR(p, this._transformMat));
|
|
var f = Math.min(c.x, p.x, u.x, l.x),
|
|
d = Math.max(c.x, p.x, u.x, l.x),
|
|
y = Math.min(c.y, p.y, u.y, l.y),
|
|
g = Math.max(c.y, p.y, u.y, l.y);
|
|
(this.location = new Vector2(f, y)),
|
|
(this.width = d - f),
|
|
(this.height = g - y);
|
|
}
|
|
}),
|
|
(t.rectEncompassingPoints = function (t) {
|
|
for (
|
|
var e = Number.POSITIVE_INFINITY,
|
|
n = Number.POSITIVE_INFINITY,
|
|
i = Number.NEGATIVE_INFINITY,
|
|
o = Number.NEGATIVE_INFINITY,
|
|
r = 0;
|
|
r < t.length;
|
|
r++
|
|
) {
|
|
var s = t[r];
|
|
s.x < e && (e = s.x),
|
|
s.x > i && (i = s.x),
|
|
s.y < n && (n = s.y),
|
|
s.y > o && (o = s.y);
|
|
}
|
|
return this.fromMinMax(e, n, i, o);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Vector2 = (function () {
|
|
function t(t, e) {
|
|
(this.x = 0), (this.y = 0), (this.x = t || 0), (this.y = e || this.x);
|
|
}
|
|
return (
|
|
Object.defineProperty(t, "zero", {
|
|
get: function () {
|
|
return t.zeroVector2;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "one", {
|
|
get: function () {
|
|
return t.unitVector2;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "unitX", {
|
|
get: function () {
|
|
return t.unitXVector;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "unitY", {
|
|
get: function () {
|
|
return t.unitYVector;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.add = function (e, n) {
|
|
var i = new t(0, 0);
|
|
return (i.x = e.x + n.x), (i.y = e.y + n.y), i;
|
|
}),
|
|
(t.divide = function (e, n) {
|
|
var i = new t(0, 0);
|
|
return (i.x = e.x / n.x), (i.y = e.y / n.y), i;
|
|
}),
|
|
(t.multiply = function (e, n) {
|
|
var i = new t(0, 0);
|
|
return (i.x = e.x * n.x), (i.y = e.y * n.y), i;
|
|
}),
|
|
(t.subtract = function (e, n) {
|
|
var i = new t(0, 0);
|
|
return (i.x = e.x - n.x), (i.y = e.y - n.y), i;
|
|
}),
|
|
(t.prototype.normalize = function () {
|
|
var t = 1 / Math.sqrt(this.x * this.x + this.y * this.y);
|
|
(this.x *= t), (this.y *= t);
|
|
}),
|
|
(t.prototype.length = function () {
|
|
return Math.sqrt(this.x * this.x + this.y * this.y);
|
|
}),
|
|
(t.prototype.round = function () {
|
|
return new t(Math.round(this.x), Math.round(this.y));
|
|
}),
|
|
(t.normalize = function (t) {
|
|
var e = 1 / Math.sqrt(t.x * t.x + t.y * t.y);
|
|
return (t.x *= e), (t.y *= e), t;
|
|
}),
|
|
(t.dot = function (t, e) {
|
|
return t.x * e.x + t.y * e.y;
|
|
}),
|
|
(t.distanceSquared = function (t, e) {
|
|
var n = t.x - e.x,
|
|
i = t.y - e.y;
|
|
return n * n + i * i;
|
|
}),
|
|
(t.clamp = function (e, n, i) {
|
|
return new t(
|
|
MathHelper.clamp(e.x, n.x, i.x),
|
|
MathHelper.clamp(e.y, n.y, i.y)
|
|
);
|
|
}),
|
|
(t.lerp = function (e, n, i) {
|
|
return new t(
|
|
MathHelper.lerp(e.x, n.x, i),
|
|
MathHelper.lerp(e.y, n.y, i)
|
|
);
|
|
}),
|
|
(t.transform = function (e, n) {
|
|
return new t(e.x * n.m11 + e.y * n.m21, e.x * n.m12 + e.y * n.m22);
|
|
}),
|
|
(t.distance = function (t, e) {
|
|
var n = t.x - e.x,
|
|
i = t.y - e.y;
|
|
return Math.sqrt(n * n + i * i);
|
|
}),
|
|
(t.negate = function (e) {
|
|
var n = new t();
|
|
return (n.x = -e.x), (n.y = -e.y), n;
|
|
}),
|
|
(t.unitYVector = new t(0, 1)),
|
|
(t.unitXVector = new t(1, 0)),
|
|
(t.unitVector2 = new t(1, 1)),
|
|
(t.zeroVector2 = new t(0, 0)),
|
|
t
|
|
);
|
|
})(),
|
|
Vector3 = (function () {
|
|
return function (t, e, n) {
|
|
(this.x = t), (this.y = e), (this.z = n);
|
|
};
|
|
})(),
|
|
ColliderTriggerHelper = (function () {
|
|
function t(t) {
|
|
(this._activeTriggerIntersections = []),
|
|
(this._previousTriggerIntersections = []),
|
|
(this._tempTriggerList = []),
|
|
(this._entity = t);
|
|
}
|
|
return (
|
|
(t.prototype.update = function () {
|
|
for (
|
|
var t = this._entity.getComponents(Collider), e = 0;
|
|
e < t.length;
|
|
e++
|
|
)
|
|
for (
|
|
var n = t[e],
|
|
i = Physics.boxcastBroadphase(n.bounds, n.collidesWithLayers),
|
|
o = function (t) {
|
|
var e = i[t];
|
|
if (!n.isTrigger && !e.isTrigger) return "continue";
|
|
if (n.overlaps(e)) {
|
|
var o = new Pair(n, e);
|
|
-1 ==
|
|
r._activeTriggerIntersections.findIndex(function (t) {
|
|
return t.first == o.first && t.second == o.second;
|
|
}) &&
|
|
-1 ==
|
|
r._previousTriggerIntersections.findIndex(function (t) {
|
|
return t.first == o.first && t.second == o.second;
|
|
}) &&
|
|
r.notifyTriggerListeners(o, !0),
|
|
r._activeTriggerIntersections.contains(o) ||
|
|
r._activeTriggerIntersections.push(o);
|
|
}
|
|
},
|
|
r = this,
|
|
s = 0;
|
|
s < i.length;
|
|
s++
|
|
)
|
|
o(s);
|
|
ListPool.free(t), this.checkForExitedColliders();
|
|
}),
|
|
(t.prototype.checkForExitedColliders = function () {
|
|
for (
|
|
var t = this,
|
|
e = function (e) {
|
|
var i = n._previousTriggerIntersections.findIndex(function (n) {
|
|
return (
|
|
n.first == t._activeTriggerIntersections[e].first &&
|
|
n.second == t._activeTriggerIntersections[e].second
|
|
);
|
|
});
|
|
-1 != i && n._previousTriggerIntersections.removeAt(i);
|
|
},
|
|
n = this,
|
|
i = 0;
|
|
i < this._activeTriggerIntersections.length;
|
|
i++
|
|
)
|
|
e(i);
|
|
for (i = 0; i < this._previousTriggerIntersections.length; i++)
|
|
this.notifyTriggerListeners(
|
|
this._previousTriggerIntersections[i],
|
|
!1
|
|
);
|
|
this._previousTriggerIntersections.length = 0;
|
|
for (i = 0; i < this._activeTriggerIntersections.length; i++)
|
|
this._previousTriggerIntersections.contains(
|
|
this._activeTriggerIntersections[i]
|
|
) ||
|
|
this._previousTriggerIntersections.push(
|
|
this._activeTriggerIntersections[i]
|
|
);
|
|
this._activeTriggerIntersections.length = 0;
|
|
}),
|
|
(t.prototype.notifyTriggerListeners = function (t, e) {
|
|
t.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
|
|
for (var n = 0; n < this._tempTriggerList.length; n++)
|
|
if (
|
|
(e
|
|
? this._tempTriggerList[n].onTriggerEnter(t.second, t.first)
|
|
: this._tempTriggerList[n].onTriggerExit(t.second, t.first),
|
|
(this._tempTriggerList.length = 0),
|
|
t.second.entity)
|
|
) {
|
|
t.second.entity.getComponents(
|
|
"ITriggerListener",
|
|
this._tempTriggerList
|
|
);
|
|
for (var i = 0; i < this._tempTriggerList.length; i++)
|
|
e
|
|
? this._tempTriggerList[i].onTriggerEnter(t.first, t.second)
|
|
: this._tempTriggerList[i].onTriggerExit(t.first, t.second);
|
|
this._tempTriggerList.length = 0;
|
|
}
|
|
}),
|
|
t
|
|
);
|
|
})();
|
|
!(function (t) {
|
|
(t[(t.center = 0)] = "center"),
|
|
(t[(t.top = 1)] = "top"),
|
|
(t[(t.bottom = 2)] = "bottom"),
|
|
(t[(t.topLeft = 9)] = "topLeft"),
|
|
(t[(t.topRight = 5)] = "topRight"),
|
|
(t[(t.left = 8)] = "left"),
|
|
(t[(t.right = 4)] = "right"),
|
|
(t[(t.bottomLeft = 10)] = "bottomLeft"),
|
|
(t[(t.bottomRight = 6)] = "bottomRight");
|
|
})(PointSectors || (PointSectors = {}));
|
|
var Collisions = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.isLineToLine = function (t, e, n, i) {
|
|
var o = Vector2.subtract(e, t),
|
|
r = Vector2.subtract(i, n),
|
|
s = o.x * r.y - o.y * r.x;
|
|
if (0 == s) return !1;
|
|
var a = Vector2.subtract(n, t),
|
|
h = (a.x * r.y - a.y * r.x) / s;
|
|
if (h < 0 || h > 1) return !1;
|
|
var c = (a.x * o.y - a.y * o.x) / s;
|
|
return !(c < 0 || c > 1);
|
|
}),
|
|
(t.lineToLineIntersection = function (t, e, n, i) {
|
|
var o = new Vector2(0, 0),
|
|
r = Vector2.subtract(e, t),
|
|
s = Vector2.subtract(i, n),
|
|
a = r.x * s.y - r.y * s.x;
|
|
if (0 == a) return o;
|
|
var h = Vector2.subtract(n, t),
|
|
c = (h.x * s.y - h.y * s.x) / a;
|
|
if (c < 0 || c > 1) return o;
|
|
var u = (h.x * r.y - h.y * r.x) / a;
|
|
return u < 0 || u > 1
|
|
? o
|
|
: (o = Vector2.add(t, new Vector2(c * r.x, c * r.y)));
|
|
}),
|
|
(t.closestPointOnLine = function (t, e, n) {
|
|
var i = Vector2.subtract(e, t),
|
|
o = Vector2.subtract(n, t),
|
|
r = Vector2.dot(o, i) / Vector2.dot(i, i);
|
|
return (
|
|
(r = MathHelper.clamp(r, 0, 1)),
|
|
Vector2.add(t, new Vector2(i.x * r, i.y * r))
|
|
);
|
|
}),
|
|
(t.isCircleToCircle = function (t, e, n, i) {
|
|
return Vector2.distanceSquared(t, n) < (e + i) * (e + i);
|
|
}),
|
|
(t.isCircleToLine = function (t, e, n, i) {
|
|
return (
|
|
Vector2.distanceSquared(t, this.closestPointOnLine(n, i, t)) < e * e
|
|
);
|
|
}),
|
|
(t.isCircleToPoint = function (t, e, n) {
|
|
return Vector2.distanceSquared(t, n) < e * e;
|
|
}),
|
|
(t.isRectToCircle = function (t, e, n) {
|
|
var i = 0.5 * t.width,
|
|
o = 0.5 * t.height,
|
|
r = Math.max(0, Math.max(e.x - t.x) - i),
|
|
s = Math.max(0, Math.max(e.y - t.y) - o);
|
|
return r * r + s * s < n * n;
|
|
}),
|
|
(t.isRectToLine = function (t, e, n) {
|
|
var i = this.getSector(t.x, t.y, t.width, t.height, e),
|
|
o = this.getSector(t.x, t.y, t.width, t.height, n);
|
|
if (i == PointSectors.center || o == PointSectors.center) return !0;
|
|
if (0 != (i & o)) return !1;
|
|
var r = i | o,
|
|
s = void 0,
|
|
a = void 0;
|
|
return (
|
|
!(
|
|
0 == (r & PointSectors.top) ||
|
|
((s = new Vector2(t.x, t.y)),
|
|
(a = new Vector2(t.x + t.width, t.y)),
|
|
!this.isLineToLine(s, a, e, n))
|
|
) ||
|
|
!(
|
|
0 == (r & PointSectors.bottom) ||
|
|
((s = new Vector2(t.x, t.y + t.height)),
|
|
(a = new Vector2(t.x + t.width, t.y + t.height)),
|
|
!this.isLineToLine(s, a, e, n))
|
|
) ||
|
|
!(
|
|
0 == (r & PointSectors.left) ||
|
|
((s = new Vector2(t.x, t.y)),
|
|
(a = new Vector2(t.x, t.y + t.height)),
|
|
!this.isLineToLine(s, a, e, n))
|
|
) ||
|
|
!(
|
|
0 == (r & PointSectors.right) ||
|
|
((s = new Vector2(t.x + t.width, t.y)),
|
|
(a = new Vector2(t.x + t.width, t.y + t.height)),
|
|
!this.isLineToLine(s, a, e, n))
|
|
)
|
|
);
|
|
}),
|
|
(t.isRectToPoint = function (t, e, n, i, o) {
|
|
return o.x >= t && o.y >= e && o.x < t + n && o.y < e + i;
|
|
}),
|
|
(t.getSector = function (t, e, n, i, o) {
|
|
var r = PointSectors.center;
|
|
return (
|
|
o.x < t
|
|
? (r |= PointSectors.left)
|
|
: o.x >= t + n && (r |= PointSectors.right),
|
|
o.y < e
|
|
? (r |= PointSectors.top)
|
|
: o.y >= e + i && (r |= PointSectors.bottom),
|
|
r
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Physics = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.reset = function () {
|
|
this._spatialHash = new SpatialHash(this.spatialHashCellSize);
|
|
}),
|
|
(t.clear = function () {
|
|
this._spatialHash.clear();
|
|
}),
|
|
(t.overlapCircleAll = function (t, e, n, i) {
|
|
return (
|
|
void 0 === i && (i = -1), this._spatialHash.overlapCircle(t, e, n, i)
|
|
);
|
|
}),
|
|
(t.boxcastBroadphase = function (t, e) {
|
|
return (
|
|
void 0 === e && (e = this.allLayers),
|
|
this._spatialHash.aabbBroadphase(t, null, e)
|
|
);
|
|
}),
|
|
(t.boxcastBroadphaseExcludingSelf = function (t, e, n) {
|
|
return (
|
|
void 0 === n && (n = this.allLayers),
|
|
this._spatialHash.aabbBroadphase(e, t, n)
|
|
);
|
|
}),
|
|
(t.addCollider = function (e) {
|
|
t._spatialHash.register(e);
|
|
}),
|
|
(t.removeCollider = function (e) {
|
|
t._spatialHash.remove(e);
|
|
}),
|
|
(t.updateCollider = function (t) {
|
|
this._spatialHash.remove(t), this._spatialHash.register(t);
|
|
}),
|
|
(t.spatialHashCellSize = 100),
|
|
(t.allLayers = -1),
|
|
t
|
|
);
|
|
})(),
|
|
Shape = (function () {
|
|
return function () {};
|
|
})(),
|
|
Polygon = (function (t) {
|
|
function e(e, n) {
|
|
var i = t.call(this) || this;
|
|
return (
|
|
(i.isUnrotated = !0),
|
|
(i._areEdgeNormalsDirty = !0),
|
|
i.setPoints(e),
|
|
(i.isBox = n),
|
|
i
|
|
);
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
Object.defineProperty(e.prototype, "edgeNormals", {
|
|
get: function () {
|
|
return (
|
|
this._areEdgeNormalsDirty && this.buildEdgeNormals(),
|
|
this._edgeNormals
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(e.prototype.buildEdgeNormals = function () {
|
|
var t,
|
|
e = this.isBox ? 2 : this.points.length;
|
|
(null != this._edgeNormals && this._edgeNormals.length == e) ||
|
|
(this._edgeNormals = new Array(e));
|
|
for (var n = 0; n < e; n++) {
|
|
var i = this.points[n];
|
|
t = n + 1 >= this.points.length ? this.points[0] : this.points[n + 1];
|
|
var o = Vector2Ext.perpendicular(i, t);
|
|
(o = Vector2.normalize(o)), (this._edgeNormals[n] = o);
|
|
}
|
|
}),
|
|
(e.prototype.setPoints = function (t) {
|
|
(this.points = t),
|
|
this.recalculateCenterAndEdgeNormals(),
|
|
(this._originalPoints = []);
|
|
for (var e = 0; e < this.points.length; e++)
|
|
this._originalPoints.push(this.points[e]);
|
|
}),
|
|
(e.prototype.collidesWithShape = function (t) {
|
|
var n = new CollisionResult();
|
|
if (t instanceof e) return ShapeCollisions.polygonToPolygon(this, t);
|
|
if (t instanceof Circle)
|
|
return (n = ShapeCollisions.circleToPolygon(t, this))
|
|
? (n.invertResult(), n)
|
|
: null;
|
|
throw new Error("overlaps of Polygon to " + t + " are not supported");
|
|
}),
|
|
(e.prototype.recalculateCenterAndEdgeNormals = function () {
|
|
(this._polygonCenter = e.findPolygonCenter(this.points)),
|
|
(this._areEdgeNormalsDirty = !0);
|
|
}),
|
|
(e.prototype.overlaps = function (t) {
|
|
var n;
|
|
if (t instanceof e) return ShapeCollisions.polygonToPolygon(this, t);
|
|
if (t instanceof Circle)
|
|
return (
|
|
!!(n = ShapeCollisions.circleToPolygon(t, this)) &&
|
|
(n.invertResult(), !0)
|
|
);
|
|
throw new Error("overlaps of Pologon to " + t + " are not supported");
|
|
}),
|
|
(e.findPolygonCenter = function (t) {
|
|
for (var e = 0, n = 0, i = 0; i < t.length; i++)
|
|
(e += t[i].x), (n += t[i].y);
|
|
return new Vector2(e / t.length, n / t.length);
|
|
}),
|
|
(e.getClosestPointOnPolygonToPoint = function (t, e) {
|
|
for (
|
|
var n,
|
|
i = Number.MAX_VALUE,
|
|
o = new Vector2(0, 0),
|
|
r = new Vector2(0, 0),
|
|
s = 0;
|
|
s < t.length;
|
|
s++
|
|
) {
|
|
var a = s + 1;
|
|
a == t.length && (a = 0);
|
|
var h = ShapeCollisions.closestPointOnLine(t[s], t[a], e);
|
|
if ((n = Vector2.distanceSquared(e, h)) < i) {
|
|
(i = n), (r = h);
|
|
var c = Vector2.subtract(t[a], t[s]);
|
|
(o.x = -c.y), (o.y = c.x);
|
|
}
|
|
}
|
|
return {
|
|
closestPoint: r,
|
|
distanceSquared: i,
|
|
edgeNormal: (o = Vector2.normalize(o)),
|
|
};
|
|
}),
|
|
(e.prototype.pointCollidesWithShape = function (t) {
|
|
return ShapeCollisions.pointToPoly(t, this);
|
|
}),
|
|
(e.prototype.containsPoint = function (t) {
|
|
t = Vector2.subtract(t, this.position);
|
|
for (
|
|
var e = !1, n = 0, i = this.points.length - 1;
|
|
n < this.points.length;
|
|
i = n++
|
|
)
|
|
this.points[n].y > t.y != this.points[i].y > t.y &&
|
|
t.x <
|
|
((this.points[i].x - this.points[n].x) *
|
|
(t.y - this.points[n].y)) /
|
|
(this.points[i].y - this.points[n].y) +
|
|
this.points[n].x &&
|
|
(e = !e);
|
|
return e;
|
|
}),
|
|
(e.buildSymmertricalPolygon = function (t, e) {
|
|
for (var n = new Array(t), i = 0; i < t; i++) {
|
|
var o = 2 * Math.PI * (i / t);
|
|
n[i] = new Vector2(Math.cos(o), Math.sin(o) * e);
|
|
}
|
|
return n;
|
|
}),
|
|
(e.prototype.recalculateBounds = function (t) {
|
|
if (
|
|
((this.center = t.localOffset),
|
|
t.shouldColliderScaleAndRotationWithTransform)
|
|
) {
|
|
var e = !0,
|
|
n = void 0,
|
|
i = Matrix2D.createTranslation(
|
|
-this._polygonCenter.x,
|
|
-this._polygonCenter.y
|
|
);
|
|
if (t.entity.scale != Vector2.one) {
|
|
(n = Matrix2D.createScale(t.entity.scale.x, t.entity.scale.y)),
|
|
(i = Matrix2D.multiply(i, n)),
|
|
(e = !1);
|
|
var o = Vector2.multiply(t.localOffset, t.entity.scale);
|
|
this.center = o;
|
|
}
|
|
if (0 != t.entity.rotation) {
|
|
(n = Matrix2D.createRotation(t.entity.rotation)),
|
|
(i = Matrix2D.multiply(i, n));
|
|
var r =
|
|
Math.atan2(t.localOffset.y, t.localOffset.x) *
|
|
MathHelper.Rad2Deg,
|
|
s = e
|
|
? t._localOffsetLength
|
|
: Vector2.multiply(t.localOffset, t.entity.scale).length();
|
|
this.center = MathHelper.pointOnCirlce(
|
|
Vector2.zero,
|
|
s,
|
|
MathHelper.toDegrees(t.entity.rotation) + r
|
|
);
|
|
}
|
|
(n = Matrix2D.createTranslation(
|
|
this._polygonCenter.x,
|
|
this._polygonCenter.y
|
|
)),
|
|
(i = Matrix2D.multiply(i, n)),
|
|
Vector2Ext.transform(this._originalPoints, i, this.points),
|
|
(this.isUnrotated = 0 == t.entity.rotation),
|
|
t._isRotationDirty && (this._areEdgeNormalsDirty = !0);
|
|
}
|
|
(this.position = Vector2.add(t.entity.position, this.center)),
|
|
(this.bounds = Rectangle.rectEncompassingPoints(this.points)),
|
|
(this.bounds.location = Vector2.add(
|
|
this.bounds.location,
|
|
this.position
|
|
));
|
|
}),
|
|
e
|
|
);
|
|
})(Shape),
|
|
Box = (function (t) {
|
|
function e(n, i) {
|
|
var o = t.call(this, e.buildBox(n, i), !0) || this;
|
|
return (o.width = n), (o.height = i), o;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.buildBox = function (t, e) {
|
|
var n = t / 2,
|
|
i = e / 2,
|
|
o = new Array(4);
|
|
return (
|
|
(o[0] = new Vector2(-n, -i)),
|
|
(o[1] = new Vector2(n, -i)),
|
|
(o[2] = new Vector2(n, i)),
|
|
(o[3] = new Vector2(-n, i)),
|
|
o
|
|
);
|
|
}),
|
|
(e.prototype.updateBox = function (t, e) {
|
|
(this.width = t), (this.height = e);
|
|
var n = t / 2,
|
|
i = e / 2;
|
|
(this.points[0] = new Vector2(-n, -i)),
|
|
(this.points[1] = new Vector2(n, -i)),
|
|
(this.points[2] = new Vector2(n, i)),
|
|
(this.points[3] = new Vector2(-n, i));
|
|
for (var o = 0; o < this.points.length; o++)
|
|
this._originalPoints[o] = this.points[o];
|
|
}),
|
|
(e.prototype.containsPoint = function (e) {
|
|
return this.isUnrotated
|
|
? this.bounds.contains(e)
|
|
: t.prototype.containsPoint.call(this, e);
|
|
}),
|
|
e
|
|
);
|
|
})(Polygon),
|
|
Circle = (function (t) {
|
|
function e(e) {
|
|
var n = t.call(this) || this;
|
|
return (n.radius = e), (n._originalRadius = e), n;
|
|
}
|
|
return (
|
|
__extends(e, t),
|
|
(e.prototype.pointCollidesWithShape = function (t) {
|
|
return ShapeCollisions.pointToCircle(t, this);
|
|
}),
|
|
(e.prototype.collidesWithShape = function (t) {
|
|
if (t instanceof Box && t.isUnrotated)
|
|
return ShapeCollisions.circleToBox(this, t);
|
|
if (t instanceof e) return ShapeCollisions.circleToCircle(this, t);
|
|
if (t instanceof Polygon)
|
|
return ShapeCollisions.circleToPolygon(this, t);
|
|
throw new Error("Collisions of Circle to " + t + " are not supported");
|
|
}),
|
|
(e.prototype.recalculateBounds = function (t) {
|
|
if (
|
|
((this.center = t.localOffset),
|
|
t.shouldColliderScaleAndRotationWithTransform)
|
|
) {
|
|
var e = t.entity.scale,
|
|
n = 1 == e.x && 1 == e.y,
|
|
i = Math.max(e.x, e.y);
|
|
if (
|
|
((this.radius = this._originalRadius * i), 0 != t.entity.rotation)
|
|
) {
|
|
var o =
|
|
Math.atan2(t.localOffset.y, t.localOffset.x) *
|
|
MathHelper.Rad2Deg,
|
|
r = n
|
|
? t._localOffsetLength
|
|
: Vector2.multiply(t.localOffset, t.entity.scale).length();
|
|
this.center = MathHelper.pointOnCirlce(
|
|
Vector2.zero,
|
|
r,
|
|
MathHelper.toDegrees(t.entity.rotation) + o
|
|
);
|
|
}
|
|
}
|
|
(this.position = Vector2.add(t.entity.position, this.center)),
|
|
(this.bounds = new Rectangle(
|
|
this.position.x - this.radius,
|
|
this.position.y - this.radius,
|
|
2 * this.radius,
|
|
2 * this.radius
|
|
));
|
|
}),
|
|
(e.prototype.overlaps = function (t) {
|
|
if (t instanceof Box && t.isUnrotated)
|
|
return Collisions.isRectToCircle(
|
|
t.bounds,
|
|
this.position,
|
|
this.radius
|
|
);
|
|
if (t instanceof e)
|
|
return Collisions.isCircleToCircle(
|
|
this.position,
|
|
this.radius,
|
|
t.position,
|
|
t.radius
|
|
);
|
|
if (t instanceof Polygon)
|
|
return ShapeCollisions.circleToPolygon(this, t);
|
|
throw new Error("overlaps of circle to " + t + " are not supported");
|
|
}),
|
|
e
|
|
);
|
|
})(Shape),
|
|
CollisionResult = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.prototype.invertResult = function () {
|
|
(this.minimumTranslationVector = Vector2.negate(
|
|
this.minimumTranslationVector
|
|
)),
|
|
(this.normal = Vector2.negate(this.normal));
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
ShapeCollisions = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.polygonToPolygon = function (t, e) {
|
|
for (
|
|
var n,
|
|
i = new CollisionResult(),
|
|
o = !0,
|
|
r = t.edgeNormals,
|
|
s = e.edgeNormals,
|
|
a = Number.POSITIVE_INFINITY,
|
|
h = new Vector2(),
|
|
c = Vector2.subtract(t.position, e.position),
|
|
u = 0;
|
|
u < r.length + s.length;
|
|
u++
|
|
) {
|
|
n = u < r.length ? r[u] : s[u - r.length];
|
|
var l = 0,
|
|
p = 0,
|
|
f = 0,
|
|
d = 0,
|
|
y = 0,
|
|
g = this.getInterval(n, t, l, f);
|
|
(l = g.min), (p = g.max);
|
|
var m = this.getInterval(n, e, p, d);
|
|
(p = m.min), (d = m.max);
|
|
var _ = Vector2.dot(c, n);
|
|
if (
|
|
((l += _),
|
|
(f += _),
|
|
(y = this.intervalDistance(l, f, p, d)) > 0 && (o = !1),
|
|
!o)
|
|
)
|
|
return null;
|
|
(y = Math.abs(y)) < a &&
|
|
((a = y), (h = n), Vector2.dot(h, c) < 0 && (h = new Vector2(-h)));
|
|
}
|
|
return (
|
|
(i.normal = h),
|
|
(i.minimumTranslationVector = Vector2.multiply(
|
|
new Vector2(-h),
|
|
new Vector2(a)
|
|
)),
|
|
i
|
|
);
|
|
}),
|
|
(t.intervalDistance = function (t, e, n, i) {
|
|
return t < n ? n - e : t - n;
|
|
}),
|
|
(t.getInterval = function (t, e, n, i) {
|
|
var o = Vector2.dot(e.points[0], t);
|
|
n = i = o;
|
|
for (var r = 1; r < e.points.length; r++)
|
|
(o = Vector2.dot(e.points[r], t)) < n ? (n = o) : o > i && (i = o);
|
|
return { min: n, max: i };
|
|
}),
|
|
(t.circleToPolygon = function (t, e) {
|
|
var n = new CollisionResult(),
|
|
i = Vector2.subtract(t.position, e.position),
|
|
o = Polygon.getClosestPointOnPolygonToPoint(e.points, i),
|
|
r = o.closestPoint,
|
|
s = o.distanceSquared;
|
|
n.normal = o.edgeNormal;
|
|
var a,
|
|
h = e.containsPoint(t.position);
|
|
if (s > t.radius * t.radius && !h) return null;
|
|
if (h)
|
|
a = Vector2.multiply(n.normal, new Vector2(Math.sqrt(s) - t.radius));
|
|
else if (0 == s) a = Vector2.multiply(n.normal, new Vector2(t.radius));
|
|
else {
|
|
var c = Math.sqrt(s);
|
|
a = Vector2.multiply(
|
|
new Vector2(-Vector2.subtract(i, r)),
|
|
new Vector2((t.radius - s) / c)
|
|
);
|
|
}
|
|
return (
|
|
(n.minimumTranslationVector = a),
|
|
(n.point = Vector2.add(r, e.position)),
|
|
n
|
|
);
|
|
}),
|
|
(t.circleToBox = function (t, e) {
|
|
var n = new CollisionResult(),
|
|
i = e.bounds.getClosestPointOnRectangleBorderToPoint(t.position).res;
|
|
if (e.containsPoint(t.position)) {
|
|
n.point = i;
|
|
var o = Vector2.add(
|
|
i,
|
|
Vector2.subtract(n.normal, new Vector2(t.radius))
|
|
);
|
|
return (
|
|
(n.minimumTranslationVector = Vector2.subtract(t.position, o)), n
|
|
);
|
|
}
|
|
var r = Vector2.distanceSquared(i, t.position);
|
|
if (0 == r)
|
|
n.minimumTranslationVector = Vector2.multiply(
|
|
n.normal,
|
|
new Vector2(t.radius)
|
|
);
|
|
else if (r <= t.radius * t.radius) {
|
|
n.normal = Vector2.subtract(t.position, i);
|
|
var s = n.normal.length() - t.radius;
|
|
return (
|
|
(n.normal = Vector2Ext.normalize(n.normal)),
|
|
(n.minimumTranslationVector = Vector2.multiply(
|
|
new Vector2(s),
|
|
n.normal
|
|
)),
|
|
n
|
|
);
|
|
}
|
|
return null;
|
|
}),
|
|
(t.pointToCircle = function (t, e) {
|
|
var n = new CollisionResult(),
|
|
i = Vector2.distanceSquared(t, e.position),
|
|
o = 1 + e.radius;
|
|
if (i < o * o) {
|
|
n.normal = Vector2.normalize(Vector2.subtract(t, e.position));
|
|
var r = o - Math.sqrt(i);
|
|
return (
|
|
(n.minimumTranslationVector = Vector2.multiply(
|
|
new Vector2(-r, -r),
|
|
n.normal
|
|
)),
|
|
(n.point = Vector2.add(
|
|
e.position,
|
|
Vector2.multiply(n.normal, new Vector2(e.radius, e.radius))
|
|
)),
|
|
n
|
|
);
|
|
}
|
|
return null;
|
|
}),
|
|
(t.closestPointOnLine = function (t, e, n) {
|
|
var i = Vector2.subtract(e, t),
|
|
o = Vector2.subtract(n, t),
|
|
r = Vector2.dot(o, i) / Vector2.dot(i, i);
|
|
return (
|
|
(r = MathHelper.clamp(r, 0, 1)),
|
|
Vector2.add(t, Vector2.multiply(i, new Vector2(r, r)))
|
|
);
|
|
}),
|
|
(t.pointToPoly = function (t, e) {
|
|
var n = new CollisionResult();
|
|
if (e.containsPoint(t)) {
|
|
var i,
|
|
o = Polygon.getClosestPointOnPolygonToPoint(
|
|
e.points,
|
|
Vector2.subtract(t, e.position)
|
|
),
|
|
r = o.closestPoint;
|
|
return (
|
|
(i = o.distanceSquared),
|
|
(n.normal = o.edgeNormal),
|
|
(n.minimumTranslationVector = Vector2.multiply(
|
|
n.normal,
|
|
new Vector2(Math.sqrt(i), Math.sqrt(i))
|
|
)),
|
|
(n.point = Vector2.add(r, e.position)),
|
|
n
|
|
);
|
|
}
|
|
return null;
|
|
}),
|
|
(t.circleToCircle = function (t, e) {
|
|
var n = new CollisionResult(),
|
|
i = Vector2.distanceSquared(t.position, e.position),
|
|
o = t.radius + e.radius;
|
|
if (i < o * o) {
|
|
n.normal = Vector2.normalize(
|
|
Vector2.subtract(t.position, e.position)
|
|
);
|
|
var r = o - Math.sqrt(i);
|
|
return (
|
|
(n.minimumTranslationVector = Vector2.multiply(
|
|
new Vector2(-r),
|
|
n.normal
|
|
)),
|
|
(n.point = Vector2.add(
|
|
e.position,
|
|
Vector2.multiply(n.normal, new Vector2(e.radius))
|
|
)),
|
|
n
|
|
);
|
|
}
|
|
return null;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
SpatialHash = (function () {
|
|
function t(t) {
|
|
void 0 === t && (t = 100),
|
|
(this.gridBounds = new Rectangle()),
|
|
(this._tempHashSet = []),
|
|
(this._cellDict = new NumberDictionary()),
|
|
(this._cellSize = t),
|
|
(this._inverseCellSize = 1 / this._cellSize),
|
|
(this._raycastParser = new RaycastResultParser());
|
|
}
|
|
return (
|
|
(t.prototype.remove = function (t) {
|
|
for (
|
|
var e = t.registeredPhysicsBounds,
|
|
n = this.cellCoords(e.x, e.y),
|
|
i = this.cellCoords(e.right, e.bottom),
|
|
o = n.x;
|
|
o <= i.x;
|
|
o++
|
|
)
|
|
for (var r = n.y; r <= i.y; r++) {
|
|
var s = this.cellAtPosition(o, r);
|
|
s
|
|
? s.remove(t)
|
|
: console.error(
|
|
"removing Collider [" +
|
|
t +
|
|
"] from a cell that it is not present in"
|
|
);
|
|
}
|
|
}),
|
|
(t.prototype.register = function (t) {
|
|
var e = t.bounds;
|
|
t.registeredPhysicsBounds = e;
|
|
var n = this.cellCoords(e.x, e.y),
|
|
i = this.cellCoords(e.right, e.bottom);
|
|
this.gridBounds.contains(new Vector2(n.x, n.y)) ||
|
|
(this.gridBounds = RectangleExt.union(this.gridBounds, n)),
|
|
this.gridBounds.contains(new Vector2(i.x, i.y)) ||
|
|
(this.gridBounds = RectangleExt.union(this.gridBounds, i));
|
|
for (var o = n.x; o <= i.x; o++)
|
|
for (var r = n.y; r <= i.y; r++) {
|
|
this.cellAtPosition(o, r, !0).push(t);
|
|
}
|
|
}),
|
|
(t.prototype.clear = function () {
|
|
this._cellDict.clear();
|
|
}),
|
|
(t.prototype.overlapCircle = function (t, e, n, i) {
|
|
var o = new Rectangle(t.x - e, t.y - e, 2 * e, 2 * e);
|
|
(this._overlapTestCircle.radius = e),
|
|
(this._overlapTestCircle.position = t);
|
|
for (
|
|
var r = 0, s = this.aabbBroadphase(o, null, i), a = 0;
|
|
a < s.length;
|
|
a++
|
|
) {
|
|
var h = s[a];
|
|
if (!(h instanceof BoxCollider))
|
|
throw new Error(
|
|
"overlapCircle against this collider type is not implemented!"
|
|
);
|
|
if (((n[r] = h), ++r == n.length)) return r;
|
|
}
|
|
return r;
|
|
}),
|
|
(t.prototype.aabbBroadphase = function (t, e, n) {
|
|
this._tempHashSet.length = 0;
|
|
for (
|
|
var i = this.cellCoords(t.x, t.y),
|
|
o = this.cellCoords(t.right, t.bottom),
|
|
r = i.x;
|
|
r <= o.x;
|
|
r++
|
|
)
|
|
for (var s = i.y; s <= o.y; s++) {
|
|
var a = this.cellAtPosition(r, s);
|
|
if (a)
|
|
for (var h = 0; h < a.length; h++) {
|
|
var c = a[h];
|
|
c != e &&
|
|
Flags.isFlagSet(n, c.physicsLayer) &&
|
|
t.intersects(c.bounds) &&
|
|
-1 == this._tempHashSet.indexOf(c) &&
|
|
this._tempHashSet.push(c);
|
|
}
|
|
}
|
|
return this._tempHashSet;
|
|
}),
|
|
(t.prototype.cellAtPosition = function (t, e, n) {
|
|
void 0 === n && (n = !1);
|
|
var i = this._cellDict.tryGetValue(t, e);
|
|
return i || (n && ((i = []), this._cellDict.add(t, e, i))), i;
|
|
}),
|
|
(t.prototype.cellCoords = function (t, e) {
|
|
return new Point(
|
|
Math.floor(t * this._inverseCellSize),
|
|
Math.floor(e * this._inverseCellSize)
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
RaycastResultParser = (function () {
|
|
return function () {};
|
|
})(),
|
|
NumberDictionary = (function () {
|
|
function t() {
|
|
this._store = new Map();
|
|
}
|
|
return (
|
|
(t.prototype.getKey = function (t, e) {
|
|
return Long.fromNumber(t)
|
|
.shiftLeft(32)
|
|
.or(this.intToUint(e))
|
|
.toString();
|
|
}),
|
|
(t.prototype.intToUint = function (t) {
|
|
return t >= 0 ? t : 4294967296 + t;
|
|
}),
|
|
(t.prototype.add = function (t, e, n) {
|
|
this._store.set(this.getKey(t, e), n);
|
|
}),
|
|
(t.prototype.remove = function (t) {
|
|
this._store.forEach(function (e) {
|
|
e.contains(t) && e.remove(t);
|
|
});
|
|
}),
|
|
(t.prototype.tryGetValue = function (t, e) {
|
|
return this._store.get(this.getKey(t, e));
|
|
}),
|
|
(t.prototype.clear = function () {
|
|
this._store.clear();
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
ContentManager = (function () {
|
|
function t() {
|
|
this.loadedAssets = new Map();
|
|
}
|
|
return (
|
|
(t.prototype.loadRes = function (t, e) {
|
|
var n = this;
|
|
return (
|
|
void 0 === e && (e = !0),
|
|
new Promise(function (i, o) {
|
|
var r = n.loadedAssets.get(t);
|
|
r
|
|
? i(r)
|
|
: e
|
|
? RES.getResAsync(t)
|
|
.then(function (e) {
|
|
n.loadedAssets.set(t, e), i(e);
|
|
})
|
|
.catch(function (e) {
|
|
console.error("资源加载错误:", t, e), o(e);
|
|
})
|
|
: RES.getResByUrl(t)
|
|
.then(function (e) {
|
|
n.loadedAssets.set(t, e), i(e);
|
|
})
|
|
.catch(function (e) {
|
|
console.error("资源加载错误:", t, e), o(e);
|
|
});
|
|
})
|
|
);
|
|
}),
|
|
(t.prototype.dispose = function () {
|
|
this.loadedAssets.forEach(function (t) {
|
|
t.dispose();
|
|
}),
|
|
this.loadedAssets.clear();
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Emitter = (function () {
|
|
function t() {
|
|
this._messageTable = new Map();
|
|
}
|
|
return (
|
|
(t.prototype.addObserver = function (t, e) {
|
|
var n = this._messageTable.get(t);
|
|
n || ((n = []), this._messageTable.set(t, n)),
|
|
n.contains(e) && console.warn("您试图添加相同的观察者两次"),
|
|
n.push(e);
|
|
}),
|
|
(t.prototype.removeObserver = function (t, e) {
|
|
this._messageTable.get(t).remove(e);
|
|
}),
|
|
(t.prototype.emit = function (t, e) {
|
|
var n = this._messageTable.get(t);
|
|
if (n) for (var i = n.length - 1; i >= 0; i--) n[i](e);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
GlobalManager = (function () {
|
|
function t() {}
|
|
return (
|
|
Object.defineProperty(t.prototype, "enabled", {
|
|
get: function () {
|
|
return this._enabled;
|
|
},
|
|
set: function (t) {
|
|
this.setEnabled(t);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.setEnabled = function (t) {
|
|
this._enabled != t &&
|
|
((this._enabled = t),
|
|
this._enabled ? this.onEnabled() : this.onDisabled());
|
|
}),
|
|
(t.prototype.onEnabled = function () {}),
|
|
(t.prototype.onDisabled = function () {}),
|
|
(t.prototype.update = function () {}),
|
|
(t.registerGlobalManager = function (t) {
|
|
this.globalManagers.push(t), (t.enabled = !0);
|
|
}),
|
|
(t.unregisterGlobalManager = function (t) {
|
|
this.globalManagers.remove(t), (t.enabled = !1);
|
|
}),
|
|
(t.getGlobalManager = function (t) {
|
|
for (var e = 0; e < this.globalManagers.length; e++)
|
|
if (this.globalManagers[e] instanceof t)
|
|
return this.globalManagers[e];
|
|
return null;
|
|
}),
|
|
(t.globalManagers = []),
|
|
t
|
|
);
|
|
})(),
|
|
TouchState = (function () {
|
|
function t() {
|
|
(this.x = 0), (this.y = 0), (this.touchPoint = -1), (this.touchDown = !1);
|
|
}
|
|
return (
|
|
Object.defineProperty(t.prototype, "position", {
|
|
get: function () {
|
|
return new Vector2(this.x, this.y);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.prototype.reset = function () {
|
|
(this.x = 0),
|
|
(this.y = 0),
|
|
(this.touchDown = !1),
|
|
(this.touchPoint = -1);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Input = (function () {
|
|
function t() {}
|
|
return (
|
|
Object.defineProperty(t, "touchPosition", {
|
|
get: function () {
|
|
return this._gameTouchs[0]
|
|
? this._gameTouchs[0].position
|
|
: Vector2.zero;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "maxSupportedTouch", {
|
|
get: function () {
|
|
return this._stage.maxTouches;
|
|
},
|
|
set: function (t) {
|
|
(this._stage.maxTouches = t), this.initTouchCache();
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "resolutionScale", {
|
|
get: function () {
|
|
return this._resolutionScale;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "totalTouchCount", {
|
|
get: function () {
|
|
return this._totalTouchCount;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "gameTouchs", {
|
|
get: function () {
|
|
return this._gameTouchs;
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
Object.defineProperty(t, "touchPositionDelta", {
|
|
get: function () {
|
|
var t = Vector2.subtract(
|
|
this.touchPosition,
|
|
this._previousTouchState.position
|
|
);
|
|
return (
|
|
t.length() > 0 && this.setpreviousTouchState(this._gameTouchs[0]), t
|
|
);
|
|
},
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(t.initialize = function (t) {
|
|
this._init ||
|
|
((this._init = !0),
|
|
(this._stage = t),
|
|
this._stage.addEventListener(
|
|
egret.TouchEvent.TOUCH_BEGIN,
|
|
this.touchBegin,
|
|
this
|
|
),
|
|
this._stage.addEventListener(
|
|
egret.TouchEvent.TOUCH_MOVE,
|
|
this.touchMove,
|
|
this
|
|
),
|
|
this._stage.addEventListener(
|
|
egret.TouchEvent.TOUCH_END,
|
|
this.touchEnd,
|
|
this
|
|
),
|
|
this._stage.addEventListener(
|
|
egret.TouchEvent.TOUCH_CANCEL,
|
|
this.touchEnd,
|
|
this
|
|
),
|
|
this._stage.addEventListener(
|
|
egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,
|
|
this.touchEnd,
|
|
this
|
|
),
|
|
this.initTouchCache());
|
|
}),
|
|
(t.initTouchCache = function () {
|
|
(this._totalTouchCount = 0),
|
|
(this._touchIndex = 0),
|
|
(this._gameTouchs.length = 0);
|
|
for (var t = 0; t < this.maxSupportedTouch; t++)
|
|
this._gameTouchs.push(new TouchState());
|
|
}),
|
|
(t.touchBegin = function (t) {
|
|
this._touchIndex < this.maxSupportedTouch &&
|
|
((this._gameTouchs[this._touchIndex].touchPoint = t.touchPointID),
|
|
(this._gameTouchs[this._touchIndex].touchDown = t.touchDown),
|
|
(this._gameTouchs[this._touchIndex].x = t.stageX),
|
|
(this._gameTouchs[this._touchIndex].y = t.stageY),
|
|
0 == this._touchIndex &&
|
|
this.setpreviousTouchState(this._gameTouchs[0]),
|
|
this._touchIndex++,
|
|
this._totalTouchCount++);
|
|
}),
|
|
(t.touchMove = function (t) {
|
|
t.touchPointID == this._gameTouchs[0].touchPoint &&
|
|
this.setpreviousTouchState(this._gameTouchs[0]);
|
|
var e = this._gameTouchs.findIndex(function (e) {
|
|
return e.touchPoint == t.touchPointID;
|
|
});
|
|
if (-1 != e) {
|
|
var n = this._gameTouchs[e];
|
|
(n.x = t.stageX), (n.y = t.stageY);
|
|
}
|
|
}),
|
|
(t.touchEnd = function (t) {
|
|
var e = this._gameTouchs.findIndex(function (e) {
|
|
return e.touchPoint == t.touchPointID;
|
|
});
|
|
-1 != e &&
|
|
(this._gameTouchs[e].reset(),
|
|
0 == e && this._previousTouchState.reset(),
|
|
this._totalTouchCount--,
|
|
0 == this.totalTouchCount && (this._touchIndex = 0));
|
|
}),
|
|
(t.setpreviousTouchState = function (t) {
|
|
(this._previousTouchState = new TouchState()),
|
|
(this._previousTouchState.x = t.position.x),
|
|
(this._previousTouchState.y = t.position.y),
|
|
(this._previousTouchState.touchPoint = t.touchPoint),
|
|
(this._previousTouchState.touchDown = t.touchDown);
|
|
}),
|
|
(t.scaledPosition = function (t) {
|
|
var e = new Vector2(
|
|
t.x - this._resolutionOffset.x,
|
|
t.y - this._resolutionOffset.y
|
|
);
|
|
return Vector2.multiply(e, this.resolutionScale);
|
|
}),
|
|
(t._init = !1),
|
|
(t._previousTouchState = new TouchState()),
|
|
(t._gameTouchs = []),
|
|
(t._resolutionOffset = new Vector2()),
|
|
(t._resolutionScale = Vector2.one),
|
|
(t._touchIndex = 0),
|
|
(t._totalTouchCount = 0),
|
|
t
|
|
);
|
|
})(),
|
|
ListPool = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.warmCache = function (t) {
|
|
if ((t -= this._objectQueue.length) > 0)
|
|
for (var e = 0; e < t; e++) this._objectQueue.unshift([]);
|
|
}),
|
|
(t.trimCache = function (t) {
|
|
for (; t > this._objectQueue.length; ) this._objectQueue.shift();
|
|
}),
|
|
(t.clearCache = function () {
|
|
this._objectQueue.length = 0;
|
|
}),
|
|
(t.obtain = function () {
|
|
return this._objectQueue.length > 0 ? this._objectQueue.shift() : [];
|
|
}),
|
|
(t.free = function (t) {
|
|
this._objectQueue.unshift(t), (t.length = 0);
|
|
}),
|
|
(t._objectQueue = []),
|
|
t
|
|
);
|
|
})(),
|
|
Pair = (function () {
|
|
function t(t, e) {
|
|
(this.first = t), (this.second = e);
|
|
}
|
|
return (
|
|
(t.prototype.clear = function () {
|
|
this.first = this.second = null;
|
|
}),
|
|
(t.prototype.equals = function (t) {
|
|
return this.first == t.first && this.second == t.second;
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
RectangleExt = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.union = function (t, e) {
|
|
var n = new Rectangle(e.x, e.y, 0, 0);
|
|
return this.unionR(t, n);
|
|
}),
|
|
(t.unionR = function (t, e) {
|
|
var n = new Rectangle();
|
|
return (
|
|
(n.x = Math.min(t.x, e.x)),
|
|
(n.y = Math.min(t.y, e.y)),
|
|
(n.width = Math.max(t.right, e.right) - n.x),
|
|
(n.height = Math.max(t.bottom, e.bottom) - n.y),
|
|
n
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Triangulator = (function () {
|
|
function t() {
|
|
(this.triangleIndices = []),
|
|
(this._triPrev = new Array(12)),
|
|
(this._triNext = new Array(12));
|
|
}
|
|
return (
|
|
(t.prototype.triangulate = function (e, n) {
|
|
void 0 === n && (n = !0);
|
|
var i = e.length;
|
|
this.initialize(i);
|
|
for (var o = 0, r = 0; i > 3 && o < 500; ) {
|
|
o++;
|
|
var s = !0,
|
|
a = e[this._triPrev[r]],
|
|
h = e[r],
|
|
c = e[this._triNext[r]];
|
|
if (Vector2Ext.isTriangleCCW(a, h, c)) {
|
|
var u = this._triNext[this._triNext[r]];
|
|
do {
|
|
if (t.testPointTriangle(e[u], a, h, c)) {
|
|
s = !1;
|
|
break;
|
|
}
|
|
u = this._triNext[u];
|
|
} while (u != this._triPrev[r]);
|
|
} else s = !1;
|
|
s
|
|
? (this.triangleIndices.push(this._triPrev[r]),
|
|
this.triangleIndices.push(r),
|
|
this.triangleIndices.push(this._triNext[r]),
|
|
(this._triNext[this._triPrev[r]] = this._triNext[r]),
|
|
(this._triPrev[this._triNext[r]] = this._triPrev[r]),
|
|
i--,
|
|
(r = this._triPrev[r]))
|
|
: (r = this._triNext[r]);
|
|
}
|
|
this.triangleIndices.push(this._triPrev[r]),
|
|
this.triangleIndices.push(r),
|
|
this.triangleIndices.push(this._triNext[r]),
|
|
n || this.triangleIndices.reverse();
|
|
}),
|
|
(t.prototype.initialize = function (t) {
|
|
(this.triangleIndices.length = 0),
|
|
this._triNext.length < t &&
|
|
(this._triNext.reverse(),
|
|
(this._triNext = new Array(Math.max(2 * this._triNext.length, t)))),
|
|
this._triPrev.length < t &&
|
|
(this._triPrev.reverse(),
|
|
(this._triPrev = new Array(Math.max(2 * this._triPrev.length, t))));
|
|
for (var e = 0; e < t; e++)
|
|
(this._triPrev[e] = e - 1), (this._triNext[e] = e + 1);
|
|
(this._triPrev[0] = t - 1), (this._triNext[t - 1] = 0);
|
|
}),
|
|
(t.testPointTriangle = function (t, e, n, i) {
|
|
return (
|
|
!(
|
|
Vector2Ext.cross(Vector2.subtract(t, e), Vector2.subtract(n, e)) < 0
|
|
) &&
|
|
!(
|
|
Vector2Ext.cross(Vector2.subtract(t, n), Vector2.subtract(i, n)) < 0
|
|
) &&
|
|
!(
|
|
Vector2Ext.cross(Vector2.subtract(t, i), Vector2.subtract(e, i)) < 0
|
|
)
|
|
);
|
|
}),
|
|
t
|
|
);
|
|
})(),
|
|
Vector2Ext = (function () {
|
|
function t() {}
|
|
return (
|
|
(t.isTriangleCCW = function (t, e, n) {
|
|
return this.cross(Vector2.subtract(e, t), Vector2.subtract(n, e)) < 0;
|
|
}),
|
|
(t.cross = function (t, e) {
|
|
return t.y * e.x - t.x * e.y;
|
|
}),
|
|
(t.perpendicular = function (t, e) {
|
|
return new Vector2(-1 * (e.y - t.y), e.x - t.x);
|
|
}),
|
|
(t.normalize = function (t) {
|
|
var e = Math.sqrt(t.x * t.x + t.y * t.y);
|
|
return (
|
|
e > MathHelper.Epsilon
|
|
? (t = Vector2.divide(t, new Vector2(e)))
|
|
: (t.x = t.y = 0),
|
|
t
|
|
);
|
|
}),
|
|
(t.transformA = function (t, e, n, i, o, r) {
|
|
for (var s = 0; s < r; s++) {
|
|
var a = t[e + s],
|
|
h = i[o + s];
|
|
(h.x = a.x * n.m11 + a.y * n.m21 + n.m31),
|
|
(h.y = a.x * n.m12 + a.y * n.m22 + n.m32),
|
|
(i[o + s] = h);
|
|
}
|
|
}),
|
|
(t.transformR = function (t, e) {
|
|
var n = t.x * e.m11 + t.y * e.m21 + e.m31,
|
|
i = t.x * e.m12 + t.y * e.m22 + e.m32;
|
|
return new Vector2(n, i);
|
|
}),
|
|
(t.transform = function (t, e, n) {
|
|
this.transformA(t, 0, e, n, 0, t.length);
|
|
}),
|
|
(t.round = function (t) {
|
|
return new Vector2(Math.round(t.x), Math.round(t.y));
|
|
}),
|
|
t
|
|
);
|
|
})();
|