// ============================================================
//  SpineMgr —— Spine 动画管理器（独立文件）
//  集成到 gameabc Canvas 2D 绘制循环，零侵入 gamemain.js
//  在 index.html 中置于 gameabc.min.js 之后、gamemain.js 之前加载
// ============================================================
(function(){

// gameabc 的全局 logmessage 默认走 mode 0，是空操作（见 gameabc.min.js 的实现），
// 诊断日志必须直接走 console 才能在浏览器与真机 WebView 里看到。
function spineLog(msg) {
	if (typeof console !== "undefined" && console.log) {
		console.log(msg);
	}
}
function spineWarn(msg) {
	if (typeof console !== "undefined" && console.warn) {
		console.warn(msg);
	}
}

var SpineMgr = {

	// --- 内部状态 ---
	_entries: {},          // {id: EntryObject}
	_assetManager: null,
	_backend: null,        // 渲染后端（SpineBackendWebGL / SpineBackendCanvas）
	_lastTime: 0,          // 上一帧时间戳(ms)
	_inited: false,
	_loadedPaths: {},      // 已请求加载的资源路径，避免重复请求
	_pendingCmds: {},      // {id: [{method, args}]} 等待实例就绪后执行的命令队列
	_scaleMap: {},         // {spineId: scale} 主流 SkeletonJson.scale 方案，_autoLoad 时注入
	_skelDataCache: {},    // {"file.json_scale1": SkeletonData} 同文件共享解析结果，避免重复 readSkeletonData

	// 默认资源根路径（可通过 init 覆盖）
	_basePath: "assets/spine/",

	// ----------------------------------------------------------
	//  init(basePath)  手动初始化（可选）
	//  如不调用，load 时会自动以默认路径 "assets/spine/" 初始化
	// ----------------------------------------------------------
	init: function(basePath) {
		if (!window.spine) {
			spineWarn("[SpineMgr] spine 运行时未加载，请检查 index.html 的探测脚本");
			return;
		}
		this._backend = this._selectBackend();
		if (!this._backend) {
			spineWarn("[SpineMgr] 无可用渲染后端");
			return;
		}
		spineLog("[SpineMgr] 渲染后端: " + this._backend.name);
		this._basePath = basePath || this._basePath;
		// 挂接 context lost 恢复回调（仅 WebGL 后端有此机制）
		var self = this;
		if (this._backend.name === "webgl") {
			this._backend._onContextRestored = function() {
				self._rebuildAfterContextRestored();
			};
		}
		// 后端初始化失败必须显式记录并让 _inited 保持 false，但不能让异常向上抛：
		// init 由文件末尾的预加载块经 _ensureInit() 调用，异常会中断整个 IIFE，
		// 导致后面的 gameenddraw 拦截根本不安装 —— Spine 从此永不绘制且无迹可循。
		// _inited 保持 false 时，各 API 走既有的 if (!this._inited) return 静默路径。
		try {
			this._assetManager = this._backend.createAssetManager(this._basePath);
		} catch (err) {
			spineWarn("[SpineMgr] 后端初始化失败: " + err.message);
			this._backend = null;
			return;
		}
		this._lastTime = Date.now();
		this._inited = true;
	},

	// (内部) 选定渲染后端。index.html 的探测脚本已决定加载哪套 spine 运行时，
	// 此处按运行时实际提供的能力对应上后端实现。
	_selectBackend: function() {
		if (window.SpineBackendWebGL && SpineBackendWebGL.isAvailable()) {
			return SpineBackendWebGL;
		}
		if (window.SpineBackendCanvas && SpineBackendCanvas.isAvailable()) {
			return SpineBackendCanvas;
		}
		return null;
	},

	// (内部) 确保已初始化
	_ensureInit: function() {
		if (!this._inited) {
			this.init(this._basePath);
		}
	},

	// ----------------------------------------------------------
	//  (内部) _preloadAll()
	//  按 gameabc_face.spineAssets 清单，把全部 Spine 资源注入当前 AssetManager 并发起加载。
	//  ⚠️ 必须整批注入，不能只补"当前已存在的 entry"：
	//  规避 file:// 下 XHR CORS 用的 rawDataUris 是 Downloader 实例私有的
	//  （AssetManagerBase 构造时默认 new Downloader()），换一个新 AssetManager
	//  就等于换了一份空 rawDataUris。若只补已存在的 entry，context 恢复之后
	//  首次触发的新特效（如天胡）会走真实 XHR 被 CORS 拦掉，_tryBuild 里 require()
	//  抛异常 → ready 恒 false → 每帧重试且永不显示。
	//  返回本次注册的资源组数。
	// ----------------------------------------------------------
	_preloadAll: function() {
		var list = gameabc_face.spineAssets;
		if (!list || list.length === 0) return 0;
		var textData = gameabc_face.spineTextData || {};
		for (var i = 0; i < list.length; i++) {
			var name = list[i];
			var jsonKey = name + ".json";
			var atlasKey = name + ".atlas";
			// 将嵌入文本数据注册为 rawDataURI，Spine Downloader 会优先从内存读取
			if (textData[jsonKey]) {
				this._assetManager.setRawDataURI(jsonKey, "data:," + textData[jsonKey]);
			}
			if (textData[atlasKey]) {
				this._assetManager.setRawDataURI(atlasKey, "data:," + textData[atlasKey]);
			}
			this._assetManager.loadText(jsonKey);
			this._loadedPaths[jsonKey] = true;
			this._assetManager.loadTextureAtlas(atlasKey);
			this._loadedPaths[atlasKey] = true;
		}
		spineLog("[SpineMgr] 预加载 " + list.length + " 组 Spine 资源" +
			(Object.keys(textData).length > 0 ? "（使用嵌入数据）" : "（使用网络请求）"));
		return list.length;
	},

	// (内部) 自动加载：根据 id 约定文件名 id.json / id.atlas
	// 主流 SkeletonJson.scale 方案：从 _scaleMap 读取目标缩放，传入 load() 在解析时烘焙
	_autoLoad: function(id) {
		if (this._entries[id]) return;
		var scale = this._scaleMap[id] || 1;
		this.load(id, id + ".json", id + ".atlas", { scale: scale });
	},

	// (内部) 将命令加入等待队列
	_queueCmd: function(id, method, args) {
		if (!this._pendingCmds[id]) this._pendingCmds[id] = [];
		this._pendingCmds[id].push({method: method, args: args});
	},

	// (内部) 实例就绪后执行队列中的命令
	_flushCmds: function(id) {
		var cmds = this._pendingCmds[id];
		if (!cmds || cmds.length === 0) return;
		delete this._pendingCmds[id];
		for (var i = 0; i < cmds.length; i++) {
			var cmd = cmds[i];
			this[cmd.method].apply(this, [id].concat(cmd.args));
		}
	},

	// ----------------------------------------------------------
	//  load(id, jsonFile, atlasFile, option)
	//  加载一组 Spine 资源, id 为自定义标识
	//  option: {x, y, scale, skin, animation, loop, mixDuration}
	// ----------------------------------------------------------
	load: function(id, jsonFile, atlasFile, option) {
		this._ensureInit();
		if (!this._inited) return;
		var opt = option || {};
		// 只加载尚未请求过的资源（预加载过的会跳过）
		if (!this._loadedPaths[jsonFile]) {
			this._assetManager.loadText(jsonFile);
			this._loadedPaths[jsonFile] = true;
		}
		if (!this._loadedPaths[atlasFile]) {
			this._assetManager.loadTextureAtlas(atlasFile);
			this._loadedPaths[atlasFile] = true;
		}
		this._entries[id] = {
			jsonFile:  jsonFile,
			atlasFile: atlasFile,
			skeleton:  null,
			state:     null,
			x:         opt.x     || 0,
			y:         opt.y     || 0,
			scale:     opt.scale || 1,
			skin:      opt.skin  || "default",
			defAnim:   opt.animation || null,
			defLoop:   opt.loop !== undefined ? opt.loop : true,
			mixDur:    opt.mixDuration || 0.2,
			visible:   true,
			ready:     false,
			_hideOnComplete: false,    // 播放完成后是否自动隐藏
			_hideAfterCompletes: 0,   // 剩余多少次 complete 后触发隐藏
			_buildFailLogged: false   // 构建失败日志只记一次（_tryBuild 每帧调用）
		};
	},

	// ----------------------------------------------------------
	//  ensureEntry(id, jsonFile, atlasFile, option)
	//  确保 id 对应的 entry 存在并达到 option 指定的状态。
	//  entry 生命周期归 SpineMgr 管，调用方无需掌握"不在就 load、在就 setScale"的内部规则，
	//  也无需从 id 推导文件名（entryId 与资源文件名不一定同名，如 ting_0 -> ting.json）。
	// ----------------------------------------------------------
	ensureEntry: function(id, jsonFile, atlasFile, option) {
		var e = this._entries[id];
		if (!e) {
			this.load(id, jsonFile, atlasFile, option);
			return;
		}
		if (option && option.scale !== undefined) {
			this.setScale(id, option.scale);
		}
	},

	// ----------------------------------------------------------
	//  isReady()  后端是否已就绪、能真正播放 Spine
	//  探测阶段的 canvas 兜底只覆盖"WebGL 不可用"；若探测通过但 GL 初始化失败
	//  （叠加层 DOM 缺失 / 并发 context 耗尽 / shader 编译失败），此时 canvas 运行时
	//  并未加载、回不去，调用方应据此走各自既有的帧动画降级路径，
	//  而不是让 Spine 静默失效却以为播成功了。
	// ----------------------------------------------------------
	isReady: function() {
		return !!this._inited;
	},

	// ----------------------------------------------------------
	//  (内部) 资源加载完成后实例化骨骼
	//  同一 jsonFile+scale 的 SkeletonData 只解析一次，多个 entry 共享
	// ----------------------------------------------------------
	_buildEntry: function(entry) {
		spineLog("[SpineMgr] _buildEntry: " + entry._id + "  skelJson.scale=" + entry.scale);
		var cacheKey = entry.jsonFile + "_s" + entry.scale;
		var skelData = this._skelDataCache[cacheKey];
		if (!skelData) {
			var atlas  = this._assetManager.require(entry.atlasFile);
			var loader = new spine.AtlasAttachmentLoader(atlas);
			var skelJson   = new spine.SkeletonJson(loader);
			skelJson.scale = entry.scale;
			skelData = skelJson.readSkeletonData(
				this._assetManager.require(entry.jsonFile)
			);
			this._skelDataCache[cacheKey] = skelData;
			spineLog("[SpineMgr] SkeletonData 解析并缓存: " + cacheKey);
		} else {
			spineLog("[SpineMgr] SkeletonData 命中缓存: " + cacheKey);
		}
		entry.skeleton = new spine.Skeleton(skelData);

		// 设置皮肤
		if (entry.skin && entry.skin !== "default") {
			entry.skeleton.setSkinByName(entry.skin);
		}
		entry.skeleton.setToSetupPose();

		// AnimationState
		var stateData       = new spine.AnimationStateData(skelData);
		stateData.defaultMix = entry.mixDur;
		entry.state         = new spine.AnimationState(stateData);

		// 绑定事件回调 —— 转发到 Spine_Event.js
		entry.state.addListener({
			complete: function(trackEntry) {
				// 自动隐藏：playOnce / playQueue 设置的计数器
				if (entry._hideOnComplete && !trackEntry.loop) {
					entry._hideAfterCompletes--;
					if (entry._hideAfterCompletes <= 0) {
						entry.visible = false;
						entry._hideOnComplete = false;
					}
				}
				if (gameabc_face.spine_onComplete) {
					gameabc_face.spine_onComplete(entry._id, trackEntry.animation.name, trackEntry.trackIndex);
				}
			},
			event: function(trackEntry, event) {
				if (gameabc_face.spine_onEvent) {
					gameabc_face.spine_onEvent(entry._id, event.data.name, event.intValue, event.floatValue, event.stringValue);
				}
			}
		});

		// 默认动画
		if (entry.defAnim) {
			entry.state.setAnimation(0, entry.defAnim, entry.defLoop);
		}
		entry.ready = true;
	},

	// ----------------------------------------------------------
	//  (内部) 每帧调用：确保所有资源就绪
	// ----------------------------------------------------------
	_tryBuild: function() {
		if (!this._assetManager.isLoadingComplete()) return false;
		for (var id in this._entries) {
			var e = this._entries[id];
			if (!e.ready) {
				e._id = id;
				try {
					this._buildEntry(e);
					spineLog("[SpineMgr] " + id + " 构建完成");
					this._flushCmds(id);
				} catch(err) {
					// 重试本身必须保留（资源可能只是还没到齐），但日志只记一次：
					// 本方法每帧调用，持续失败时会以约 60 条/秒刷屏并淹没其他日志。
					if (!e._buildFailLogged) {
						e._buildFailLogged = true;
						spineWarn("[SpineMgr] " + id + " 构建失败(仅记一次): " + err.message);
					}
					e.ready = false;
				}
			}
		}
		return true;
	},

	// ----------------------------------------------------------
	//  (内部) WebGL context 恢复后重建全部 GPU 资源
	//  context lost 会让 AssetManager 中缓存的 GLTexture 与 shader 一并作废，
	//  必须重新加载资源并重建所有 entry，否则表现为"特效再也不显示"。
	// ----------------------------------------------------------
	_rebuildAfterContextRestored: function() {
		spineLog("[SpineMgr] 重建 Spine 资源（context restored）");

		// 记录当前 entry 的声明式状态，重建后按原样恢复
		var saved = [];
		for (var id in this._entries) {
			var e = this._entries[id];
			saved.push({
				id:        id,
				jsonFile:  e.jsonFile,
				atlasFile: e.atlasFile,
				x:         e.x,
				y:         e.y,
				scale:     e.scale,
				skin:      e.skin,
				mixDur:    e.mixDur
			});
		}

		// 丢弃全部缓存：SkeletonData 持有已作废的 GLTexture 引用，不能复用
		this._entries = {};
		this._pendingCmds = {};
		this._skelDataCache = {};
		this._loadedPaths = {};

		// 先释放旧 AssetManager 再换新的：GLTexture 构造时会 context.addRestorable(this)，
		// 只有 dispose() 才 removeRestorable。本后端刻意复用同一个 ManagedWebGLRenderingContext
		// （见 SpineBackendWebGL._ensureGL 注释），若不释放，每恢复一次就把 23 页图集的
		// GLTexture 永久留在 restorables 里（解码位图约 137MB）—— 而 context lost 的诱因
		// 正是内存压力，泄漏会把 lost/restore 变成越恢复越糟的死循环。
		// context 已丢失时 gl.deleteTexture 等按规范是 no-op，安全；仍加 try/catch 防御，
		// 释放失败不能挡住后面的重建。
		if (this._assetManager) {
			try {
				this._assetManager.dispose();
			} catch (errDispose) {
				spineWarn("[SpineMgr] 释放旧 AssetManager 失败(已忽略): " + errDispose.message);
			}
			this._assetManager = null;
		}

		// 本方法在 webglcontextrestored 事件回调中执行，异常会逸出到事件循环，
		// 故与 init 同样显式捕获：重建失败就停在不可用状态并留下日志。
		try {
			this._assetManager = this._backend.createAssetManager(this._basePath);
		} catch (err) {
			spineWarn("[SpineMgr] context 恢复后重建 AssetManager 失败: " + err.message);
			this._inited = false;
			return;
		}

		// 整批重注入 rawDataURI 并重新发起加载：新 AssetManager = 新 Downloader = 空 rawDataUris，
		// 只补 saved 里的资源会让恢复后首次触发的新特效在 file:// 下被 CORS 拦死（见 _preloadAll 注释）。
		// _preloadAll 会把全部资源写进 _loadedPaths，故下面按 saved 重建 entry 时
		// load() 的 if (!this._loadedPaths[...]) 判断会正确跳过重复请求。
		this._preloadAll();

		for (var i = 0; i < saved.length; i++) {
			var s = saved[i];
			this.load(s.id, s.jsonFile, s.atlasFile, {
				x: s.x, y: s.y, scale: s.scale, skin: s.skin, mixDuration: s.mixDur
			});
			// 重建后默认不可见：正在播的动画已随 context 丢失，
			// 强行续播会出现半截动画，交由下一次业务触发重新播放。
			this._entries[s.id].visible = false;
		}
	},

	// ----------------------------------------------------------
	//  updateAndDraw(ctx)   每帧自动调用
	//  ctx: gameabc_face.dc (Canvas 2D Context)
	// ----------------------------------------------------------
	updateAndDraw: function(ctx) {
		if (!this._inited) return;
		this._tryBuild();

		var now = Date.now();
		var dt  = (now - this._lastTime) / 1000;
		this._lastTime = now;
		if (dt <= 0 || dt > 0.5) dt = 1/30;

		// 先推进动画状态：即使本帧无法绘制（后端未就绪 / context lost），
		// 动画时间轴与 complete 事件也必须照常推进，否则回调链会卡死。
		var visibleList = [];
		for (var id in this._entries) {
			var e = this._entries[id];
			if (!e.ready || !e.visible) continue;

			e.state.update(dt);
			e.state.apply(e.skeleton);
			// 骨骼位置由后端决定：Canvas 后端归零(用 ctx.translate 定位)，
			// WebGL 后端写入 x/-y(位移并入骨骼，使所有 entry 共用同一 MVP)。
			// 必须在 updateWorldTransform 之前设置，否则不生效于本帧。
			this._backend.placeEntry(e);
			e.skeleton.updateWorldTransform(spine.Physics.update);
			visibleList.push(e);
		}

		if (!this._backend.beginFrame(visibleList.length)) return;
		// endFrame 必须配对执行：WebGL 后端的 PolygonBatcher 只在 endFrame 里 end()，
		// 若 drawEntry 抛出而漏了 end()，batcher.isDrawing 会永久停在 true，
		// 下一帧 begin() 即抛 "PolygonBatch is already drawing" 并冒到 gameenddraw —— Spine 永久黑屏。
		try {
			for (var i = 0; i < visibleList.length; i++) {
				this._backend.drawEntry(visibleList[i]);
			}
		} finally {
			this._backend.endFrame();
		}
	},

	// ==========================================================
	//  公开控制 API
	// ==========================================================

	setAnimation: function(id, animName, loop, track) {
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);
			this._queueCmd(id, "setAnimation", [animName, loop, track]);
			return null;
		}
		e.visible = true;
		if (!e.ready) {
			this._queueCmd(id, "setAnimation", [animName, loop, track]);
			return null;
		}
		return e.state.setAnimation(track || 0, animName, loop !== false);
	},

	addAnimation: function(id, animName, loop, delay, track) {
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);
			this._queueCmd(id, "addAnimation", [animName, loop, delay, track]);
			return null;
		}
		if (!e.ready) {
			this._queueCmd(id, "addAnimation", [animName, loop, delay, track]);
			return null;
		}
		return e.state.addAnimation(track || 0, animName, loop !== false, delay || 0);
	},

	setPosition: function(id, x, y) {
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);
			e = this._entries[id];
		}
		e.x = x; e.y = y;
	},

	setScale: function(id, sx, sy) {
		// 主流方案：scale 通过 SkeletonJson.scale 在 load 时烘焙，运行时 setScale 更新 _scaleMap
		// 并在 entry 未就绪时作为 option 重建，保持接口向后兼容
		this._scaleMap[id] = sx;
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);   // 会使用 _scaleMap[id] = sx
			return;
		}
		if (e.scale === sx) return;  // 已是目标 scale，无需重建
		// 目标 scale 与已烘焙 scale 不同 → 清除旧 entry 并以新 scale 重建。
		// 文件名必须取自 entry（load 时记录的权威值）：entryId 与资源文件名不一定同名
		// （如 entryId=ting_0 对应 ting.json），按 id 推导会去加载不存在的文件。
		var savedX = e.x, savedY = e.y;
		var savedJson = e.jsonFile, savedAtlas = e.atlasFile;
		this.remove(id);
		this.load(id, savedJson, savedAtlas, { scale: sx, x: savedX, y: savedY });
	},

	setFlip: function(id, flipX, flipY) {
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);
			this._queueCmd(id, "setFlip", [flipX, flipY]);
			return;
		}
		if (!e.skeleton) {
			this._queueCmd(id, "setFlip", [flipX, flipY]);
			return;
		}
		e.skeleton.scaleX = Math.abs(e.skeleton.scaleX) * (flipX ? -1 : 1);
		e.skeleton.scaleY = Math.abs(e.skeleton.scaleY) * (flipY ? -1 : 1);
	},

	setVisible: function(id, visible) {
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);
			e = this._entries[id];
		}
		e.visible = !!visible;
	},

	setSkin: function(id, skinName) {
		var e = this._entries[id];
		if (!e) {
			this._autoLoad(id);
			this._queueCmd(id, "setSkin", [skinName]);
			return;
		}
		if (!e.ready) {
			this._queueCmd(id, "setSkin", [skinName]);
			return;
		}
		e.skeleton.setSkinByName(skinName);
		e.skeleton.setSlotsToSetupPose();
	},

	getAnimations: function(id) {
		var e = this._entries[id];
		if (!e) { this._autoLoad(id); return []; }
		if (!e.ready) return [];
		var anims = e.skeleton.data.animations;
		var names = [];
		for (var i = 0; i < anims.length; i++) names.push(anims[i].name);
		return names;
	},

	getSkins: function(id) {
		var e = this._entries[id];
		if (!e) { this._autoLoad(id); return []; }
		if (!e.ready) return [];
		var skins = e.skeleton.data.skins;
		var names = [];
		for (var i = 0; i < skins.length; i++) names.push(skins[i].name);
		return names;
	},

	playOnce: function(id, animName, track) {
		this.setVisible(id, true);
		// 重播前重置骨骼到初始姿态，消除上次末帧残留导致的混合过渡（斜向位移）
		var e = this._entries[id];
		if (e && e.ready) {
			e.state.clearTracks();
			e.skeleton.setToSetupPose();
		}
		this.setAnimation(id, animName, false, track);
		e = this._entries[id];
		if (e) {
			e._hideOnComplete = true;
			e._hideAfterCompletes = 1;
		}
	},

	playQueue: function(id, animList, hideOnComplete) {
		if (!animList || animList.length === 0) return;
		this.setVisible(id, true);
		// 重播前重置骨骼到初始姿态，消除上次末帧残留导致的混合过渡
		var e = this._entries[id];
		if (e && e.ready) {
			e.state.clearTracks();
			e.skeleton.setToSetupPose();
		}
		this.setAnimation(id, animList[0], false, 0);
		for (var i = 1; i < animList.length; i++) {
			this.addAnimation(id, animList[i], false, 0, 0);
		}
		var e = this._entries[id];
		if (e) {
			e._hideOnComplete = hideOnComplete !== false;
			e._hideAfterCompletes = animList.length;
		}
	},

	stop: function(id) {
		var e = this._entries[id];
		if (!e) return;
		e.visible = false;
		e._hideOnComplete = false;
		e._hideAfterCompletes = 0;
		delete this._pendingCmds[id];
		if (e.state) {
			e.state.clearTracks();
		}
		if (e.skeleton) {
			e.skeleton.setToSetupPose();
		}
	},

	stopAll: function() {
		for (var id in this._entries) {
			this.stop(id);
		}
	},

	remove: function(id) {
		delete this._entries[id];
		delete this._pendingCmds[id];
	},

	removeAll: function() {
		this._entries = {};
		this._pendingCmds = {};
		this._skelDataCache = {};
	}
};

