From a62b70ef4cc9276e239d7d1bbda8270b2339121b Mon Sep 17 00:00:00 2001 From: humingxing <930621236@qq.com> Date: Fri, 16 Oct 2026 20:29:26 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9bug?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- assets/script/battle/bag/PlayerBagTextPool.ts | 71 +++++++--- .../battle/view/AreaUnlockGuidePresenter.ts | 126 ++++++++++++++---- assets/script/sdk/config/DefaultConfig.ts | 2 +- bin/tt_slgjm1.0.3.bin | 1 + 4 files changed, 155 insertions(+), 45 deletions(-) create mode 100644 bin/tt_slgjm1.0.3.bin diff --git a/assets/script/battle/bag/PlayerBagTextPool.ts b/assets/script/battle/bag/PlayerBagTextPool.ts index 4e68547..104169a 100644 --- a/assets/script/battle/bag/PlayerBagTextPool.ts +++ b/assets/script/battle/bag/PlayerBagTextPool.ts @@ -204,7 +204,8 @@ export class PlayerBagTextPool { } /** - * 属性卡：同显示等级、不同 Text.type 的字（不扣减字池）。 + * 属性卡/随机牌：保留显示等级，随机换成其它五行 Text.id（不扣减字池）。 + * 不按字池 Text.level 过滤——高等级由合成抬升，只要求目标属性在该显示等级有 Hero。 * @param currentWeapon2Id 当前字 * @param level 显示等级 */ @@ -212,30 +213,19 @@ export class PlayerBagTextPool { const curId = Math.floor(Number(currentWeapon2Id) || 0); const lv = Math.floor(Number(level) || 0); if (curId <= 0 || lv <= 0) return null; - let curType = 0; - for (let i = 0; i < this._textIds.length; i++) { - if (this._textIds[i] !== curId && this._heroIds[i] !== curId) continue; - curType = this._types[i]; - break; - } - if (curType < 1 || curType > 5) { - const list = gg.data.table.getTableList(TableNames.Text) ?? []; - for (let i = 0; i < list.length; i++) { - if (Number(list[i].id) !== curId) continue; - curType = Math.floor(Number(list[i].type) || 0); - break; - } - } + const curType = this._resolveElementType(curId); if (curType < 1 || curType > 5) { console.log('[PlayerBagTextPool] 属性卡无法解析当前 type', curId); return null; } + const heroes = gg.data.table.getTableList(TableNames.Hero) ?? []; const candidates: number[] = []; - for (let i = 0; i < this._textIds.length; i++) { - if (this._types[i] === curType) continue; - if (this._levels[i] !== lv) continue; - const id = this._textIds[i]; - if (id > 0) candidates.push(id); + for (let type = 1; type <= 5; type++) { + if (type === curType) continue; + if (!this._heroAt(heroes, type, lv)) continue; + const textId = this._anyElementTextId(type); + if (!(textId > 0)) continue; + candidates.push(textId); } if (candidates.length <= 0) { console.log('[PlayerBagTextPool] 属性卡无同级异属性候选', lv, curType); @@ -245,6 +235,47 @@ export class PlayerBagTextPool { return { weapon2Id: pick, level: lv }; } + /** + * 解析五行 Text.type（池内命中或查 Text 表）。 + * @param weapon2Id Text.id / 旧池 Hero.id + */ + private _resolveElementType(weapon2Id: number): number { + const id = Math.floor(Number(weapon2Id) || 0); + if (!(id > 0)) return 0; + for (let i = 0; i < this._textIds.length; i++) { + if (this._textIds[i] !== id && this._heroIds[i] !== id) continue; + const t = this._types[i]; + if (t >= 1 && t <= 5) return t; + } + const list = gg.data.table.getTableList(TableNames.Text) ?? []; + for (let i = 0; i < list.length; i++) { + if (Number(list[i].id) !== id) continue; + return Math.floor(Number(list[i].type) || 0); + } + return 0; + } + + /** + * 取任一该五行的 Text.id（池优先，否则 Text 表）。 + * @param type Text.type 1–5 + */ + private _anyElementTextId(type: number): number { + const t = Math.floor(Number(type) || 0); + if (t < 1 || t > 5) return 0; + for (let i = 0; i < this._textIds.length; i++) { + if (this._types[i] !== t) continue; + const id = this._textIds[i]; + if (id > 0) return id; + } + const list = gg.data.table.getTableList(TableNames.Text) ?? []; + for (let i = 0; i < list.length; i++) { + if (Math.floor(Number(list[i].type) || 0) !== t) continue; + const id = Math.floor(Number(list[i].id) || 0); + if (id > 0) return id; + } + return 0; + } + /** * 按 id 扣减 1 次 remaining（GM/预设刷新等非 rollSlots 路径）。 * @param weapon2Id Text.id 或池输出的 Hero.id diff --git a/assets/script/battle/view/AreaUnlockGuidePresenter.ts b/assets/script/battle/view/AreaUnlockGuidePresenter.ts index 0acbeb8..b5c29e5 100644 --- a/assets/script/battle/view/AreaUnlockGuidePresenter.ts +++ b/assets/script/battle/view/AreaUnlockGuidePresenter.ts @@ -1,4 +1,4 @@ -import { Color, Graphics, Node, UITransform, Vec3, isValid, sp } from 'cc'; +import { _decorator, Color, Component, Graphics, Node, UITransform, Vec3, isValid, sp } from 'cc'; import { isElementGlyphType } from 'db://assets/mx/module/merge'; import { GBundle } from '../../game/ConfigRes'; import { AI_VIEW_LOCAL_CAMP } from '../ai/runtime/AiCampArea'; @@ -8,6 +8,8 @@ import type { MapManager } from '../map/legacy/MapManager'; import { BattleSpinePlayback } from '../presentation/BattleSpinePlayback'; import type { TextGrid } from './TextGrid'; +const { ccclass } = _decorator; + /** 引导虚线框预制体路径 */ const FRAME_PATH = 'prefab/障碍物/'; /** 引导虚线框预制体名 */ @@ -22,15 +24,29 @@ const DASH_LEN = 12; const DASH_HALF_W = 2.5; /** 描边相对半宽加宽 */ const DASH_OUTLINE_EXTRA = 1.5; -/** 背包端取字块顶边中点的向上偏移 */ -const BAG_TOP_PAD = 2; -/** 气泡端取底边中点的向下偏移 */ -const TIP_BOTTOM_PAD = 2; +/** 流动速度：像素/秒（背包→地图） */ +const FLOW_SPEED = 48; /** 交替色：黑 */ const DASH_BLACK = new Color(15, 15, 15, 255); /** 交替色：白 */ const DASH_WHITE = new Color(255, 255, 255, 255); +/** + * 连线层每帧推进斑马相位。 + */ +@ccclass('AreaUnlockGuideFlowTick') +class AreaUnlockGuideFlowTick extends Component { + /** 宿主 */ + host: AreaUnlockGuidePresenter | null = null; + + /** + * @param dt 帧间隔 + */ + update(dt: number): void { + this.host?.onFlowTick(dt); + } +} + /** 世界坐标复用 */ const _bagWorld = new Vec3(); /** 气泡世界坐标复用 */ @@ -72,6 +88,18 @@ export class AreaUnlockGuidePresenter { private _frame: Node | null = null; /** 当前标识的背包槽；null 表示未展示 */ private _slotIndex: number | null = null; + /** 连线本地起点 x */ + private _fromX = 0; + /** 连线本地起点 y */ + private _fromY = 0; + /** 连线本地终点 x */ + private _toX = 0; + /** 连线本地终点 y */ + private _toY = 0; + /** 斑马流动相位（像素） */ + private _flowPhase = 0; + /** 是否正在播流动 */ + private _flowing = false; /** * 绑定连线层父节点（须同时覆盖地图与背包，如 BattleGame 根）。 @@ -87,6 +115,8 @@ export class AreaUnlockGuidePresenter { /** 释放节点与池资源 */ unbind(): void { this.clear(); + const tick = this._lineLayer?.getComponent(AreaUnlockGuideFlowTick); + if (tick) tick.host = null; if (this._lineLayer?.isValid) { this._lineLayer.destroy(); } @@ -104,12 +134,30 @@ export class AreaUnlockGuidePresenter { clear(): void { const prevHost = this._frame?.parent; this._slotIndex = null; + this._stopFlow(); this._releaseFrame(); if (prevHost?.isValid) this._purgeOrphanFrames(prevHost); if (this._graphics?.isValid) this._graphics.clear(); if (this._lineLayer?.isValid) this._lineLayer.active = false; } + /** + * 连线层帧 tick：推进相位并重绘。 + * @param dt 帧间隔 + */ + onFlowTick(dt: number): void { + if (!this._flowing) return; + if (!this._lineLayer?.isValid || !this._lineLayer.active) return; + if (!this._graphics?.isValid) return; + const step = Math.max(0, Number(dt) || 0) * FLOW_SPEED; + if (step <= 0) return; + // 相位减小：斑马段沿起点(背包)→终点(地图)滑动 + this._flowPhase -= step; + const period = DASH_LEN * 2; + if (this._flowPhase < 0) this._flowPhase = (this._flowPhase % period + period) % period; + this._redrawLine(); + } + /** * 按背包与当前解锁条件刷新引导。 * 原槽仍可解锁时保持不变，避免频繁乱跳。 @@ -295,12 +343,15 @@ export class AreaUnlockGuidePresenter { } this._lineLayer = layer; this._graphics = layer.getComponent(Graphics); + let tick = layer.getComponent(AreaUnlockGuideFlowTick); + if (!tick) tick = layer.addComponent(AreaUnlockGuideFlowTick); + tick.host = this; this._disableNodeHit(layer); layer.active = false; } /** - * 从背包字顶边中点连到气泡底边中点。 + * 背包字中心 → 地图待解锁格中心（气泡已挂在格心）。 * @param bagNode 背包字块 * @param tip 格子锁气泡 */ @@ -311,46 +362,73 @@ export class AreaUnlockGuidePresenter { const layerUt = layer.getComponent(UITransform); if (!layerUt) return; - const bagUt = bagNode.getComponent(UITransform); - const tipUt = tip.getComponent(UITransform); - const bagHalfH = bagUt ? bagUt.contentSize.height * 0.5 * Math.abs(bagNode.worldScale.y) : 30; - const tipHalfH = tipUt ? tipUt.contentSize.height * 0.5 * Math.abs(tip.worldScale.y) : 20; - - _bagWorld.set(bagNode.worldPosition.x, bagNode.worldPosition.y + bagHalfH + BAG_TOP_PAD, bagNode.worldPosition.z); - _tipWorld.set(tip.worldPosition.x, tip.worldPosition.y - tipHalfH - TIP_BOTTOM_PAD, tip.worldPosition.z); + _bagWorld.set(bagNode.worldPosition.x, bagNode.worldPosition.y, bagNode.worldPosition.z); + _tipWorld.set(tip.worldPosition.x, tip.worldPosition.y, tip.worldPosition.z); layerUt.convertToNodeSpaceAR(_bagWorld, _fromLocal); layerUt.convertToNodeSpaceAR(_tipWorld, _toLocal); - - g.clear(); - this._fillZebraDash(g, _fromLocal.x, _fromLocal.y, _toLocal.x, _toLocal.y); + const nx = _fromLocal.x; + const ny = _fromLocal.y; + const mx = _toLocal.x; + const my = _toLocal.y; + const moved = Math.abs(nx - this._fromX) > 1 + || Math.abs(ny - this._fromY) > 1 + || Math.abs(mx - this._toX) > 1 + || Math.abs(my - this._toY) > 1; + this._fromX = nx; + this._fromY = ny; + this._toX = mx; + this._toY = my; + if (!this._flowing || moved) this._flowPhase = 0; + this._redrawLine(); layer.active = true; layer.setSiblingIndex(layer.parent!.children.length - 1); + this._flowing = true; + } + + /** 按当前相位重绘斑马线 */ + private _redrawLine(): void { + const g = this._graphics; + if (!g?.isValid) return; + g.clear(); + this._fillZebraDash(g, this._fromX, this._fromY, this._toX, this._toY, this._flowPhase); + } + + /** 停止流动（清相位，保留层节点） */ + private _stopFlow(): void { + this._flowing = false; + this._flowPhase = 0; } /** - * 黑白段交替实心绳：每段先画反色描边再画本色。 + * 黑白段交替实心绳：相位沿背包→地图方向滑动。 * @param g Graphics * @param x1 起点 x * @param y1 起点 y * @param x2 终点 x * @param y2 终点 y + * @param phase 流动相位（像素） */ - private _fillZebraDash(g: Graphics, x1: number, y1: number, x2: number, y2: number): void { + private _fillZebraDash(g: Graphics, x1: number, y1: number, x2: number, y2: number, phase: number): void { const dx = x2 - x1; const dy = y2 - y1; const len = Math.sqrt(dx * dx + dy * dy); if (len < 1) return; const ux = dx / len; const uy = dy / len; - let d = 0; + const period = DASH_LEN * 2; + const offset = ((phase % period) + period) % period; + let d = -offset; let useBlack = true; while (d < len) { + const d0 = Math.max(d, 0); const d1 = Math.min(d + DASH_LEN, len); - const fill = useBlack ? DASH_BLACK : DASH_WHITE; - const outline = useBlack ? DASH_WHITE : DASH_BLACK; - this._fillDashSeg(g, x1, y1, ux, uy, d, d1, DASH_HALF_W + DASH_OUTLINE_EXTRA, outline); - this._fillDashSeg(g, x1, y1, ux, uy, d, d1, DASH_HALF_W, fill); - d = d1; + if (d1 > d0) { + const fill = useBlack ? DASH_BLACK : DASH_WHITE; + const outline = useBlack ? DASH_WHITE : DASH_BLACK; + this._fillDashSeg(g, x1, y1, ux, uy, d0, d1, DASH_HALF_W + DASH_OUTLINE_EXTRA, outline); + this._fillDashSeg(g, x1, y1, ux, uy, d0, d1, DASH_HALF_W, fill); + } + d += DASH_LEN; useBlack = !useBlack; } } diff --git a/assets/script/sdk/config/DefaultConfig.ts b/assets/script/sdk/config/DefaultConfig.ts index f88cd0a..3138b4b 100644 --- a/assets/script/sdk/config/DefaultConfig.ts +++ b/assets/script/sdk/config/DefaultConfig.ts @@ -7,7 +7,7 @@ import { IConfigData } from "./IConfigData"; export const DefaultConfig: IConfigData = { id: "", name: "tt_slgjm", - vsion: "1.0.2", + vsion: "1.0.3", chanId: "tt", themeId: "1", useDoc: true, diff --git a/bin/tt_slgjm1.0.3.bin b/bin/tt_slgjm1.0.3.bin new file mode 100644 index 0000000..8032ba2 --- /dev/null +++ b/bin/tt_slgjm1.0.3.bin @@ -0,0 +1 @@ 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 \ No newline at end of file