1925 lines
53 KiB
JavaScript
1925 lines
53 KiB
JavaScript
'use strict';
|
|
var duilib;
|
|
(function (duilib) {
|
|
|
|
duilib.throttle = function (func, timeout, context) {
|
|
var args;
|
|
var timer;
|
|
var previous;
|
|
return function () {
|
|
if (timer)
|
|
clearTimeout(timer);
|
|
|
|
if (previous == null)
|
|
previous = performance.now();
|
|
|
|
args = arguments;
|
|
var timestamp = performance.now() - previous;
|
|
if (timestamp >= timeout) {
|
|
timer = null;
|
|
previous = null;
|
|
func.apply(context, args);
|
|
} else {
|
|
timer = setTimeout(function () {
|
|
timer = null;
|
|
previous = null;
|
|
func.apply(context, args);
|
|
}, timeout - timestamp);
|
|
}
|
|
}
|
|
};
|
|
|
|
duilib.observeSize = (function () {
|
|
if (!self.ResizeObserver)
|
|
return null;
|
|
|
|
var observer = new ResizeObserver(function (entries) {
|
|
var rect;
|
|
var callback;
|
|
for (var i = 0; i < entries.length; i++) {
|
|
callback = observer.callbacks[entries[i].target.observeId];
|
|
if (callback == null)
|
|
continue;
|
|
|
|
rect = entries[i].contentRect;
|
|
callback({ width: rect.width, height: rect.height });
|
|
}
|
|
});
|
|
|
|
observer.observeId = 0;
|
|
observer.callbacks = {};
|
|
return function (target, callback) {
|
|
var obs = observer;
|
|
target.observeId = obs.observeId++;
|
|
obs.observe(target);
|
|
obs.callbacks[target.observeId] = callback;
|
|
}
|
|
})();
|
|
|
|
duilib.lerp = function (min, max, fraction) {
|
|
return (max - min) * fraction + min;
|
|
};
|
|
|
|
duilib.ease = function (fraction) {
|
|
if (!duilib.b3ease) duilib.b3ease = new duilib.CubicBezierEase(0.25, 0.1, 0.25, 1);
|
|
return duilib.b3ease.ease(fraction);
|
|
},
|
|
|
|
duilib.CubicBezierEase = (function () {
|
|
function CubicBezierEase(p1x, p1y, p2x, p2y) {
|
|
this.cX = 3 * p1x;
|
|
this.bX = 3 * (p2x - p1x) - this.cX;
|
|
this.aX = 1 - this.cX - this.bX;
|
|
|
|
this.cY = 3 * p1y;
|
|
this.bY = 3 * (p2y - p1y) - this.cY;
|
|
this.aY = 1 - this.cY - this.bY;
|
|
};
|
|
|
|
CubicBezierEase.prototype.getX = function (t) {
|
|
return t * (this.cX + t * (this.bX + t * this.aX));
|
|
};
|
|
|
|
CubicBezierEase.prototype.getXDerivative = function (t) {
|
|
return this.cX + t * (2 * this.bX + 3 * this.aX * t);
|
|
};
|
|
|
|
CubicBezierEase.prototype.ease = function (x) {
|
|
var prev,
|
|
t = x;
|
|
do {
|
|
prev = t;
|
|
t = t - ((this.getX(t) - x) / this.getXDerivative(t));
|
|
} while (Math.abs(t - prev) > 1e-4);
|
|
|
|
|
|
return t * (this.cY + t * (this.bY + t * this.aY));
|
|
};
|
|
|
|
return CubicBezierEase;
|
|
})();
|
|
|
|
duilib.TimeStep = (function () {
|
|
function TimeStep(initParam) {
|
|
this.start = initParam.start;
|
|
this.current = initParam.start;
|
|
this.end = initParam.end;
|
|
this.time = 0;
|
|
this.percent = 0;
|
|
this.duration = initParam.duration;
|
|
this.completed = false;
|
|
};
|
|
|
|
TimeStep.prototype.update = function (delta) {
|
|
this.time += delta;
|
|
this.percent = duilib.ease(Math.min(this.time / this.duration, 1));
|
|
|
|
var start, end;
|
|
var isArray = false;
|
|
if (Array.isArray(this.start)) {
|
|
isArray = true;
|
|
start = this.start;
|
|
} else {
|
|
start = [this.start, 0];
|
|
}
|
|
|
|
if (Array.isArray(this.end)) {
|
|
isArray = true;
|
|
end = this.end;
|
|
} else {
|
|
end = [this.end, 0];
|
|
}
|
|
|
|
if (isArray) {
|
|
this.current = [duilib.lerp(start[0], end[0], this.percent), duilib.lerp(start[1], end[1], this.percent)];
|
|
} else {
|
|
this.current = duilib.lerp(start[0], end[0], this.percent);
|
|
}
|
|
|
|
if (this.time >= this.duration) this.completed = true;
|
|
};
|
|
|
|
return TimeStep;
|
|
})();
|
|
|
|
duilib.APNode = (function () {
|
|
function APNode(initParam) {
|
|
if (initParam == undefined) initParam = {};
|
|
this.id = undefined; // 内部属性，不可更改
|
|
this.x = initParam.x;
|
|
this.y = initParam.y;
|
|
this.height = initParam.height;
|
|
this.width = initParam.width;
|
|
this.angle = initParam.angle;
|
|
this.scale = initParam.scale;
|
|
this.opacity = initParam.opacity;
|
|
this.clip = initParam.clip;
|
|
this.hideSlots = initParam.hideSlots;
|
|
this.clipSlots = initParam.clipSlots;
|
|
this.disableMask = initParam.disableMask;
|
|
this.renderX = undefined; // 内部属性，不可更改
|
|
this.renderY = undefined; // 内部属性，不可更改
|
|
this.renderAngle = undefined; // 内部属性，不可更改
|
|
this.renderScale = undefined; // 内部属性，不可更改
|
|
this.renderOpacity = undefined; // 内部属性，不可更改
|
|
this.renderClip = undefined; // 内部属性，不可更改
|
|
this.mvp = new spine.webgl.Matrix4(); // 内部属性，不可更改
|
|
this.skeleton = initParam.skeleton; // 内部属性，不可更改
|
|
this.name = initParam.name; // 内部属性，不可更改
|
|
this.action = initParam.action; // 内部属性，不可更改
|
|
this.loop = initParam.loop;
|
|
this.loopCount = initParam.loopCount;
|
|
this.speed = initParam.speed;
|
|
this.onupdate = initParam.onupdate;
|
|
this.oncomplete = initParam.oncomplete;
|
|
this.completed = true; // 内部属性，不可更改
|
|
this.referNode = initParam.referNode;
|
|
this.referFollow = initParam.referFollow;
|
|
this.referBounds = undefined; // 内部属性，不可更改
|
|
this.timestepMap = {}; // 内部属性，不可更改
|
|
this.flipX = initParam.flipX;
|
|
this.flipY = initParam.flipY;
|
|
};
|
|
|
|
APNode.prototype.fadeTo = function (opacity, duration) {
|
|
if (opacity != undefined) {
|
|
this.updateTimeStep('opacity', (this.opacity == undefined ? 1 : this.opacity), opacity, duration);
|
|
this.opacity = opacity;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
APNode.prototype.moveTo = function (x, y, duration) {
|
|
if (x != undefined) {
|
|
this.updateTimeStep('x', (this.x == undefined ? [0, 0.5] : this.x), x, duration);
|
|
this.x = x;
|
|
}
|
|
|
|
if (y != undefined) {
|
|
this.updateTimeStep('y', (this.y == undefined ? [0, 0.5] : this.y), y, duration);
|
|
this.y = y;
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
APNode.prototype.scaleTo = function (scale, duration) {
|
|
if (scale != undefined) {
|
|
this.updateTimeStep('scale', (this.scale == undefined ? 1 : this.scale), scale, duration);
|
|
this.scale = scale;
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
APNode.prototype.rotateTo = function (angle, duration) {
|
|
if (angle != undefined) {
|
|
this.updateTimeStep('angle', (this.angle == undefined ? 0 : this.angle), angle, duration);
|
|
this.angle = angle;
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
APNode.prototype.update = function (e) {
|
|
function calc(value, refer, dpr) {
|
|
if (Array.isArray(value)) {
|
|
return value[0] * dpr + value[1] * refer;
|
|
} else {
|
|
return value * dpr;
|
|
}
|
|
}
|
|
|
|
var domX, domY, domDefaultX, domDefaultY;
|
|
var dpr = e.dpr;
|
|
var referSize = { width: e.canvas.width, height: e.canvas.height };
|
|
var domNode = this.referNode instanceof HTMLElement ? this.referNode : undefined;
|
|
if (domNode) {
|
|
if (this.referFollow || !this.referBounds) {
|
|
var rect = domNode.getBoundingClientRect();
|
|
this.referBounds = {
|
|
x: rect.left,
|
|
y: decadeUI.get.bodySize().height - rect.bottom,
|
|
width: rect.width,
|
|
height: rect.height,
|
|
};
|
|
}
|
|
|
|
referSize.height = this.referBounds.height * dpr;
|
|
referSize.width = this.referBounds.width * dpr;
|
|
}
|
|
|
|
var timestep, percent;
|
|
var renderX, renderY, renderScale, renderScaleX, renderScaleY;
|
|
var skeletonSize = this.skeleton.bounds.size;
|
|
|
|
timestep = this.timestepMap.x;
|
|
if (timestep != undefined && !timestep.completed) {
|
|
timestep.update(e.delta);
|
|
renderX = calc(timestep.current, referSize.width, dpr);
|
|
} else if (this.x != undefined) {
|
|
renderX = calc(this.x, referSize.width, dpr);
|
|
}
|
|
|
|
timestep = this.timestepMap.y;
|
|
if (timestep != undefined && !timestep.completed) {
|
|
timestep.update(e.delta);
|
|
renderY = calc(timestep.current, referSize.height, dpr);
|
|
} else if (this.y != undefined) {
|
|
renderY = calc(this.y, referSize.height, dpr);
|
|
}
|
|
|
|
if (this.width != undefined) renderScaleX = calc(this.width, referSize.width, dpr) / skeletonSize.x;
|
|
if (this.height != undefined) renderScaleY = calc(this.height, referSize.height, dpr) / skeletonSize.y;
|
|
|
|
if (domNode) {
|
|
if (renderX == undefined) {
|
|
renderX = (this.referBounds.x + this.referBounds.width / 2) * dpr;
|
|
} else {
|
|
renderX += this.referBounds.x * dpr;
|
|
}
|
|
|
|
if (renderY == undefined) {
|
|
renderY = (this.referBounds.y + this.referBounds.height / 2) * dpr;;
|
|
} else {
|
|
renderY += this.referBounds.y * dpr;;
|
|
}
|
|
}
|
|
|
|
this.mvp.ortho2d(0, 0, e.canvas.width, e.canvas.height);
|
|
if (renderX != void 0 && renderY == void 0) {
|
|
this.mvp.translate(renderX, 0, 0);
|
|
this.mvp.setY(0);
|
|
} else if (renderX == void 0 && renderY != void 0) {
|
|
this.mvp.translate(0, renderY, 0);
|
|
this.mvp.setX(0);
|
|
} else if (renderX != void 0 && renderY != void 0) {
|
|
this.mvp.translate(renderX, renderY, 0);
|
|
} else {
|
|
this.mvp.setPos2D(0, 0);
|
|
}
|
|
|
|
timestep = this.timestepMap.scale;
|
|
if (timestep != undefined && !timestep.completed) {
|
|
timestep.update(e.delta);
|
|
renderScale = timestep.current;
|
|
} else {
|
|
renderScale = (this.scale == undefined ? 1 : this.scale);
|
|
}
|
|
|
|
if (renderScaleX && !renderScaleY) {
|
|
renderScale *= renderScaleX;
|
|
} else if (!renderScaleX && renderScaleY) {
|
|
renderScale *= renderScaleY;
|
|
} else if (renderScaleX && renderScaleY) {
|
|
renderScale *= Math.min(renderScaleX, renderScaleY);
|
|
} else {
|
|
renderScale *= dpr;
|
|
}
|
|
|
|
if (renderScale != 1) {
|
|
this.mvp.scale(renderScale, renderScale, 0);
|
|
}
|
|
|
|
timestep = this.timestepMap.angle;
|
|
if (timestep != undefined && !timestep.completed) {
|
|
timestep.update(e.delta);
|
|
this.renderAngle = timestep.current;
|
|
} else {
|
|
this.renderAngle = this.angle;
|
|
}
|
|
|
|
if (this.renderAngle) {
|
|
this.mvp.rotate(this.renderAngle, 0, 0, 1);
|
|
}
|
|
|
|
timestep = this.timestepMap.opacity;
|
|
if (timestep != undefined && !timestep.completed) {
|
|
timestep.update(e.delta);
|
|
this.renderOpacity = timestep.current;
|
|
} else {
|
|
this.renderOpacity = this.opacity;
|
|
}
|
|
|
|
this.renderX = renderX; this.renderY = renderY; this.renderScale = renderScale;
|
|
if (this.clip) {
|
|
this.renderClip = {
|
|
x: calc(this.clip.x, e.canvas.width, dpr),
|
|
y: calc(this.clip.y, e.canvas.height, dpr),
|
|
width: calc(this.clip.width, e.canvas.width, dpr),
|
|
height: calc(this.clip.height, e.canvas.height, dpr)
|
|
};
|
|
}
|
|
|
|
if (this.onupdate) this.onupdate();
|
|
};
|
|
|
|
APNode.prototype.setAction = function (action, transtion) {
|
|
if (this.skeleton && this.skeleton.node == this) {
|
|
if (this.skeleton.data.findAnimation(action) == null) return console.error('setAction: 未找到对应骨骼动作');
|
|
transtion = transtion == undefined ? 0.5 : transtion / 1000;
|
|
var entry = this.skeleton.state.setAnimation(0, action, this.loop);
|
|
entry.mixDuration = transtion;
|
|
} else {
|
|
console.error('setAction: 节点失去关联');
|
|
}
|
|
};
|
|
|
|
APNode.prototype.resetAction = function (transtion) {
|
|
if (this.skeleton && this.skeleton.node == this) {
|
|
transtion = transtion == undefined ? 0.5 : transtion / 1000;
|
|
var entry = this.skeleton.state.setAnimation(0, this.skeleton.defaultAction, this.loop);
|
|
entry.mixDuration = transtion;
|
|
} else {
|
|
console.error('resetAction: 节点失去关联');
|
|
}
|
|
};
|
|
|
|
APNode.prototype.complete = function () {
|
|
if (!this.oncomplete)
|
|
return;
|
|
|
|
if (typeof this.oncomplete == 'string') {
|
|
var code = this.oncomplete;
|
|
var a = code.indexOf('{');
|
|
var b = code.lastIndexOf('}');
|
|
if (a == -1 || b == -1) {
|
|
this.oncomplete = undefined;
|
|
return console.error(this.name + ' 的oncomplete函数语法错误');
|
|
}
|
|
|
|
this.oncomplete = new Function(code.substring(a + 1, b));
|
|
}
|
|
|
|
|
|
if (typeof this.oncomplete == 'function')
|
|
this.oncomplete();
|
|
};
|
|
|
|
APNode.prototype.updateTimeStep = function (key, start, end, duration) {
|
|
if (duration == undefined || duration == 0)
|
|
return;
|
|
|
|
var timestep = this.timestepMap[key];
|
|
if (timestep) {
|
|
timestep.start = timestep.completed ? start : timestep.current;
|
|
timestep.end = end;
|
|
timestep.time = 0;
|
|
timestep.percent = 0;
|
|
timestep.completed = false;
|
|
timestep.duration = duration;
|
|
} else {
|
|
timestep = this.timestepMap[key] = new duilib.TimeStep({
|
|
start: start,
|
|
end: end,
|
|
duration: duration,
|
|
});
|
|
}
|
|
|
|
return timestep;
|
|
}
|
|
|
|
return APNode;
|
|
})();
|
|
|
|
duilib.AnimationPlayer = (function () {
|
|
function AnimationPlayer(pathPrefix, parentNode, elementId) {
|
|
if (!window.spine) return console.error('spine 未定义.');
|
|
|
|
var canvas;
|
|
if (parentNode === 'offscreen') {
|
|
canvas = elementId
|
|
this.offscreen = true;
|
|
} else {
|
|
canvas = document.createElement('canvas');
|
|
canvas.className = 'animation-player';
|
|
if (elementId != undefined) canvas.id = elementId;
|
|
if (parentNode != undefined) parentNode.appendChild(canvas);
|
|
}
|
|
|
|
var config = { alpha: true };
|
|
var gl = canvas.getContext('webgl2', config);
|
|
if (gl == undefined) {
|
|
gl = canvas.getContext('webgl', config) || canvas.getContext('experimental-webgl', config);
|
|
} else {
|
|
gl.isWebgl2 = true;
|
|
}
|
|
|
|
if (gl) {
|
|
this.spine = {
|
|
shader: spine.webgl.Shader.newTwoColoredTextured(gl),
|
|
batcher: new spine.webgl.PolygonBatcher(gl),
|
|
skeletonRenderer: new spine.webgl.SkeletonRenderer(gl),
|
|
assetManager: new spine.webgl.AssetManager(gl, pathPrefix),
|
|
assets: {},
|
|
skeletons: [],
|
|
}
|
|
} else {
|
|
this.spine = { assets: {} };
|
|
console.error('当前设备不支持 WebGL.');
|
|
}
|
|
|
|
this.gl = gl;
|
|
this.canvas = canvas;
|
|
this.$canvas = canvas;
|
|
this.frameTime = undefined;
|
|
this.running = false;
|
|
this.resized = false;
|
|
this.dpr = 1;
|
|
this.nodes = [];
|
|
this.BUILT_ID = 0;
|
|
this._dprAdaptive = false;
|
|
|
|
Object.defineProperties(this, {
|
|
dprAdaptive: {
|
|
get: function () {
|
|
return this._dprAdaptive;
|
|
},
|
|
set: function (value) {
|
|
if (this._dprAdaptive == value) return;
|
|
this._dprAdaptive = value;
|
|
this.resized = false;
|
|
},
|
|
},
|
|
useMipMaps: {
|
|
get: function () {
|
|
if (!gl) return;
|
|
return this.gl.useMipMaps;
|
|
},
|
|
set: function (value) {
|
|
if (!gl) return;
|
|
this.gl.useMipMaps = value;
|
|
},
|
|
}
|
|
});
|
|
|
|
if (!this.offscreen) {
|
|
this.canvas.width = canvas.clientWidth;
|
|
this.canvas.height = canvas.clientHeight;
|
|
}
|
|
|
|
this.check = function () {
|
|
if (!this.gl) {
|
|
function empty() { };
|
|
var key;
|
|
for (key in this.__proto__) {
|
|
if (typeof this.__proto__[key] == 'function') {
|
|
this.__proto__[key] = empty;
|
|
}
|
|
}
|
|
|
|
for (key in this) {
|
|
if (typeof this[key] == 'function' && key != 'check') {
|
|
this[key] = empty;
|
|
}
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
this.check();
|
|
};
|
|
|
|
AnimationPlayer.prototype.createTextureRegion = function (image, name) {
|
|
var page = new spine.TextureAtlasPage();
|
|
page.name = name;
|
|
page.uWrap = spine.TextureWrap.ClampToEdge;
|
|
page.vWrap = spine.TextureWrap.ClampToEdge;
|
|
page.texture = this.spine.assetManager.textureLoader(image);
|
|
page.texture.setWraps(page.uWrap, page.vWrap);
|
|
page.width = page.texture.getImage().width;
|
|
page.height = page.texture.getImage().height;
|
|
|
|
|
|
|
|
var region = new spine.TextureAtlasRegion();
|
|
region.page = page;
|
|
region.rotate = false;
|
|
region.width = page.width;
|
|
region.height = page.height;
|
|
region.x = 0;
|
|
region.y = 0;
|
|
region.u = region.x / page.width;
|
|
region.v = region.y / page.height;
|
|
if (region.rotate) {
|
|
region.u2 = (region.x + region.height) / page.width;
|
|
region.v2 = (region.y + region.width) / page.height;
|
|
}
|
|
else {
|
|
region.u2 = (region.x + region.width) / page.width;
|
|
region.v2 = (region.y + region.height) / page.height;
|
|
}
|
|
|
|
region.originalWidth = page.width;
|
|
region.originalHeight = page.height;
|
|
region.index = -1;
|
|
region.texture = page.texture;
|
|
region.renderObject = region;
|
|
|
|
return region;
|
|
};
|
|
|
|
AnimationPlayer.prototype.hasSpine = function (filename) {
|
|
return this.spine.assets[filename] != undefined;
|
|
};
|
|
|
|
AnimationPlayer.prototype.loadSpine = function (filename, skelType, onload, onerror) {
|
|
skelType = skelType == undefined ? 'skel' : skelType.toLowerCase();
|
|
var thisAnim = this;
|
|
var reader = {
|
|
name: filename,
|
|
filename: filename,
|
|
skelType: skelType,
|
|
onsuccess: onload,
|
|
onfailed: onerror,
|
|
loaded: 0,
|
|
errors: 0,
|
|
toLoad: 2,
|
|
onerror: function (path, msg) {
|
|
var _this = reader;
|
|
_this.toLoad--;
|
|
_this.errors++;
|
|
if (_this.toLoad == 0) {
|
|
console.error('loadSpine: [' + _this.filename + '] 加载失败.');
|
|
if (_this.onfailed) _this.onfailed();
|
|
}
|
|
},
|
|
onload: function (path, data) {
|
|
var _this = reader;
|
|
_this.toLoad--;
|
|
_this.loaded++;
|
|
if (_this.toLoad == 0) {
|
|
if (_this.errors > 0) {
|
|
console.error('loadSpine: [' + _this.filename + '] 加载失败.');
|
|
if (_this.onfailed) _this.onfailed();
|
|
} else {
|
|
thisAnim.spine.assets[_this.filename] = { name: _this.filename, skelType: _this.skelType };
|
|
if (_this.onsuccess) _this.onsuccess();
|
|
}
|
|
}
|
|
},
|
|
ontextLoad: function (path, data) {
|
|
var _this = reader;
|
|
var imageName = null;
|
|
var atlasReader = new spine.TextureAtlasReader(data);
|
|
var prefix = '';
|
|
var a = _this.name.lastIndexOf('/');
|
|
var b = _this.name.lastIndexOf('\\');
|
|
if (a != -1 || b != -1) {
|
|
if (a > b)
|
|
prefix = _this.name.substring(0, a + 1);
|
|
else
|
|
prefix = _this.name.substring(0, b + 1);
|
|
}
|
|
|
|
while (true) {
|
|
var line = atlasReader.readLine();
|
|
if (line == null) break;
|
|
line = line.trim();
|
|
|
|
if (line.length == 0) {
|
|
imageName = null;
|
|
} else if (!imageName) {
|
|
imageName = line;
|
|
_this.toLoad++;
|
|
thisAnim.spine.assetManager.loadTexture(prefix + imageName,
|
|
_this.onload, _this.onerror);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
_this.onload(path, data);
|
|
},
|
|
};
|
|
|
|
if (skelType == 'json') {
|
|
thisAnim.spine.assetManager.loadText(filename + '.json',
|
|
reader.onload, reader.onerror);
|
|
} else {
|
|
thisAnim.spine.assetManager.loadBinary(filename + '.skel',
|
|
reader.onload, reader.onerror);
|
|
}
|
|
|
|
thisAnim.spine.assetManager.loadText(filename + '.atlas',
|
|
reader.ontextLoad, reader.onerror);
|
|
};
|
|
|
|
AnimationPlayer.prototype.prepSpine = function (filename, autoLoad) {
|
|
var _this = this;
|
|
var spineAssets = _this.spine.assets;
|
|
if (!spineAssets[filename]) {
|
|
if (autoLoad) {
|
|
_this.loadSpine(filename, 'skel', function () {
|
|
_this.prepSpine(filename);
|
|
});
|
|
return 'loading';
|
|
}
|
|
return console.error('prepSpine: [' + filename + '] 骨骼没有加载');;
|
|
}
|
|
|
|
var skeleton;
|
|
var skeletons = _this.spine.skeletons;
|
|
for (var i = 0; i < skeletons.length; i++) {
|
|
skeleton = skeletons[i];
|
|
if (skeleton.name == filename && skeleton.completed) return skeleton;
|
|
}
|
|
|
|
var asset = spineAssets[filename];
|
|
var manager = _this.spine.assetManager;
|
|
var skelRawData = asset.skelRawData;
|
|
if (!skelRawData) {
|
|
var prefix = '';
|
|
var a = filename.lastIndexOf('/');
|
|
var b = filename.lastIndexOf('\\');
|
|
if (a != -1 || b != -1) {
|
|
if (a > b)
|
|
prefix = filename.substring(0, a + 1);
|
|
else
|
|
prefix = filename.substring(0, b + 1);
|
|
}
|
|
var atlas = new spine.TextureAtlas(manager.get(filename + '.atlas'), function (path) {
|
|
return manager.get(prefix + path);
|
|
});
|
|
|
|
var atlasLoader = new spine.AtlasAttachmentLoader(atlas);
|
|
if (asset.skelType.toLowerCase() == 'json') {
|
|
skelRawData = new spine.SkeletonJson(atlasLoader);
|
|
} else {
|
|
skelRawData = new spine.SkeletonBinary(atlasLoader);
|
|
}
|
|
|
|
spineAssets[filename].skelRawData = skelRawData;
|
|
spineAssets[filename].ready = true;
|
|
}
|
|
|
|
var data = skelRawData.readSkeletonData(manager.get(filename + '.' + asset.skelType));
|
|
skeleton = new spine.Skeleton(data);
|
|
|
|
skeleton.name = filename;
|
|
skeleton.completed = true;
|
|
skeleton.setSkinByName('default');
|
|
skeleton.setToSetupPose();
|
|
skeleton.updateWorldTransform();
|
|
skeleton.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
|
|
skeleton.state.addListener({
|
|
complete: function (track) {
|
|
var node = skeleton.node;
|
|
if (node) {
|
|
track.loop = (node.loop == undefined ? false : node.loop);
|
|
if (track.loop && node.loopCount > 0) {
|
|
node.loopCount--;
|
|
if (node.loopCount == 0) track.loop = false;
|
|
}
|
|
skeleton.completed = node.completed = !track.loop;
|
|
if (node.complete) node.complete();
|
|
} else {
|
|
skeleton.completed = !track.loop;
|
|
console.error('skeleton complete: 超出预期的错误');
|
|
}
|
|
}
|
|
});
|
|
skeleton.bounds = { offset: new spine.Vector2(), size: new spine.Vector2() };
|
|
skeleton.getBounds(skeleton.bounds.offset, skeleton.bounds.size, []);
|
|
skeleton.defaultAction = data.animations[0].name;
|
|
skeleton.node = undefined;
|
|
skeletons.push(skeleton);
|
|
return skeleton;
|
|
};
|
|
|
|
AnimationPlayer.prototype.playSpine = function (sprite, position) {
|
|
if (self.duicfg && !self.duicfg.gameAnimationEffect) return;
|
|
if (sprite == undefined) return console.error('playSpine: parameter undefined');
|
|
if (typeof sprite == 'string') sprite = { name: sprite };
|
|
if (!this.hasSpine(sprite.name)) return console.error('playSpine: [' + sprite.name + '] 骨骼没有加载');
|
|
|
|
var skeletons = this.spine.skeletons;
|
|
var skeleton;
|
|
|
|
if (!(sprite instanceof duilib.APNode && sprite.skeleton.completed)) {
|
|
for (var i = 0; i < skeletons.length; i++) {
|
|
skeleton = skeletons[i];
|
|
if (skeleton.name == sprite.name && skeleton.completed) break;
|
|
skeleton = null;
|
|
}; if (!skeleton) skeleton = this.prepSpine(sprite.name);
|
|
|
|
if (!(sprite instanceof duilib.APNode)) {
|
|
var param = sprite;
|
|
sprite = new duilib.APNode(sprite);
|
|
sprite.id = param.id == undefined ? this.BUILT_ID++ : param.id;
|
|
this.nodes.push(sprite);
|
|
}
|
|
|
|
sprite.skeleton = skeleton;
|
|
skeleton.node = sprite;
|
|
}
|
|
|
|
sprite.completed = false;
|
|
skeleton.completed = false;
|
|
|
|
if (position != undefined) {
|
|
sprite.x = position.x;
|
|
sprite.y = position.y;
|
|
sprite.height = position.height;
|
|
sprite.width = position.width;
|
|
sprite.scale = position.scale;
|
|
sprite.angle = position.angle;
|
|
sprite.referNode = position.parent;
|
|
sprite.referFollow = position.follow;
|
|
}
|
|
|
|
var entry = skeleton.state.setAnimation(0, sprite.action ? sprite.action : skeleton.defaultAction, sprite.loop);
|
|
entry.mixDuration = 0;
|
|
if (this.requestId == undefined) {
|
|
this.running = true;
|
|
if (!this.offscreen) this.canvas.style.visibility = 'visible';
|
|
this.requestId = requestAnimationFrame(this.render.bind(this));
|
|
}
|
|
|
|
sprite.referBounds = undefined;
|
|
return sprite;
|
|
};
|
|
|
|
AnimationPlayer.prototype.loopSpine = function (sprite, position) {
|
|
if (typeof sprite == 'string') {
|
|
sprite = {
|
|
name: sprite,
|
|
loop: true,
|
|
}
|
|
} else {
|
|
sprite.loop = true;
|
|
}
|
|
|
|
return this.playSpine(sprite, position);
|
|
};
|
|
|
|
AnimationPlayer.prototype.stopSpine = function (sprite) {
|
|
var nodes = this.nodes;
|
|
var id = sprite.id == undefined ? sprite : sprite.id;
|
|
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
sprite = nodes[i];
|
|
if (sprite.id == id) {
|
|
if (!sprite.completed) {
|
|
sprite.completed = true;
|
|
sprite.skeleton.state.setEmptyAnimation(0);
|
|
}
|
|
return sprite;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
AnimationPlayer.prototype.stopSpineAll = function () {
|
|
var sprite;
|
|
var nodes = this.nodes;
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
sprite = nodes[i];
|
|
if (!sprite.completed) {
|
|
sprite.completed = true;
|
|
sprite.skeleton.state.setEmptyAnimation(0);
|
|
}
|
|
}
|
|
};
|
|
|
|
AnimationPlayer.prototype.getSpineActions = function (filename) {
|
|
if (!this.hasSpine(filename)) return console.error('getSpineActions: [' + filename + '] 骨骼没有加载');;
|
|
|
|
var skeleton;
|
|
var skeletons = this.spine.skeletons;
|
|
for (var i = 0; i < skeletons.length; i++) {
|
|
skeleton = skeletons[i];
|
|
if (skeleton.name == filename) break;
|
|
skeleton = undefined;
|
|
}
|
|
|
|
if (skeleton == undefined) skeleton = this.prepSpine(filename);
|
|
var actions = skeleton.data.animations;
|
|
var result = new Array(actions.length);
|
|
for (var i = 0; i < actions.length; i++) result[i] = { name: actions[i].name, duration: actions[i].duration };
|
|
return result;
|
|
};
|
|
|
|
AnimationPlayer.prototype.getSpineBounds = function (filename) {
|
|
if (!this.hasSpine(filename)) return console.error('getSpineBounds: [' + filename + '] 骨骼没有加载');;
|
|
|
|
if (!this.resized) {
|
|
var dpr = 1;
|
|
if (this.dprAdaptive == true)
|
|
dpr = Math.max(window.devicePixelRatio * (window.documentZoom ? window.documentZoom : 1), 1);
|
|
|
|
canvas.elementHeight = canvas.clientHeight;
|
|
canvas.elementWidth = canvas.clientWidth;
|
|
canvas.height = canvas.elementHeight * dpr;
|
|
canvas.width = canvas.elementWidth * dpr;
|
|
}
|
|
|
|
var skeleton;
|
|
var skeletons = this.spine.skeletons;
|
|
for (var i = 0; i < skeletons.length; i++) {
|
|
skeleton = skeletons[i];
|
|
if (skeleton.name == filename) break;
|
|
skeleton = undefined;
|
|
}
|
|
|
|
if (skeleton == undefined) skeleton = this.prepSpine(filename);
|
|
return skeleton.bounds;
|
|
};
|
|
|
|
AnimationPlayer.prototype.render = function (timestamp) {
|
|
var canvas = this.canvas;
|
|
var offscreen = this.offscreen;
|
|
var dpr = 1;
|
|
if (this.dprAdaptive) {
|
|
if (offscreen)
|
|
dpr = this.dpr != undefined ? this.dpr : 1;
|
|
else
|
|
dpr = Math.max(window.devicePixelRatio * (window.documentZoom ? window.documentZoom : 1), 1);
|
|
}
|
|
var delta = timestamp - ((this.frameTime == undefined) ? timestamp : this.frameTime);
|
|
this.frameTime = timestamp;
|
|
|
|
var erase = true;
|
|
var resize = !this.resized || canvas.width == 0 || canvas.height == 0;
|
|
if (resize) {
|
|
this.resized = true;
|
|
if (!offscreen) {
|
|
canvas.width = dpr * canvas.clientWidth;
|
|
canvas.height = dpr * canvas.clientHeight;
|
|
erase = false;
|
|
} else {
|
|
if (this.width) {
|
|
canvas.width = dpr * this.width;
|
|
erase = false;
|
|
}
|
|
if (this.height) {
|
|
canvas.height = dpr * this.height;
|
|
erase = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
var ea = {
|
|
dpr: dpr,
|
|
delta: delta,
|
|
canvas: canvas,
|
|
frameTime: timestamp,
|
|
};
|
|
|
|
var nodes = this.nodes;
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
if (!nodes[i].completed) {
|
|
nodes[i].update(ea);
|
|
} else {
|
|
nodes.remove(nodes[i]); i--;
|
|
}
|
|
}
|
|
|
|
var gl = this.gl;
|
|
gl.viewport(0, 0, canvas.width, canvas.height);
|
|
if (erase) {
|
|
gl.clearColor(0, 0, 0, 0);
|
|
gl.clear(gl.COLOR_BUFFER_BIT);
|
|
}
|
|
|
|
if (nodes.length == 0) {
|
|
this.frameTime = void 0;
|
|
this.requestId = void 0;
|
|
this.running = false;
|
|
if (!offscreen) this.canvas.style.visibility = 'hidden';
|
|
return;
|
|
}
|
|
|
|
var sprite, state, skeleton;
|
|
var shader = this.spine.shader;
|
|
var batcher = this.spine.batcher;
|
|
var renderer = this.spine.skeletonRenderer;
|
|
|
|
gl.enable(gl.SCISSOR_TEST);
|
|
gl.scissor(0, 0, canvas.width, canvas.height);
|
|
|
|
if (this.bindShader == undefined) {
|
|
this.bindShader = shader;
|
|
shader.bind();
|
|
shader.setUniformi(spine.webgl.Shader.SAMPLER, 0);
|
|
}
|
|
|
|
var speed;
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
sprite = nodes[i];
|
|
if (sprite.renderClip != undefined) {
|
|
gl.clipping = sprite.renderClip;
|
|
gl.scissor(gl.clipping.x, gl.clipping.y, gl.clipping.width, gl.clipping.height);
|
|
}
|
|
|
|
skeleton = sprite.skeleton;
|
|
state = skeleton.state;
|
|
speed = sprite.speed == undefined ? 1 : sprite.speed;
|
|
skeleton.flipX = sprite.flipX;
|
|
skeleton.flipY = sprite.flipY
|
|
skeleton.opacity = (sprite.renderOpacity == undefined ? 1 : sprite.renderOpacity);
|
|
state.hideSlots = sprite.hideSlots;
|
|
state.update(delta / 1000 * speed);
|
|
state.apply(skeleton);
|
|
skeleton.updateWorldTransform();
|
|
|
|
shader.setUniform4x4f(spine.webgl.Shader.MVP_MATRIX, sprite.mvp.values);
|
|
batcher.begin(shader);
|
|
renderer.premultipliedAlpha = sprite.premultipliedAlpha;
|
|
renderer.outcropMask = this.outcropMask;
|
|
if (renderer.outcropMask) {
|
|
renderer.outcropX = sprite.renderX;
|
|
renderer.outcropY = sprite.renderY;
|
|
renderer.outcropScale = sprite.renderScale;
|
|
renderer.outcropAngle = sprite.renderAngle;
|
|
renderer.clipSlots = sprite.clipSlots;
|
|
}
|
|
|
|
renderer.hideSlots = sprite.hideSlots;
|
|
renderer.disableMask = sprite.disableMask;
|
|
renderer.draw(batcher, skeleton);
|
|
batcher.end();
|
|
|
|
if (gl.clipping) {
|
|
gl.clipping = undefined;
|
|
gl.scissor(0, 0, canvas.width, canvas.height);
|
|
}
|
|
}
|
|
|
|
gl.disable(gl.SCISSOR_TEST);
|
|
|
|
this.requestId = requestAnimationFrame(this.render.bind(this));
|
|
};
|
|
|
|
|
|
return AnimationPlayer;
|
|
})();
|
|
|
|
duilib.AnimationPlayerPool = (function () {
|
|
function AnimationPlayerPool(size, pathPrefix, thisName) {
|
|
if (!self.spine) return console.error('spine 未定义.');
|
|
|
|
this.name = thisName;
|
|
this.animations = new Array(size ? size : 1);
|
|
for (var i = 0; i < this.animations.length; i++) this.animations[i] = new duilib.AnimationPlayer(pathPrefix);
|
|
|
|
};
|
|
|
|
AnimationPlayerPool.prototype.loadSpine = function (filename, skelType, onload, onerror) {
|
|
var thisAnim = this;
|
|
thisAnim.animations[0].loadSpine(filename, skelType, function () {
|
|
var ap;
|
|
var aps = thisAnim.animations;
|
|
|
|
for (var i = 1; i < aps.length; i++) {
|
|
ap = aps[i];
|
|
if (window.requestIdleCallback) {
|
|
requestIdleCallback(ap.prepSpine.bind(ap, this.name, true), { timeout: 200 });
|
|
} else {
|
|
setTimeout(function (ap, name) {
|
|
ap.prepSpine(name, true);
|
|
}, 50, ap, this.name);
|
|
}
|
|
}
|
|
|
|
if (onload) onload();
|
|
}, onerror);
|
|
};
|
|
|
|
AnimationPlayerPool.prototype.playSpineTo = function (element, animation, position) {
|
|
var animations = this.animations;
|
|
if (position && position.parent) {
|
|
position.parent = undefined;
|
|
console.log('playSpineTo: position.parent 参数已忽略');
|
|
}
|
|
if (element._ap && element._ap.canvas.parentNode == element) {
|
|
element._ap.playSpine(animation, position);
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < animations.length; i++) {
|
|
if (!animations[i].running) {
|
|
if (animations[i].canvas.parentNode != element) {
|
|
element._ap = animations[i];
|
|
element.appendChild(animations[i].canvas);
|
|
}
|
|
animations[i].playSpine(animation, position);
|
|
return;
|
|
}
|
|
}
|
|
|
|
console.error('spine:' + (this.name != null ? this.name : '' + '可用动画播放组件不足'));
|
|
|
|
};
|
|
|
|
return AnimationPlayerPool;
|
|
})();
|
|
|
|
duilib.BUILT_ID = 0;
|
|
duilib.DynamicWorkers = new Array(2);
|
|
duilib.DynamicPlayer = (function () {
|
|
function DynamicPlayer(pathPrefix) {
|
|
this.id = duilib.BUILT_ID++;
|
|
this.dpr = 1;
|
|
this.width = 120;
|
|
this.height = 180;
|
|
this.dprAdaptive = false;
|
|
this.BUILT_ID = 0;
|
|
|
|
var offscreen = self.OffscreenCanvas != undefined;
|
|
if (offscreen) {
|
|
offscreen = false;
|
|
var workers = duilib.DynamicWorkers;
|
|
for (var i = 0; i < workers.length; i++) {
|
|
if (workers[i] == undefined) {
|
|
workers[i] = new Worker(decadeUIPath + 'dynamicWorker.js');
|
|
workers[i].capacity = 0;
|
|
} else if (workers[i].capacity >= 4) {
|
|
continue;
|
|
}
|
|
|
|
this.renderer = workers[i];
|
|
this.canvas = document.createElement('canvas');
|
|
this.canvas.className = 'animation-player';
|
|
duilib.observeSize(this.canvas, duilib.throttle(function (newSize) {
|
|
this.height = Math.round(newSize.height);
|
|
this.width = Math.round(newSize.width);
|
|
this.update();
|
|
}, 100, this));
|
|
|
|
var canvas = this.canvas.transferControlToOffscreen();
|
|
workers[i].postMessage({
|
|
message: 'CREATE',
|
|
id: this.id,
|
|
canvas: canvas,
|
|
pathPrefix: pathPrefix,
|
|
}, [canvas]);
|
|
|
|
workers[i].capacity++;
|
|
this.offscreen = offscreen = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!offscreen) {
|
|
var renderer = new duilib.AnimationPlayer(decadeUIPath + pathPrefix);
|
|
this.canvas = renderer.canvas;
|
|
this.renderer = renderer;
|
|
dui.bodySensor.addListener(duilib.throttle(function () {
|
|
this.renderer.resized = false;
|
|
}, 100, this), true);
|
|
}
|
|
}
|
|
|
|
DynamicPlayer.prototype.play = function (sprite) {
|
|
var sprite = (typeof sprite == 'string') ? { name: sprite } : sprite;
|
|
sprite.id = this.BUILT_ID++;
|
|
sprite.loop = true;
|
|
|
|
if (this.offscreen) {
|
|
if (!this.initialized) {
|
|
this.initialized = true;
|
|
this.dpr = Math.max(window.devicePixelRatio * (window.documentZoom ? window.documentZoom : 1), 1);
|
|
this.height = this.canvas.clientHeight;
|
|
this.width = this.canvas.clientWidth;
|
|
}
|
|
|
|
if (typeof sprite.oncomplete == 'function')
|
|
sprite.oncomplete = sprite.oncomplete.toString();
|
|
|
|
this.renderer.postMessage({
|
|
message: 'PLAY',
|
|
id: this.id,
|
|
dpr: this.dpr,
|
|
dprAdaptive: this.dprAdaptive,
|
|
outcropMask: this.outcropMask,
|
|
useMipMaps: this.useMipMaps,
|
|
width: this.width,
|
|
height: this.height,
|
|
sprite: sprite,
|
|
});
|
|
} else {
|
|
var dynamic = this.renderer;
|
|
dynamic.useMipMaps = this.useMipMaps;
|
|
dynamic.dprAdaptive = this.dprAdaptive;
|
|
dynamic.outcropMask = this.outcropMask;
|
|
var run = function () {
|
|
var t = dynamic.playSpine(sprite);
|
|
t.opacity = 0;
|
|
t.fadeTo(1, 600);
|
|
};
|
|
|
|
if (dynamic.hasSpine(sprite.name)) {
|
|
run();
|
|
} else {
|
|
dynamic.loadSpine(sprite.name, 'skel', run);
|
|
}
|
|
}
|
|
|
|
return sprite;
|
|
};
|
|
|
|
DynamicPlayer.prototype.stop = function (sprite) {
|
|
if (this.offscreen) {
|
|
this.renderer.postMessage({
|
|
message: 'STOP',
|
|
id: this.id,
|
|
sprite: sprite,
|
|
});
|
|
return;
|
|
}
|
|
|
|
this.renderer.stopSpine(sprite);
|
|
};
|
|
|
|
DynamicPlayer.prototype.stopAll = function () {
|
|
if (this.offscreen) {
|
|
this.renderer.postMessage({
|
|
message: 'STOPALL',
|
|
id: this.id
|
|
});
|
|
return;
|
|
}
|
|
|
|
this.renderer.stopSpineAll();
|
|
};
|
|
|
|
DynamicPlayer.prototype.update = function (force) {
|
|
if (!this.offscreen) {
|
|
this.renderer.resized = false;
|
|
this.renderer.useMipMaps = this.useMipMaps;
|
|
this.renderer.dprAdaptive = this.dprAdaptive;
|
|
this.renderer.outcropMask = this.outcropMask;
|
|
return;
|
|
}
|
|
|
|
this.dpr = Math.max(window.devicePixelRatio * (window.documentZoom ? window.documentZoom : 1), 1);
|
|
if (force === false)
|
|
return;
|
|
|
|
this.renderer.postMessage({
|
|
message: 'UPDATE',
|
|
id: this.id,
|
|
dpr: this.dpr,
|
|
dprAdaptive: this.dprAdaptive,
|
|
outcropMask: this.outcropMask,
|
|
useMipMaps: this.useMipMaps,
|
|
width: this.width,
|
|
height: this.height,
|
|
});
|
|
}
|
|
|
|
return DynamicPlayer;
|
|
})();
|
|
|
|
})(duilib || (duilib = {}));
|
|
|
|
var decadeModule;
|
|
if (decadeModule) decadeModule.import(function (lib, game, ui, get, ai, _status) {
|
|
decadeUI.animation = (function () {
|
|
var animation = new decadeUI.AnimationPlayer(decadeUIPath + 'assets/animation/', document.body, 'decadeUI-canvas');
|
|
decadeUI.bodySensor.addListener(function () { animation.resized = false; }, true);
|
|
animation.cap = new decadeUI.AnimationPlayerPool(4, decadeUIPath + 'assets/animation/', 'decadeUI.animation');
|
|
|
|
var fileList = [
|
|
{ name: 'effect_youxikaishi' },
|
|
{ name: 'effect_baguazhen' },
|
|
{ name: 'effect_baiyinshizi' },
|
|
{ name: 'effect_cixiongshuanggujian' },
|
|
{ name: 'effect_fangtianhuaji' },
|
|
{ name: 'effect_guanshifu' },
|
|
{ name: 'effect_gudingdao' },
|
|
{ name: 'effect_hanbingjian' },
|
|
{ name: 'effect_qilingong' },
|
|
{ name: 'effect_qinggangjian' },
|
|
{ name: 'effect_qinglongyanyuedao' },
|
|
{ name: 'effect_renwangdun' },
|
|
{ name: 'effect_shoujidonghua' },
|
|
{ name: 'effect_tengjiafangyu' },
|
|
{ name: 'effect_tengjiaranshao' },
|
|
{ name: 'effect_zhangbashemao' },
|
|
{ name: 'effect_zhiliao' },
|
|
{ name: 'effect_zhugeliannu' },
|
|
{ name: 'effect_zhuqueyushan' },
|
|
{ name: 'effect_jinhe' },
|
|
{ name: 'effect_numa' },
|
|
{ name: 'effect_nvzhuang' },
|
|
{ name: 'effect_wufengjian' },
|
|
{ name: 'effect_yajiaoqiang' },
|
|
{ name: 'effect_yinfengjia' },
|
|
{ name: 'effect_zheji' },
|
|
{ name: 'effect_jisha1' },
|
|
{ name: 'effect_zhenwang' },
|
|
{ name: 'effect_lebusishu' },
|
|
{ name: 'effect_bingliangcunduan' },
|
|
{ name: 'effect_nanmanruqin' },
|
|
{ name: 'effect_taoyuanjieyi' },
|
|
{ name: 'effect_shandian' },
|
|
{ name: 'effect_wanjianqifa_full' },
|
|
{ name: 'effect_xianding', fileType: 'json' },
|
|
{ name: 'effect_caochuanjiejian', follow: true },
|
|
{ name: 'effect_guohechaiqiao', follow: true },
|
|
{ name: 'effect_leisha', follow: true },
|
|
{ name: 'effect_heisha', follow: true },
|
|
{ name: 'effect_huosha', follow: true },
|
|
{ name: 'effect_hongsha', follow: true },
|
|
{ name: 'effect_huogong', follow: true },
|
|
{ name: 'effect_panding', follow: true },
|
|
{ name: 'effect_shan', follow: true },
|
|
{ name: 'effect_tao', follow: true },
|
|
{ name: 'effect_tiesuolianhuan', follow: true },
|
|
{ name: 'effect_jiu', follow: true },
|
|
{ name: 'effect_shunshouqianyang', follow: true },
|
|
{ name: 'effect_shushangkaihua', follow: true },
|
|
{ name: 'effect_wanjianqifa', follow: true },
|
|
{ name: 'effect_wuzhongshengyou', follow: true },
|
|
{ name: 'effect_wuxiekeji', follow: true },
|
|
{ name: 'effect_wugufengdeng', follow: true },
|
|
{ name: 'effect_yuanjiaojingong', follow: true },
|
|
{ name: 'effect_zhijizhibi', follow: true },
|
|
{ name: 'effect_zhulutianxia', follow: true },
|
|
];
|
|
|
|
var fileNameList = fileList.concat();
|
|
|
|
var read = function () {
|
|
if (fileNameList.length) {
|
|
var file = fileNameList.shift();
|
|
if (file.follow) {
|
|
// 这个是专门播放追踪卡牌的动画，调用方式 decadeUI.animation.cap.playSpineTo(element, animation, position);
|
|
// 建议非追踪对象的特效不要滥用，因为每次导入1个骨骼会生成4个预制骨骼，资源占用较多
|
|
animation.cap.loadSpine(file.name, file.fileType, function () {
|
|
read();
|
|
});
|
|
} else {
|
|
// 这个是专门播放全屏位置的动画
|
|
animation.loadSpine(file.name, file.fileType, function () {
|
|
read();
|
|
animation.prepSpine(this.name);
|
|
});
|
|
}
|
|
}
|
|
}; read(); read();
|
|
|
|
var skillAnimation = (function () {
|
|
var defines = {
|
|
skill: {
|
|
bagua_skill: { skill: 'bagua_skill', name: 'effect_baguazhen', scale: 0.6 },
|
|
baiyin_skill: { skill: 'baiyin_skill', name: 'effect_baiyinshizi', scale: 0.5 },
|
|
bazhen_bagua: { skill: 'bazhen_bagua', name: 'effect_baguazhen', scale: 0.6 },
|
|
cixiong_skill: { skill: 'cixiong_skill', name: 'effect_cixiongshuanggujian', scale: 0.5 },
|
|
fangtian_skill: { skill: 'fangtian_skill', name: 'effect_fangtianhuaji', scale: 0.7 },
|
|
guanshi_skill: { skill: 'guanshi_skill', name: 'effect_guanshifu', scale: 0.7 },
|
|
guding_skill: { skill: 'guding_skill', name: 'effect_gudingdao', scale: 0.6, x: [0, 0.4], y: [1, 0.25] },
|
|
hanbing_skill: { skill: 'hanbing_skill', name: 'effect_hanbingjian', scale: 0.5 },
|
|
linglong_bagua: { skill: 'linglong_bagua', name: 'effect_baguazhen', scale: 0.5 },
|
|
qilin_skill: { skill: 'qilin_skill', name: 'effect_qilingong', scale: 0.5 },
|
|
qinggang_skill: { skill: 'qinggang_skill', name: 'effect_qinggangjian', scale: 0.7 },
|
|
qinglong_skill: { skill: 'qinglong_skill', name: 'effect_qinglongyanyuedao', scale: 0.6 },
|
|
renwang_skill: { skill: 'renwang_skill', name: 'effect_renwangdun', scale: 0.5 },
|
|
tengjia1: { skill: 'tengjia1', name: 'effect_tengjiafangyu', scale: 0.6 },
|
|
tengjia2: { skill: 'tengjia2', name: 'effect_tengjiaranshao', scale: 0.6 },
|
|
tengjia3: { skill: 'tengjia3', name: 'effect_tengjiafangyu', scale: 0.6 },
|
|
zhangba_skill: { skill: 'zhangba_skill', name: 'effect_zhangbashemao', scale: 0.7 },
|
|
zhuge_skill: { skill: 'zhuge_skill', name: 'effect_zhugeliannu', scale: 0.5 },
|
|
zhuque_skill: { skill: 'zhuque_skill', name: 'effect_zhuqueyushan', scale: 0.6 },
|
|
jinhe_lose: { skill: 'jinhe_lose', name: 'effect_jinhe', scale: 0.4 },
|
|
numa: { skill: 'numa', name: 'effect_numa', scale: 0.4 },
|
|
nvzhuang: { skill: 'nvzhuang', name: 'effect_nvzhuang', scale: 0.5 },
|
|
wufengjian_skill: { skill: 'wufengjian_skill', name: 'effect_wufengjian', scale: 0.4 },
|
|
yajiaoqiang_skill: { skill: 'yajiaoqiang_skill', name: 'effect_yajiaoqiang', scale: 0.5 },
|
|
yinfengjia_skill: { skill: 'yinfengjia_skill', name: 'effect_yinfengjia', scale: 0.5 },
|
|
zheji: { skill: 'zheji', name: 'effect_zheji', scale: 0.35 },
|
|
lebu: { skill: 'lebu', name: 'effect_lebusishu', scale: 0.7 },
|
|
bingliang: { skill: 'bingliang', name: 'effect_bingliangcunduan', scale: 0.7 },
|
|
shandian: { skill: 'shandian', name: 'effect_shandian', scale: 0.7 },
|
|
},
|
|
card: {
|
|
nanman: { card: 'nanman', name: 'effect_nanmanruqin', scale: 0.6, y: [0, 0.4] },
|
|
wanjian: { card: 'wanjian', name: 'effect_wanjianqifa_full', scale: 1.5 },
|
|
taoyuan: { card: 'taoyuan', name: 'effect_taoyuanjieyi' },
|
|
}
|
|
}
|
|
|
|
var cardAnimate = function (card) {
|
|
var anim = defines.card[card.name];
|
|
if (!anim) return console.error('cardAnimate:' + card.name);
|
|
animation.playSpine(anim.name, { x: anim.x, y: anim.y, scale: anim.scale });
|
|
};
|
|
|
|
for (var key in defines.card) {
|
|
lib.animate.card[defines.card[key].card] = cardAnimate;
|
|
}
|
|
|
|
var skillAnimate = function (name) {
|
|
var anim = defines.skill[name];
|
|
if (!anim) return console.error('skillAnimate:' + name);
|
|
animation.playSpine(anim.name, { x: anim.x, y: anim.y, scale: anim.scale, parent: this });
|
|
};
|
|
|
|
for (var key in defines.skill) {
|
|
lib.animate.skill[defines.skill[key].skill] = skillAnimate;
|
|
}
|
|
|
|
var trigger = {
|
|
card: {
|
|
nvzhuang: {
|
|
onEquip: function () {
|
|
if (player.sex == 'male' && player.countCards('he', function (cardx) { return cardx != card; })) {
|
|
lib.animate.skill['nvzhuang'].call(player, 'nvzhuang');
|
|
player.chooseToDiscard(true, function (card) {
|
|
return card != _status.event.card;
|
|
}, 'he').set('card', card);
|
|
}
|
|
},
|
|
onLose: function () {
|
|
if (player.sex != 'male') return;
|
|
var next = game.createEvent('nvzhuang_lose');
|
|
event.next.remove(next);
|
|
var evt = event.getParent();
|
|
if (evt.getlx === false) evt = evt.getParent();
|
|
evt.after.push(next);
|
|
next.player = player;
|
|
next.setContent(function () {
|
|
if (player.countCards('he')) {
|
|
lib.animate.skill['nvzhuang'].call(player, 'nvzhuang');
|
|
player.chooseToDiscard(true, 'he');
|
|
}
|
|
});
|
|
}
|
|
},
|
|
zheji: {
|
|
onEquip: function () {
|
|
lib.animate.skill['zheji'].call(player, 'zheji');
|
|
}
|
|
},
|
|
numa: {
|
|
onEquip: function () {
|
|
lib.animate.skill['numa'].call(player, 'numa');
|
|
}
|
|
},
|
|
lebu: {
|
|
effect: function () {
|
|
if (result.bool == false) {
|
|
lib.animate.skill['lebu'].call(player, 'lebu');
|
|
player.skip('phaseUse');
|
|
}
|
|
}
|
|
},
|
|
bingliang: {
|
|
effect: function () {
|
|
if (result.bool == false) {
|
|
if (get.is.changban()) {
|
|
player.addTempSkill('bingliang_changban');
|
|
} else {
|
|
lib.animate.skill['bingliang'].call(player, 'bingliang');
|
|
player.skip('phaseDraw');
|
|
}
|
|
}
|
|
}
|
|
},
|
|
shandian: {
|
|
effect: function () {
|
|
if (result.bool == false) {
|
|
lib.animate.skill['shandian'].call(player, 'shandian');
|
|
player.damage(3, 'thunder', 'nosource');
|
|
} else {
|
|
player.addJudgeNext(card);
|
|
}
|
|
}
|
|
},
|
|
},
|
|
};
|
|
|
|
|
|
for (var j in trigger.card) {
|
|
if (lib.card[j]) {
|
|
for (var k in trigger.card[j]) {
|
|
lib.card[j][k] = trigger.card[j][k];
|
|
}
|
|
}
|
|
}
|
|
})();
|
|
|
|
return animation;
|
|
})();
|
|
|
|
decadeUI.backgroundAnimation = (function () {
|
|
var animation = new decadeUI.AnimationPlayer(decadeUIPath + 'assets/dynamic/', document.body, 'decadeUI-canvas-background');
|
|
decadeUI.bodySensor.addListener(function () { animation.resized = false; }, true);
|
|
|
|
animation.dprAdaptive = true;
|
|
animation.definedAssets = {
|
|
skin_xiaosha: {
|
|
default: {
|
|
name: 'skin_xiaosha_default',
|
|
x: [0, 0.7],
|
|
y: [0, 0.3],
|
|
height: [0, 0.2],
|
|
},
|
|
},
|
|
skin_daqiao: {
|
|
战场绝版: {
|
|
name: 'skin_daqiao_ZhanChang',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
清萧清丽: {
|
|
name: 'skin_daqiao_QingXiaoQingLi',
|
|
x: [0, 0.5],
|
|
y: [0, 0.33],
|
|
height: [0, 0.8],
|
|
},
|
|
衣垂绿川: {
|
|
name: 'skin_daqiao_YiChuiLvChuan',
|
|
action: 'DaiJi',
|
|
x: [0, 0.5],
|
|
y: [-100, 0.5],
|
|
height: [0, 1.2],
|
|
disableMask: true,
|
|
}
|
|
},
|
|
skin_caojie: {
|
|
凤历迎春: {
|
|
name: 'skin_caojie_FengLiYingChun',
|
|
y: [75, 0.3],
|
|
height: [0, 1.5],
|
|
},
|
|
战场绝版: {
|
|
name: 'skin_caojie_ZhanChang',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_caoying: {
|
|
巾帼花舞: {
|
|
name: 'fullskin_caoying_JinGuoHuaWu',
|
|
x: [0, 0.4],
|
|
y: [75, 0.3],
|
|
height: [0, 0.9],
|
|
},
|
|
},
|
|
skin_baosanniang: {
|
|
舞剑铸缘: {
|
|
name: 'skin_baosanniang_WuJianZhuYuan',
|
|
action: 'DaiJi',
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
漫花剑俏: {
|
|
name: 'skin_baosanniang_ManHuaJianQiao',
|
|
// x: [0, 0.7],
|
|
y: [50, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_caiwenji: {
|
|
才颜双绝: {
|
|
name: 'skin_caiwenji_CaiYanShuangJue',
|
|
y: [-80, 0.5],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_daqiaoxiaoqiao: {
|
|
战场绝版: {
|
|
name: 'skin_daqiaoxiaoqiao_ZhanChang',
|
|
//x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_diaochan: {
|
|
玉婵仙子: {
|
|
name: 'skin_diaochan_YuChanXianZi',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
战场绝版: {
|
|
name: 'skin_diaochan_ZhanChang',
|
|
y: [75, 0.3],
|
|
height: [0, 1],
|
|
},
|
|
},
|
|
skin_dongbai: {
|
|
娇俏伶俐: {
|
|
name: 'skin_dongbai_JiaoQiaoLingLi',
|
|
x: [0, 0.5],
|
|
y: [0, 0.33],
|
|
height: [0, 0.96],
|
|
},
|
|
},
|
|
skin_fanyufeng: {
|
|
斟酒入情: {
|
|
name: 'skin_fanyufeng_ZhenJiuRuQing',
|
|
x: [0, 0.5],
|
|
y: [0, 0.28],
|
|
height: [0, 1],
|
|
},
|
|
},
|
|
skin_fuhuanghou: {
|
|
万福千灯: {
|
|
name: 'skin_fuhuanghou_WanFuQianDeng',
|
|
//x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_guozhao: {
|
|
雍容尊雅: {
|
|
name: 'skin_guozhao_YongRongZunYa',
|
|
x: [0, 0.5],
|
|
y: [0, 0.33],
|
|
height: [0, 0.7],
|
|
},
|
|
},
|
|
skin_hetaihou: {
|
|
鸩毒除患: {
|
|
name: 'skin_hetaihou_ZhenDuChuHuan',
|
|
y: [0, 0.33],
|
|
height: [0, 0.65],
|
|
},
|
|
蛇蝎为心: {
|
|
name: 'skin_hetaihou_SheXieWeiXin',
|
|
action: 'DaiJi',
|
|
y: [5, 0.33],
|
|
height: [0, 0.76],
|
|
hideSlots: 'jiubei',
|
|
},
|
|
耀紫迷幻: {
|
|
name: 'skin_hetaihou_YaoZiMiHuan',
|
|
y: [5, 0.33],
|
|
height: [0, 0.76],
|
|
},
|
|
},
|
|
skin_huaman: {
|
|
经典形象: {
|
|
name: 'skin_huaman_default',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
花俏蛮娇: {
|
|
name: 'skin_huaman_HuaQiaoManJiao',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
}
|
|
},
|
|
skin_lukang: {
|
|
毁堰破晋: {
|
|
name: 'skin_lukang_HuiYanPoJin',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_luxun: {
|
|
谋定天下: {
|
|
name: 'skin_luxun_MouDingTianXia',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_luxunlvmeng: {
|
|
清雨踏春: {
|
|
name: 'skin_luxunlvmeng_QingYuTaChun',
|
|
// x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_mayunlu: {
|
|
战场绝版: {
|
|
name: 'skin_mayunlu_ZhanChang',
|
|
x: [0, 0.6],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_simashi: {
|
|
桀骜睥睨: {
|
|
name: 'skin_simashi_JieAoPiNi',
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
}
|
|
},
|
|
skin_sundengzhoufei: {
|
|
鹊星夕情: {
|
|
name: 'skin_sundengzhoufei_QueXingXiQing',
|
|
// x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_sunluban: {
|
|
宵靥谜君: {
|
|
name: 'skin_sunluban_XiaoYeMiJun',
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_sunluyu: {
|
|
娇俏伶俐: {
|
|
name: 'skin_sunluyu_JiaoQiaoLingLi',
|
|
y: [0, 0.3],
|
|
height: [0, 0.9],
|
|
},
|
|
},
|
|
skin_shuxiangxiang: {
|
|
花好月圆: {
|
|
name: 'skin_shuxiangxiang_HuaHaoYueYuan',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
花曳心牵: {
|
|
name: 'skin_shuxiangxiang_HuaYeXinQian',
|
|
x: [0, 0.5],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_wangrong: {
|
|
云裳花容: {
|
|
name: 'skin_wangrong_YunShangHuaRong',
|
|
y: [75, 0.3],
|
|
height: [0, 1],
|
|
},
|
|
},
|
|
skin_wangyi: {
|
|
绝色异彩: {
|
|
name: 'skin_wangyi_JueSeYiCai',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
战场绝版: {
|
|
name: 'skin_wangyi_ZhanChang',
|
|
x: [0, 0.7],
|
|
y: [75, 0.35],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_wolongzhuge: {
|
|
隆中陇亩: {
|
|
name: 'skin_wolongzhuge_LongZhongLongMu',
|
|
// x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_wuxian: {
|
|
锦运福绵: {
|
|
name: 'skin_wuxian_JinYunFuMian',
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
金玉满堂: {
|
|
name: 'fullskin_wuxian_JinYuManTang',
|
|
y: [0, 0.35],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_xiahoushi: {
|
|
端华夏莲: {
|
|
name: 'skin_xiahoushi_DuanHuaXiaLian',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
战场绝版: {
|
|
name: 'skin_xiahoushi_ZhanChang',
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_xiaoqiao: {
|
|
花好月圆: {
|
|
name: 'skin_xiaoqiao_HuaHaoYueYuan',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
采莲江南: {
|
|
name: 'skin_xiaoqiao_CaiLianJiangNan',
|
|
action: 'DaiJi',
|
|
x: [0, 0.5],
|
|
y: [-100, 0.5],
|
|
height: [0, 1.2],
|
|
}
|
|
},
|
|
skin_xinxianying: {
|
|
英装素果: {
|
|
name: 'skin_xinxianying_YingZhuangSuGuo',
|
|
//x: [0, 0.7],
|
|
y: [75, 0.26],
|
|
//height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_xushi: {
|
|
拈花思君: {
|
|
name: 'skin_xushi_NianHuaSiJun',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
为夫弑敌: {
|
|
name: 'skin_xushi_WeiFuShiDi',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhangchangpu: {
|
|
钟桂香蒲: {
|
|
name: 'skin_zhangchangpu_ZhongGuiXiangPu',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhangchunhua: {
|
|
花好月圆: {
|
|
name: 'skin_zhangchunhua_HuaHaoYueYuan',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
战场绝版: {
|
|
name: 'skin_zhangchunhua_ZhanChang',
|
|
//x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhangqiying: {
|
|
岁稔年丰: {
|
|
name: 'skin_zhangqiying_SuiRenNianFeng',
|
|
y: [0, 0.33],
|
|
height: [0, 0.8],
|
|
},
|
|
逐鹿天下: {
|
|
name: 'skin_zhangqiying_ZhuLuTianXia',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 1],
|
|
},
|
|
},
|
|
skin_zhangxingcai: {
|
|
凯旋星花: {
|
|
name: 'skin_zhangxingcai_KaiXuanXingHua',
|
|
x: [0, 0.45],
|
|
y: [0, 0.33],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhenji: {
|
|
才颜双绝: {
|
|
name: 'skin_zhenji_CaiYanShuangJue',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
洛神御水: {
|
|
name: 'skin_zhenji_LuoShenYuShui',
|
|
x: [0, 0.6],
|
|
y: [75, 0.3],
|
|
//height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhoufei: {
|
|
晴空暖鸢: {
|
|
name: 'skin_zhoufei_QingKongNuanYuan',
|
|
x: [0, 0.5],
|
|
y: [0, 0.33],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhugeguo: {
|
|
兰荷艾莲: {
|
|
name: 'skin_zhugeguo_LanHeAiLian',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
仙池起舞: {
|
|
name: 'skin_zhugeguo_XianChiQiWU',
|
|
action: 'DaiJi',
|
|
x: [0, 0.48],
|
|
y: [0, 0.35],
|
|
height: [0, 1.5],
|
|
},
|
|
英装素果: {
|
|
name: 'skin_zhugeguo_YingZhuangSuGuo',
|
|
//x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
//height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhugeliang: {
|
|
空城退敌: {
|
|
name: 'skin_zhugeliang_KongChengTuiDi',
|
|
x: [0, 0.7],
|
|
y: [75, 0.3],
|
|
height: [0, 0.8],
|
|
},
|
|
},
|
|
skin_zhouyi: {
|
|
剑舞浏漓: {
|
|
name: 'fullskin_zhouyi_JianWuLiuLi',
|
|
y: [0, 0.5],
|
|
height: [0, 1.2],
|
|
},
|
|
},
|
|
|
|
};
|
|
|
|
animation.stop = animation.stopSpineAll;
|
|
animation.play = function (name, skin) {
|
|
var definedAssets = this.definedAssets;
|
|
if (definedAssets[name] == void 0 || definedAssets[name][skin] == void 0)
|
|
return console.log('没有预定义[asset:' + name + ', skin:' + skin + ']的动态背景.');
|
|
|
|
if (this.current && this.current.name == name)
|
|
return;
|
|
|
|
this.stopSpineAll();
|
|
var playAsset = definedAssets[name][skin];
|
|
if (!this.hasSpine(playAsset.name)) {
|
|
var _this = this;
|
|
_this.loadSpine(playAsset.name, 'skel', function () {
|
|
if (_this.current && _this.current.name == playAsset.name) return;
|
|
_this.current = _this.loopSpine(playAsset);
|
|
});
|
|
} else {
|
|
this.current = this.loopSpine(playAsset);
|
|
}
|
|
};
|
|
|
|
|
|
animation.check();
|
|
var background = duicfg.dynamicBackground
|
|
if (background != void 0 && background != 'off') {
|
|
var name = background.split('_');
|
|
var skin = name.splice(name.length - 1, 1)[0];
|
|
animation.play(name.join('_'), skin);
|
|
}
|
|
|
|
return animation;
|
|
})();
|
|
|
|
// 下面是我自用的，可能会删掉
|
|
window.dcdAnim = decadeUI.animation;
|
|
window.dcdBackAnim = decadeUI.backgroundAnimation;
|
|
window.game = game;
|
|
window.get = get;
|
|
window.ui = ui;
|
|
window._status = _status;
|
|
});
|