// 挂载到 gameabc_face 上
gameabc_face.spineMgr = SpineMgr;

// ★ 自动预加载：读取 gameabc_face.spineAssets 清单，在引擎启动前预加载所有 Spine 资源
//   如果存在 spineTextData（嵌入文本数据），则通过 setRawDataURI 注入，
//   彻底避免 file:// 协议下 XHR CORS 拦截问题
if (gameabc_face.spineAssets && gameabc_face.spineAssets.length > 0) {
	SpineMgr._ensureInit();
	if (!SpineMgr._inited) {
		// 后端未就绪：跳过预加载，但必须继续往下走完 gameenddraw 拦截的安装。
		// 此处不能 return —— 预加载块在 IIFE 函数体内，return 会退出整个 IIFE，
		// 反而导致拦截装不上，正是本守卫要避免的后果。
		// 回归锁：codes/test/node/spineMgr.gameEndDrawGuard.test.js
		spineWarn("[SpineMgr] 后端未就绪，跳过 Spine 资源预加载");
	} else {
		// 与 context 恢复后的重注入共用同一份实现，避免两处清单分叉
		SpineMgr._preloadAll();
	}
}

// ★ 用 defineProperty 拦截 gameenddraw 赋值
//   无论 gamemain.js 或其他代码如何定义 gameenddraw，
//   Spine 渲染都会自动追加在用户逻辑之后
var _userEndDraw = gameabc_face.gameenddraw || null;
var _wrappedEndDraw = function(gameid, spid, times, timelong) {
	if (typeof _userEndDraw === "function") {
		_userEndDraw(gameid, spid, times, timelong);
	}
	var ctx = gameabc_face.dc;
	if (ctx && SpineMgr._inited) {
		SpineMgr.updateAndDraw(ctx);
	}
};
Object.defineProperty(gameabc_face, "gameenddraw", {
	configurable: true,
	get: function() { return _wrappedEndDraw; },
	set: function(fn) { _userEndDraw = fn; }
});

})();