From a0473771f110ace34a788fc39f13adc3fe6c6098 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BA=94=E9=A6=99=E4=B8=B8=E5=AD=90?= <15518898337@163.com>
Date: Tue, 9 Jun 2026 01:28:30 +0800
Subject: [PATCH] =?UTF-8?q?fix:=20=E4=BC=98=E5=8C=96=E8=B7=B3=E4=B8=80?=
 =?UTF-8?q?=E8=B7=B3=E8=BF=90=E8=A1=8C=E6=80=81=E4=B8=8E=E5=9C=B0=E5=9D=97?=
 =?UTF-8?q?=E8=B5=84=E6=BA=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .hermes/shared-memory/decision-log.md         |   12 +-
 .hermes/shared-memory/pitfalls.md             |   79 +-
 ...³•åˆ›ä½œã€‘跳一跳俯视角玩法模æ�¿PRD-2026-05-19.md |   91 +-
 ...��维】本地开�验�与生产�维-2026-05-15.md |    2 +-
 ...�玩法创作】平�入�与玩法链路-2026-05-15.md |   20 +-
 packages/shared/src/contracts/jumpHop.ts      |   31 +
 server-rs/crates/api-server/src/jump_hop.rs   |  978 ++++++++----
 .../crates/module-jump-hop/src/application.rs |  145 +-
 .../src/vector_engine/client.rs               |  113 +-
 .../src/vector_engine/curl_transport.rs       |   21 +-
 .../platform-image/tests/vector_engine.rs     |   73 +-
 .../crates/shared-contracts/src/jump_hop.rs   |   39 +
 .../crates/spacetime-client/src/jump_hop.rs   |   33 +-
 .../spacetime-client/src/mapper/jump_hop.rs   |   44 +-
 .../spacetime-client/src/module_bindings.rs   |    4 +
 .../jump_hop_tile_asset_snapshot_type.rs      |    3 +
 .../jump_hop_tile_face_asset_snapshot_type.rs |   24 +
 ...jump_hop_tile_face_assets_snapshot_type.rs |   22 +
 .../crates/spacetime-module/src/jump_hop.rs   |    2 +-
 .../spacetime-module/src/jump_hop/types.rs    |   28 +
 .../JumpHopRuntimeShell.test.tsx              |  425 ++++-
 .../jump-hop-runtime/JumpHopRuntimeShell.tsx  | 1362 +++++++++++++----
 .../PlatformEntryFlowShellImpl.tsx            |   94 +-
 ...gEntryFlowShell.agent.interaction.test.tsx |  105 ++
 .../JumpHopCreationWorkspace.test.tsx         |    2 +-
 .../workspaces/JumpHopCreationWorkspace.tsx   |    2 +-
 .../jump-hop/jumpHopRuntimeModel.test.ts      |  136 +-
 src/services/jump-hop/jumpHopRuntimeModel.ts  |  280 +++-
 .../miniGameDraftGenerationProgress.test.ts   |    8 +-
 .../miniGameDraftGenerationProgress.ts        |   12 +-
 30 files changed, 3180 insertions(+), 1010 deletions(-)
 create mode 100644 server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_asset_snapshot_type.rs
 create mode 100644 server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_assets_snapshot_type.rs

diff --git a/.hermes/shared-memory/decision-log.md b/.hermes/shared-memory/decision-log.md
index 0cbdb334..003bc244 100644
--- a/.hermes/shared-memory/decision-log.md
+++ b/.hermes/shared-memory/decision-log.md
@@ -1390,10 +1390,10 @@
 - 验�方�：从平�推�或公开详情进入跳一跳作�时，路由 source type 为 `jump-hop`�public code 为 `JH-*`，�行��动消费�端返回的完整 profile / run 数�；�端 smoke 统一使用 `npm run dev:api-server` �动并检查 `/healthz`。
 - 关�文档：`docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`�`docs/�开��维】本地开�验�与生产�维-2026-05-15.md`。
 
-## 2026-05-28 跳一跳�设计为 5x5 地�图集与弹弓拖拽
+## 2026-05-28 跳一跳�设计为 UV 地�图集与长按蓄力
 
 - 背景：旧跳一跳模���留角色生图�有�路径�score/combo 和 `2x3` 地�图集�径，和当�“俯视角平�跳跃 + 主题生�地�池 + 无�路径�的产�需求�一致。
-- 决策：`jump-hop` v1 创作端��留主题输入；image2 生�一张 `5x5`�共 25 个 2D 地�图标的图集，�端按�匀网格切出 25 个 `JumpHopTileAsset`。角色���独生图，�行�使用陶泥儿 logo �明 PNG 角色；�行�输入为按��拉蓄力��手��弹出，�端�交 `chargeMs + dragVectorX + dragVectorY`，�端�决�点。�稿试玩必须使用 `runtimeMode=draft`，正�作�使用 `runtimeMode=published`；排行榜按作�维度�玩家��留 1 �最佳记录，排�为�功跳跃次数���游�时长���更新时间��。
+- 决策：`jump-hop` v1 创作端��留主题输入；image2 �生�一张 `1024x1536` 竖版图集，按 `3列*6行` 容纳 18 个立方体主题物体 UV 展开包装，�个大�元内部固定 `4列*3行` UV 网并切出 `top/front/right/back/left/bottom` 六张�贴图，�端共�久化 108 张 `256x256` ��明 PNG。`JumpHopTileAsset.faceAssets` �存六�贴图，历� `imageSrc/imageObjectKey/assetObjectId` 写 top �作为旧�贴图 fallback；旧作�没有 `faceAssets` 时�行���把�张贴图应用到立方体所有�。角色���独生图，�行�使用陶泥儿 logo �明 PNG 角色；�行�输入为长按蓄力��手起跳，�端��交蓄力值，�端始终沿当�地�中心到下一�地�中心方��决真实�点；`dragVectorX/dragVectorY` 仅作为旧客户端兼容字段�留且��与�决。�稿试玩必须使用 `runtimeMode=draft`，正�作�使用 `runtimeMode=published`；排行榜按作�维度�玩家��留 1 �最佳记录，排�为�功跳跃次数���游�时长���更新时间��。
 - 决策补充：跳一跳创作入�的事实��是 SpacetimeDB `creation_entry_type_config`。默认��和旧默认行都必须�步�移到 `subtitle=主题驱动平�跳跃`�`image_src=/creation-type-references/jump-hop.webp`；�端�在系统默认旧值命中时自动纠�，��覆盖��手动�置。
 - 影�范围：`jump-hop` PRD�`api-server` 生�编排�`module-jump-hop` 领域规则�`spacetime-module` / `spacetime-client` 跳一跳契约��端工作� / 结果页 / runtime / 平�壳调用链。
 - 验�方�：`cargo check -p spacetime-module --manifest-path server-rs/Cargo.toml`�`cargo check -p spacetime-client --manifest-path server-rs/Cargo.toml`�`cargo check -p api-server --manifest-path server-rs/Cargo.toml`�`npm run check:spacetime-schema`�跳一跳工作�和 runtime 定��端测试。
@@ -1407,10 +1407,10 @@
 - 验�方�：`npm test -- src/services/jump-hop/jumpHopRuntimeModel.test.ts src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx`�`cargo test -p module-jump-hop --manifest-path server-rs/Cargo.toml -- --nocapture`。
 - 关�文档：`docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
-## 2026-06-02 跳一跳起跳�离��并加入飞行动画缓冲
+## 2026-06-02 跳一跳飞行动画缓冲与真实�点展示
 
-- 背景：用户�馈当�跳跃到目标�置需�拖得太远，且�手�缺少角色翻腾到目标地�的过渡动画，导致跳跃手感�硬。
-- 决策：`jump-hop` 的 `chargeToDistanceRatio` 统一从 `0.004` ��到 `0.008`，让�等跳跃�离所需拖动�离��；�端 runtime 把“�端真实 run�和“当��幕显示��拆开，�手瞬间先生� `visualJump`，用当�角色�置作为起点��端预测�点作为终点，播放约 `560ms` 的飞行动画；该路径�得等待�端新 run。角色弹到预测�点�若新 run 尚未返回，必须�在预测�点等待，�进入约 `1440ms` 的相机层推进过渡。推进期间地� DOM 层和 DOM 角色层统一包在�一个 camera layer 下移动，旧当�地�自然离开视野，新预览地�从上方露出，�� p1/p2 �独 top/left 过渡导致角色和地���步。相机推进必须�时使用 X/Y �移，从旧目标地��置斜�滑到新当�地��焦�置，�能先横�瞬切居中�纵�推进。地��留当� / 目标 / 预览的深度尺寸差异，但该差异通过固定基准宽高上的 CSS transform scale 表达，并在相机推进期间�样使用 `1440ms` 缓动；当�����外� CSS scale。
+- 背景：用户�馈长按蓄力版本的跳跃手感�硬，�功�角色容易被�回地�中心，且�端回包或相机推进时会出现飞过很远�瞬间拉回的闪现。
+- 决策：`jump-hop` 当�长按蓄力统一使用 `chargeToDistanceRatio=0.004`，相�蓄力时间的世界跳跃�离比上一轮 `0.008` �低一�。�端 runtime 把“�端真实 run�和“当��幕显示��拆开，�手瞬间先生� `visualJump`，用当�角色�置作为起点��端预测真实�点作为终点，播放约 `560ms` 的飞行动画；该路径�得等待�端新 run。角色弹到预测真实�点�若新 run 尚未返回，必须�在预测真实�点等待。�功�地�角色�置必须�留 `lastJump.landedX/landedY` 映射出的真实�移，�得�附回目标地�中心。相机推进以旧窗�真实�点和新窗�真实�点为锚点，使用约 `1440ms` 过渡；推进期间地� DOM 层和 DOM 角色层统一包在�一个 camera layer 下移动，旧当�地�自然离开视野，新预览地�从上方露出，�� p1/p2 �独 top/left 过渡导致角色和地���步。相机推进必须�时使用 X/Y �移，�能先横�瞬切居中�纵�推进。地��留当� / 目标 / 预览的深度尺寸差异，但该差异通过固定基准宽高上的 CSS transform scale 表达，并在相机推进期间�样使用 `1440ms` 缓动；当�����外� CSS scale。
 - 影�范围：`server-rs/crates/module-jump-hop/src/application.rs`�`src/services/jump-hop/jumpHopRuntimeModel.ts`�`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�跳一跳�行�定�测试。
 - 验�方�：`npm test -- src/services/jump-hop/jumpHopRuntimeModel.test.ts src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx`�`cargo test -p module-jump-hop --manifest-path server-rs/Cargo.toml -- --nocapture`�`npm run check:encoding`。
 - 关�文档：`docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
@@ -1418,7 +1418,7 @@
 ## 2026-06-03 跳一跳角色形象改为陶泥儿 logo �明 PNG
 
 - 背景：跳一跳�行�此��使用旧内置 / CSS 角色形象，和用户�求的陶泥儿 logo 角色�一致，也容易和 DOM 地�层出现�挡层级问题。
-- 决策：`jump-hop` v1 ��渲染内置 3D 角色几何体；�行�和结果页统一使用 `public/branding/jump-hop-taonier-character.png`，该文件由陶泥儿 logo 处�为�明 PNG �接入。蓄力时角色沿拖拽方�明显拉长，�地���方�回弹两次。`characterAsset` 继续仅作为历�兼容�述字段，�能�新打开角色生图槽或把角色图片作为创作者��置输入。
+- 决策：`jump-hop` v1 ��渲染内置 3D 角色几何体；�行�和结果页统一使用 `public/branding/jump-hop-taonier-character.png`，该文件由陶泥儿 logo 处�为�明 PNG �接入。蓄力时角色��垂直压缩，�地��留真实�点并轻�回弹。`characterAsset` 继续仅作为历�兼容�述字段，�能�新打开角色生图槽或把角色图片作为创作者��置输入。
 - 影�范围：`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�`src/components/jump-hop-result/JumpHopResultView.tsx`�跳一跳 PRD 和平�链路文档。
 - 验�方�：跳一跳�行� / 结果页测试需�断言角色图片 src 为 `/branding/jump-hop-taonier-character.png`，并确认旧默认角色 fallback ��出现。
 - 关�文档：`docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
diff --git a/.hermes/shared-memory/pitfalls.md b/.hermes/shared-memory/pitfalls.md
index bb648e65..2972bbf6 100644
--- a/.hermes/shared-memory/pitfalls.md
+++ b/.hermes/shared-memory/pitfalls.md
@@ -71,13 +71,13 @@
 - 验�：`CreationAgentWorkspace` 测试应断言进度标题�百分比和�示文本带专属 class；`src/index.test.ts` 应断言这些 class 在 remap surface 内有白色覆盖规则；移动端截图中暗色�片文字应���读。
 - 关�：`src/components/creation-agent/CreationAgentWorkspace.tsx`�`src/components/creation-agent/CreationAgentWorkspace.test.tsx`�`src/index.css`�`src/index.test.ts`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
-## VectorEngine 图片生� SendRequest 超时�按传输失败排查
+## VectorEngine 图片生� request_send 传输错误�按��试网络抖动排查
 
-- 现象：`external_api_call_failure` 里看到 `failureStage=request_send`�`timeout=true`�`statusCode=null`，`errorSource` �能是 `client error (SendRequest)` 或更完整的 reqwest 底层错误链，�端�知�图片生�失败。
-- 原因：`timeout=true` �自 `reqwest::Error::is_timeout()`，�是业务代�固定写死；`SendRequest` 是 Hyper ��请求阶段的错误��标签，�说明请求未拿到�归类的 HTTP �应，�会包�上游 JSON 错误体。
-- 处�：先按 `provider/failureStage/statusClass` ��，�用 `user_id` / `profile_id` 和 `metadata_json.userId/profileId/requestId` 定�触�者��稿 / 作�和�一次 HTTP 请求；`request_send + timeout=true` 优先查 provider 日志的 `source_chain`�请求体大���考图数��出�网络�代�/Nginx�VectorEngine 当时�用性和�一 request_id 日志。当� `platform-image` 对 `request_send` 的 `timeout` / `connect` 错误最多�试 3 次，multipart `/v1/images/edits` �次�试都必须�建 form；看到 `VectorEngine 图片请求��失败，准备�试` �是�次 attempt 失败，最终 `external_api_call_failure` �代表该用户请求整体失败。若记录有 `502` 或 `429 moderation_blocked`，按上游网关或审核失败�行处�，��归到传输超时。
+- 现象：`external_api_call_failure` 里看到 `failureStage=request_send`�`statusCode=null`，`errorSource` �能是 `client error (SendRequest)`�`[35] SSL connect error (Recv failure: Connection reset by peer)`�`[56] Failure when receiving data from the peer (... unexpected eof while reading ...)`；也�能看到 `failureStage=upstream_status`�`statusCode=502`�错误体是 Nginx HTML `502 Bad Gateway`。�端�知�图片生�失败。
+- 原因：`request_send` 表示请求未拿到�归类的 HTTP �应，�会包�上游 JSON 错误体；`upstream_status=502/5xx/429/408` 表示拿到了上游错误�应但�属于��试的过载 / 网关抖动。`timeout=true` �自超时判定，`connect=true` 会�时覆盖 DNS / connect 失败以� libcurl 35 SSL �手�libcurl 56 收包�� EOF�connection reset 这类临时传输错误。
+- 处�：先按 `provider/failureStage/statusClass` ��，�用 `user_id` / `profile_id` 和 `metadata_json.userId/profileId/requestId` 定�触�者��稿 / 作�和�一次 HTTP 请求；`request_send + timeout/connect=true` 或 `upstream_status + statusCode=408/429/5xx` 优先查 provider 日志的 `source_chain`�请求体大���考图数��出�网络�代�/Nginx�VectorEngine 当时�用性和�一 request_id 日志。当� `platform-image` 对 request_send 的 timeout / connect / SSL connect reset / recv error / unexpected eof / send error，以� upstream_status 的 408 / 429 / 5xx 最多�� 5 次，multipart `/v1/images/edits` �次�试都会�新构造 form；看到 `VectorEngine 图片请求��失败，准备�试` 或 `VectorEngine 图片上游状���试，准备�试` �是�次 attempt 失败，最终 `external_api_call_failure` �代表该用户请求整体失败。若记录有 `429 moderation_blocked` 或明确审核错误，按审核失败�行处�，��归到网络抖动。
 - 拼图关�资产生�按 `level_scene -> ui_spritesheet -> level_background` 顺�执行，�个资产会输出 `slot`�`asset_kind`�`elapsed_ms`；排查拼图�稿失败时优先看�一 request_id 下最�一个失败 slot。
-- 验�：`cargo test -p platform-image --manifest-path server-rs/Cargo.toml vector_engine_image_edit_retries_send_timeout_once_and_succeeds`�`cargo check -p api-server --manifest-path server-rs/Cargo.toml`；查询 `tracking_event` 时失败记录应能看到触�者 `user_id` 和�用的 `profile_id`。
+- 验�：`cargo test -p platform-image --manifest-path server-rs/Cargo.toml vector_engine_send_retry_policy -- --nocapture`�`cargo test -p platform-image --manifest-path server-rs/Cargo.toml vector_engine_image_edit_retries_send_timeout_once_and_succeeds`�`cargo check -p api-server --manifest-path server-rs/Cargo.toml`；查询 `tracking_event` 时失败记录应能看到触�者 `user_id` 和�用的 `profile_id`。
 - 关�：`server-rs/crates/platform-image/src/vector_engine/client.rs`�`server-rs/crates/api-server/src/external_api_audit.rs`�`server-rs/crates/api-server/src/openai_image_generation.rs`�`docs/�开��维】本地开�验�与生产�维-2026-05-15.md`。
 
 ## “我的�页�日任务���硬编�进度，也��跨日�留旧状�
@@ -457,6 +457,14 @@
 - 验�：未登录推�页�以直接进入跳一跳�行�，且 `work_play_start` 事件�会�库或出现在 outbox 中，metadata �匿�标记。
 - 关�：`server-rs/crates/api-server/src/jump_hop.rs`�`server-rs/crates/api-server/src/auth.rs`�`server-rs/crates/api-server/src/work_play_tracking.rs`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/rpg-entry/RpgEntryHomeView.recharge.test.tsx`。
 
+## 跳一跳直接打开空 runtime 路由�能�在加载�
+
+- 现象：直接访问 `/runtime/jump-hop` 时页�看起�一直�在“正在载入游� / 正在加载内容�，DOM 内部�有空的跳一跳�行�，没有平��地�或 run 数�。
+- 原因：`appPageRoutes` 会把该路径解�为 `jump-hop-runtime`，但裸路径没有 `work=JH-*` 公开作��，也没有从详情页�动�写入的 `jumpHopRun`，平�壳�挂载 `JumpHopRuntimeShell`。
+- 处�：平�壳在 `jump-hop-runtime` 且缺少 run 时先看 `work` �数；有 `JH-*` 则通过公开 gallery detail 回读 profile 并�动 published run，没有则回到平�首页。全局作���� effect 在跳一跳 runtime 阶段�跳过，��和�行���互相抢路由。
+- 验�：`npm run test -- src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx -t "direct jump hop runtime route"`；�览器 smoke 分别打开 `/`�`/runtime/jump-hop` 和 `/runtime/jump-hop?work=JH-*`。
+- 关�：`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/routing/appPageRoutes.ts`�`src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx`。
+
 ## release tracking outbox ��错误先查 env 缺失
 
 - 现象：release 机器 `journalctl -u genarrative-api.service` �秒刷 `tracking outbox 定时�存 active 文件失败 error=Permission denied (os error 13)` 和 `tracking outbox 批�写入 SpacetimeDB 失败`。
@@ -1740,18 +1748,18 @@
 - 验�：`npm run typecheck`，并跑 `npm test -- src/routing/appPageRoutes.test.ts` 覆盖 JumpHop 阶段路径。
 - 关�：`src/components/platform-entry/platformEntryTypes.ts`�`src/routing/appPageRoutes.ts`�`src/components/platform-entry/PlatformEntryFlowShellImpl.tsx`�`src/components/rpg-entry/RpgEntryHomeView.tsx`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
-## 跳一跳地�图集固定走 5x5 地�池
+## 跳一跳地�图集固定走 18 个 UV 大�元
 
 - 现象：跳一跳�始�稿生�时报 `系列素�图集的物�行数�能超过 n。`，或者生�完���有 atlas 预览路径，地�切片没有真正�盘。
-- 原因：旧模�先��试过通用系列素� helper 和 `2x3` 六格固定 tileType，但当�跳一跳已��设计为“主题 -> 5x5 地�图集 -> 25 个等�地�池 -> 无�路径�，旧的物�行数 / 固定类型模型都会把创作链路带�。
-- 处�：跳一跳地�固定生�一张 `5x5` 主题图集，�端按�匀网格切出 25 张 PNG，并对�张切片�自走 OSS 上传�asset_object 确认和 entity bind；����� `2行*3列`�`start / normal / target / finish / bonus / accent` 六格�径。
-- 验�：`jump_hop.rs` �应�调用通用物�行数模型处�地�图集；公开结果里应能拿到 25 个独立 `JumpHopTileAsset`，�行�无�路径从地�池�机��。
+- 原因：旧模�先��试过通用系列素� helper�`2x3` 六格固定 tileType 和 `5x5` �贴图池，但当�跳一跳已��设计为“主题 -> 一张 `1024x1536` 图集 -> 18 个 `3列*6行` UV 大�元 -> �格 `4列*3行` 六�贴图 -> 无�路径�，旧的物�行数 / 固定类型模型都会把创作链路带�。
+- 处�：跳一跳地�固定�生�一张 `1024x1536` 主题 UV 展开图集，�端先切出 18 个大�元，�从�格固定 UV 网切出 top/front/right/back/left/bottom 六张 `256x256` ��明 PNG，并对 108 张�贴图�自走 OSS 上传�asset_object 确认和 entity bind；����� `2行*3列`�`5x5` �贴图�`start / normal / target / finish / bonus / accent` 六格�径。
+- 验�：`jump_hop.rs` �应�调用通用物�行数模型处�地�图集；公开结果里应能拿到 18 个独立 `JumpHopTileAsset` 且�个新资产包� `faceAssets` 六�贴图，�行�无�路径从地�池�机��；旧资产没有 `faceAssets` 时�能用 `imageSrc` �贴图 fallback。
 - 关�：`server-rs/crates/api-server/src/jump_hop.rs`�`docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
 
 ## 跳一跳��梦主题地�图集 safety rejection ��专项改写
 
 - 现象：跳一跳�稿使用“��梦 / Pokemon / 皮�丘 / 精���等主题时，背景底图和返回按钮�能已生��功，但地�图集的 VectorEngine 请求返回 `Your request was rejected by the safety system`，日志里 `failure_context="跳一跳地�图集生�失败"`�`status=429`�`code="invalid_prompt"`。
-- 原因：25 个�点图集 prompt 会把这些�放进“主题物体图集�语境，容易被上游�解为�求生�具体��梦角色或标志�具，触�安全拦截；这�是普通平�造型��抠图或超时问题。
+- 原因：18 个立方体主题物体 UV 展开图集 prompt 会把这些�放进“主题物体图集�语境，容易被上游�解为�求生�具体��梦角色或标志�具，触�安全拦截；这�是普通平�造型��抠图或超时问题。
 - 处�：仅在跳一跳图片生� prompt 文本命中��梦相关�时�生�侧替�，把 `��梦 / 神奇�� / �袋妖怪 / Pokemon` 改为“原创幻想�宠冒险�具�，把 `精��` 改为“彩色冒险能���，把 `皮�丘 / Pikachu` 改为“黄色闪电�宠符��；��把所有主题都加全局 IP �止约�，用户�稿标题和主题展示也�改。
 - 验�：`cargo test -p api-server jump_hop --manifest-path server-rs/Cargo.toml` 应覆盖��梦�专项替�；真实�调时�一�稿�试�，地�图集请求的 prompt ��包���梦相关�。
 - 关�：`server-rs/crates/api-server/src/jump_hop.rs`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
@@ -1759,9 +1767,9 @@
 ## 跳一跳地�切片��按 tileType �用资产槽�
 
 - 现象：跳一跳生�完��，�行�看起���在显示默认几何地�，或者地�图片在加载时频闪；结果页地�池也�能�看到少���素�。
-- 原因：`tileType` �是路径平�的玩法类型标签，25 个 atlas 切片里会��出现 `normal / target / bonus / accent` 等类型。若�端�久化时用 `tileType` 生� slot/path，�类型切片会写入�一个 `/generated-jump-hop-assets/<profile>/<slot>/image.png`，�上传的切片覆盖先上传的切片，�端�签缓存也会读到��或旧对象。
-- 处�：�端切图�必须按 atlas �元格写入 `tile-01` 到 `tile-25` 的唯一 slot/path；�端结果页和�行�展示生�图时用 `assetObjectId` 作为 `refreshKey`，���生���用旧签�或旧图片缓存。
-- 验�：`cargo test -p api-server jump_hop --manifest-path server-rs/Cargo.toml -- --nocapture` 应包� `jump_hop_tile_asset_slots_are_unique_for_twenty_five_slices`；�端�行�测试应断言地��签带 `assetObjectId` 刷新键。
+- 原因：`tileType` �是路径平�的玩法类型标签，18 个 atlas 大�元里会��出现 `normal / target / bonus / accent` 等类型。若�端�久化时用 `tileType` 生� slot/path，�类型切片会写入�一个 `/generated-jump-hop-assets/<profile>/<slot>/image.png`，�上传的切片覆盖先上传的切片，�端�签缓存也会读到��或旧对象。
+- 处�：�端切图�必须按 atlas �元格写入 `tile-01` 到 `tile-18` 的唯一 tile slot，并把六�贴图写入 `tile-XX-top/front/right/back/left/bottom` 唯一 face slot；�端结果页和�行�展示生�图时用 `assetObjectId` 作为 `refreshKey`，���生���用旧签�或旧图片缓存。
+- 验�：`cargo test -p api-server jump_hop --manifest-path server-rs/Cargo.toml -- --nocapture` 应包� `jump_hop_tile_asset_slots_are_unique_for_eighteen_slices`；�端�行�测试应断言地��签带 `assetObjectId` 刷新键，并覆盖新 UV 资产会解�六张�贴图。
 - 关�：`server-rs/crates/api-server/src/jump_hop.rs`�`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�`src/components/jump-hop-result/JumpHopResultView.tsx`。
 
 ## 跳一跳�点辅助标识���用舞�高度常��脑袋投影
@@ -1772,12 +1780,12 @@
 - 验�：拖拽�程时辅助点应�在当�地�和目标地�之间，完整拖拽时应逼近目标地�中心；�行�截图里辅助点必须始终压在地�与角色之上。
 - 关�：`src/services/jump-hop/jumpHopRuntimeModel.ts`�`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`。
 
-## 跳一跳�点辅助和�端�决必须统一�标�算
+## 跳一跳长按蓄力�能�消费拖拽方�
 
-- 现象：�点辅助标识已�压在目标地�图片上，�手��端�判定失败，玩家看到的是“明明瞄准了�没�上去�。
-- 原因：�端辅助标识使用�幕�素�标绘制，而�端�决使用世界�标。�幕 y 轴�下为正�世界 y 轴�上为正；�时�幕 x/y �个世界��对应的�素比例��。若�端直接把�幕�素拖拽���给�端，辅助点和�端�点方�会�一致。
-- 处�：�端�行��留原始�幕拖拽��用于画弹弓和辅助点，但�交�端�必须按当�地�到目标地�的�幕跨度 / 世界跨度把 x�y 分别�算�世界尺度一致的��；�端继续�负责��弹射和�点�决。
-- 验�：�端回归测试��时覆盖辅助点完整拖拽到目标地�，以��交给�端的��已完�世界尺度�算；�端领域测试覆盖�幕��下拉时应�世界 y 正方�跳出并命中。
+- 现象：跳一跳改�长按蓄力�，如果�端或�端�消费 `dragVectorX/dragVectorY`，玩家手指轻微移动就会改�跳跃方�，和“始终�下一�中心跳�的体验�一致。
+- 原因：历�弹弓拖拽版本把�幕拖拽方�作为正��决输入，契约字段�为兼容旧客户端�留，容易被误认为�是当�玩法规则。
+- 处�：�端�行��用长按时长�交 `dragDistance` 兼容字段，����方�字段；�点预测按当�地�中心到下一�地�中心的方�投影。�端 `module-jump-hop` �使收到旧客户端 `dragVectorX/dragVectorY` 也必须忽略，�按当�地�到下一�地�中心的�����决。
+- 验�：�端回归测试覆盖手指移动�改��交方��预测�点忽略旧方�字段；�端领域测试覆盖旧客户端传错误方�时�按下一�中心命中。
 - 关�：`src/services/jump-hop/jumpHopRuntimeModel.ts`�`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�`server-rs/crates/module-jump-hop/src/application.rs`。
 
 ## 跳一跳创作入�旧文案先查 SpacetimeDB �置
@@ -2055,24 +2063,32 @@
 
 - 现象：跳一跳�手�如果�端很快返回下一帧 run，地�窗�会立刻�移，角色翻腾动画看起��没播放；若�时刷新图片资产，还�能被误认为地�频闪。
 - 原因：�端 run 是规则真相，�端 runtime �需�低延迟表现。如果 DOM 平�层直接用最新 `run.currentPlatformIndex` 渲染，�端回包会抢在动画�完�视觉切�。
-- 处�：�端�留独立 `displayRun`，�手�先进入 `isJumpAnimating=true`，角色在当�窗�内�值飞�目标地�；约 `300ms` ��把 `displayRun` 切到最新�端 run，并进入约 `1440ms` 的 `platformAdvancing` 表现�。推进期间地� DOM 层和 Three.js 角色层必须统一包在�一个 camera layer 下移动，旧当�地�用相机�移自然离开视野，新预览地�从上方露出；���让 p1/p2 �自 top/left 过渡。相机层必须�时设置 `--jump-hop-camera-shift-x` 与 `--jump-hop-camera-shift-y`，从旧目标地��置斜�滑到新当�地��焦�置，��先横�瞬切居中�纵�推进。地��留当� / 目标 / 预览的深度尺寸差异，但深度差异必须用固定宽高 + CSS transform scale 缓动实现，�能直接改宽高瞬切；当�����外� CSS scale。相机推进期间角色自身也�能�留 `left/top` transition，�则 `displayRun` 切�造�的角色局部�标�更会和父级 camera layer �移�加，视觉上��地��从�幕外飞回；角色推进期��许 transform / opacity transition。正�胜负��功跳跃次数�时长和排行榜�以�端 run 为准，�端�延迟显示�。
-- 验�：`npm test -- src/services/jump-hop/jumpHopRuntimeModel.test.ts src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx` 应覆盖动画期间平���在旧窗�，动画结��进入 `data-platform-advancing=true`，Three 角色层与地�层�在 `jump-hop-camera-layer` 内，通过 `--jump-hop-camera-shift-x` 和 `--jump-hop-camera-shift-y` 完�相机斜�推进，并校验��地�按深度�留��视觉尺寸��行�平�宽高使用固定基准值�推进� transform transition 为 `1440ms`�推进�角色 transition �包� `left/top`。
+- 处�：�端�留独立 `displayRun`，�手�先进入 `isJumpAnimating=true`，角色在当�显示窗�内飞��端预测真实�点；视觉预测必须用当�显示窗�的 current/next 地�作为方���，�能拿已���返回的�端新 run 目标�旧窗�角色，�则下一跳会�实际目标�方�飞。飞行动画完���把 `displayRun` 切到最新�端 run，并进入约 `1440ms` 的 `platformAdvancing` 表现�。�功�的角色显示必须使用 `lastJump.landedX/landedY` 映射出的真实�移，���附到目标地�中心。推进期间地� DOM 层和 DOM 角色层必须统一包在�一个 camera layer 下移动，旧当�地�先跟�相机�移离开主视野，之���留在�幕�方；��给旧地�加独立�上 / �下飞走 keyframes，也��因为旧地�还在�留列表里阻塞下一跳。玩家继续��跳时，已完�旧地�继续被新的相机推进自然带离�幕，超过离�阈值�销�。相机层必须�时设置 `--jump-hop-camera-shift-x` 与 `--jump-hop-camera-shift-y`，并以旧窗�真实�点和新窗�真实�点为锚点，��先横�瞬切居中�纵�推进；�行�相机层当�为约 `1.3x` 近�缩放。地��留当� / 目标 / 预览的深度尺寸差异，但深度差异必须用固定宽高 + CSS transform scale 缓动实现，�能直接改宽高瞬切；当�����外� CSS scale。相机推进期间角色自身也�能�留 `left/top` transition，�则 `displayRun` 切�造�的角色局部�标�更会和父级 camera layer �移�加，视觉上��地��从�幕外飞回；角色推进期��许 transform / opacity transition。正�胜负��功跳跃次数�时长和排行榜�以�端 run 为准，�端�延迟显示�。
+- 验�：`npm test -- src/services/jump-hop/jumpHopRuntimeModel.test.ts src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx` 应覆盖动画期间平���在旧窗�，�功�地�留真实�点�移，动画结��进入 `data-platform-advancing=true`，DOM 角色层与地�层�在 `jump-hop-camera-layer` 内，通过 `--jump-hop-camera-shift-x` 和 `--jump-hop-camera-shift-y` 完�相机斜�推进，并校验��地�按深度�留��视觉尺寸��行�平�宽高使用固定基准值�推进� transform transition 为 `1440ms`�推进�角色 transition �包� `left/top`�旧地�没有独立 `jump-hop-platform-exit-drift` keyframes 且下一跳�会被旧地��留�阻塞。
 - 关�：`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�`src/services/jump-hop/jumpHopRuntimeModel.ts`�`server-rs/crates/module-jump-hop/src/application.rs`。
 
 ## 跳一跳相机推进��让地�图片回退到原型方�
 
 - 现象：角色�到下一��，相机推进时旧地�图片�然消失，或新预览地�先露出浅色原型方�，��真实 image2 切片�出现。
-- 原因：旧地�进入 exiting 状�时如果 React key 从 `platformId` �� `platformId-exiting`，图片组件会�新挂载并丢失已加载状�；�时 `JumpHopTileImage` 曾在真实图片 URL 已存在但 `onLoad` 尚未触�时显示 fallback 原型地�。
-- 处�：exiting 地�继续使用稳定 `platformId` key，让旧图片组件在推进期�用；有真实 `resolvedUrl` 且未错误时直接�留真实 `<img>`，�在无 URL 或加载失败时显示 fallback；当� 3 �之外的�续地�通过��预加载图片��解�签� URL 和�览器缓存。
+- 原因：旧地�进入 exiting 状�时如果 React key 从 `platformId` �� `platformId-exiting`，图片组件会�新挂载并丢失已加载状�；�时 `JumpHopTileImage` 曾在真实图片 URL 已存在但 `onLoad` 尚未触�时显示 fallback 原型地�。Three.js 平�层接入�，如果��预加载�让�览器缓存 `<img>`，但没有把未� `platformId` 的纹� URL 写入 `platformTextureUrlsByRenderKey`，相机推进时新预览地�会短暂缺 Three 贴图；若旧 blob 贴图在空 URL 回调时先被 revoke，�继续�留在 state 中，也会留下一个看似 ready�实际已失效的贴图地�。
+- 处�：exiting 地�继续使用稳定 `platformId` key，让旧图片组件在推进期�用；有真实 `resolvedUrl` 且未错误时直接�留真实 `<img>`，�在无 URL 或加载失败时显示 fallback；当� 3 �之外的�续地�通过��预加载图片��解�签� URL 和�览器缓存，并�步按未� `platformId` �布 Three 纹� URL。Three 平�层在当� render items 全部有贴图 URL �继续承接包� exiting 地�在内的 3D 渲染；退出地���相机推进自然离�，�播放独立飞走动画，��退出期露出被放大的平�贴图或��飞多次；贴图 URL 替�必须等新 URL 到达��释放旧 parent-owned blob，空 URL 回调�得清空或 revoke �在活跃 / 预加载 key 上的旧贴图。
 - 验�：`npm run test -- src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx src/services/jump-hop/jumpHopRuntimeModel.test.ts` 应覆盖真实 tile URL �露出 `.jump-hop-runtime__fallback-tile`，并存在 `jump-hop-tile-preload-image`。
 - 关�：`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�`src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx`。
 
-## 跳一跳地�抠图��用绿幕或近白底识别
+## 跳一跳 Three.js 平�层�能左�镜� DOM �标
 
-- 现象：跳一跳生��地�花�雪地�白石或云朵地�时，�明化会把绿色 / 白色主体局部扣掉，�行�看到平�缺���薄或主体消失。
-- 原因：通用图集默认按绿幕和近白底��明化，适� UI / 普通物�，但跳一跳地�天然高频包�绿色和白色；如果继续用 `#00FF00` 绿幕或近白背景识别，素�本体会�入背景分数。旧逻辑还会清��边缘连通的高置信 key 色�，�到主体内部撞色时也�能误伤。
-- 处�：跳一跳地�图集 prompt 固定�求�一纯洋红 `#FF00FF` key 背景；切片���明化调用 `GeneratedAssetSheetAlphaOptions::jump_hop_magenta_screen()`，�扣洋红 key，关闭近白扣除，并且�清��边缘连通 key 色�素。通用绿幕函数��默认绿幕 / 近白兼容，��影�拼图�抓大鹅和敲木鱼。
-- 验�：`cargo test -p platform-image --manifest-path server-rs/Cargo.toml generated_asset_sheet -- --nocapture` 覆盖洋红 key �留绿色�白色和�边缘连通 key 色主体；`cargo test -p api-server jump_hop --manifest-path server-rs/Cargo.toml -- --nocapture` 覆盖跳一跳洋红 prompt 与绿 / 白地�切片。
+- 现象：视觉上下一�地�在角色�侧，但蓄力引导和角色飞行动画�左侧；�端回包�地�窗��闪现摆回正确�置，�是先按�方�飞��由快照刷新纠正。
+- 原因：Three.js 平�层如果把相机 `up` 设置���，或在 Three 容器上�左�镜�，会让 WebGL 地�的�幕 X 轴和 DOM 角色 / �点预测的�幕 X 轴相�。规则层�沿当�地�中心到下一�中心�决，所以�端快照会把状�纠正回�，表现为跳�刷新。
+- 处�：Three 相机�� `up=(0, 1, 0)`，�用内部投影公�抵消 45° 下压导致的 Y 轴压缩；��通过�� `camera.up` 解决上下方�。DOM 角色�蓄力引导��点预测和 Three 平�层必须共用���幕�标。
+- 验�：`npm run test -- src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx src/services/jump-hop/jumpHopRuntimeModel.test.ts` 应覆盖 `JUMP_HOP_THREE_CAMERA_UP_Y=1`，并断言 Three 投影与 DOM �幕�标��。
+- 关�：`src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx`�`src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx`。
+
+## 跳一跳立方体贴图��走�明主体切片
+
+- 现象：水果等主题生��功�，�行�地�看起��薄的纯水果 PNG�果切贴纸��明 cutout；或者�过�六个�都是�一张平铺果皮 / 果肉�质，无法组��方�苹果 / 方�香蕉这类完整主题对象表达。
+- 原因：跳一跳地�已�改为 Three.js 标准 `1x1x1` 等比��倒角立方体�用几何体，�行�视角固定为近�相机和 45° 下压视角；image2 应生� `1024x1536` 的 18 个 cube object UV unwrap，�个大�元内的 top/front/right/back/left/bottom 六��共�包装�一个主题物体。�强调 full-bleed 容易让水果主题退化�果皮�果肉��脉等表�纹�；如果�把一张图贴给六个�，模型也�需��解正�和跨�连续特�。旧切图链路若把洋红 key 转 alpha��边���留最大 alpha 连通主体并补�明安全边，会把整格贴图�新抠�苹果 / 香蕉 / 果切等居中主体，贴到立方体上�四角和侧�都��明。
+- 处�：跳一跳地�图集 prompt 固定�求 `cube object UV unwrap atlas / 立方体主题物体六�展开图集`，一张图�生� 18 个大�元，�个大�元固定 `4列*3行` UV 网：第 1 行第 2 列 top，第 2 行 left/front/right/back，第 3 行第 2 列 bottom；水果主题�明确生�能一眼说出�称的方�苹果�方�香蕉�方�橙��方�西瓜等�识别对象，并�求果柄�片�剥皮�带�放射切��红瓤黑籽等身份特�跨�连续。�止自然圆形水果�自然长�香蕉��方�化完整水果�果切�贴纸�居中�物体��明背景和留白，�时也�止“�纯平铺�质 / 抽象纹� / �铺主题颜色 / 纯果皮�质 / 纯果肉纹� / 纯�脉纹��。�端按 3x6 大�元和 4x3 UV 网切出 108 张 `256x256` ��明�贴图，��调用�明化�最大 alpha 连通主体�留或�明补边。洋红 `#FF00FF` �作为图集安全� / UV 空� / 外圈 key 色，�切�若�有�少残留则转���明�质底色；绿色�白色�雪地�云朵��地�花朵�果肉粉色和浅黄色等主题颜色必须完整�留。
+- 验�：`cargo test -p api-server jump_hop --manifest-path server-rs/Cargo.toml -- --nocapture` 覆盖跳一跳 UV unwrap prompt�18 个大�元�108 张��明�贴图�绿色 / 白色�质�被�明化�洋红 key 残留�作为�明洞；�端 `JumpHopRuntimeShell` 测试覆盖新 UV 资产会解�六张�贴图，旧�贴图资产�� fallback。
 - 关�：`server-rs/crates/platform-image/src/generated_asset_sheets/alpha.rs`�`server-rs/crates/platform-image/src/generated_asset_sheets/sheet.rs`�`server-rs/crates/api-server/src/jump_hop.rs`。
 
 ## �中文 image2 live 验���用 PowerShell 管�喂 Node ��
@@ -2138,3 +2154,12 @@
 - 处�：`api-server` 构造生�结果订阅消�时，`time4` 固定格�化为北京时间 `YYYY-MM-DD HH:mm`；���用 `shared_kernel::format_timestamp_micros`。
 - 验�：`cargo test --manifest-path server-rs\Cargo.toml -p api-server generation_result_template -- --nocapture`；dev 日志中�应�出现 `data.time4.value invalid`。
 - 关�：`server-rs/crates/api-server/src/wechat_subscribe_message.rs`�`docs/�开��维】本地开�验�与生产�维-2026-05-15.md`。
+
+## 待解决：跳一跳生�超时��能��继续�功
+
+- 风险程度：高。
+- 现象：跳一跳生�页�能在 `98% 写入正��稿` �报“请求超时，请���试�，但�端�在继续生�，���把�一 session 写� `DraftCompiled=100`。2026-06-08 排查 `jump-hop-session-6db8fa7af57c4fa2a71e6430cc808412` 时，背景底图 image2 �功但耗时约 `18分25秒`，返回按钮约 `2分44秒`，地�图集约 `1分46秒`，总耗时超过�端 20 分钟等待窗�，最终在�端超时�约 3 分钟写�稿�功。
+- 原因：跳一跳创作链路�把背景�返回按钮�地�图集�切片和 OSS 写入串在一次 HTTP 请求里；VectorEngine image2 �步 timeout/connect 失败会在�端�试，�步耗时�能超过�端总等待窗�。中间资产和真实阶段没有�库，session 在完���显示 `Collecting`�`progress_percent=0`，�端�能按时间显示�进度；超时��试�一 session 时，�端还�能因为 session 没有中间素�而�新从背景开始生�。
+- 待处�：将跳一跳生�改为�端任务化 / �轮询真实阶段进度，按背景�返回按钮�图集�切片��久化�写�稿分阶段�库；统一�端全局生� deadline�VectorEngine �试预算��端等待窗�和失败�回写。超时��次进入�一 session 应优先��正在�行或已完�的任务，�应��生图。
+- 验�：模拟首张 image2 超长耗时或超时�试时，生�页应显示真实阶段和���状�；�端请求超时�应把最终�功�稿标记为失败；刷新 `/creation/jump-hop/generating?sessionId=<id>` �应能��到�端真实状�；�一 session �试�得��生�已完�阶段。
+- 关�：`src/services/jump-hop/jumpHopClient.ts`�`src/services/miniGameDraftGenerationProgress.ts`�`server-rs/crates/api-server/src/jump_hop.rs`�`server-rs/crates/platform-image/src/vector_engine/client.rs`�`docs/�玩法创作】平�入�与玩法链路-2026-05-15.md`。
diff --git a/docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md b/docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md
index 07751c9e..e64d4371 100644
--- a/docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md
+++ b/docs/prd/�玩法创作】跳一跳俯视角玩法模�PRD-2026-05-19.md
@@ -2,15 +2,15 @@
 
 ## 1. 目标
 
-`jump-hop` �定义为竖�俯视角平�跳跃游�。创作者�输入主题，系统生�一张该主题的 `5x5` 地�资�图集，切� 25 个 2D 地�素�；�行�使用抠除白底�的陶泥儿 logo �明 PNG 作为玩家角色，并和这些 2D 地�资产组�无�平��。
+`jump-hop` �定义为竖�俯视角平�跳跃游�。创作者�输入主题，系统生�一张该主题的 `1024x1536` 立方体主题物体 UV 展开图集，按 `3列*6行` 容纳 18 个方�，�个方��按固定 `4列*3行` UV 网切� top/front/right/back/left/bottom 六张�贴图；�行�使用 Three.js �用标准 `1x1x1` 等比��倒角立方体几何体，把六�贴图贴到立方体地�上组�无�平��，�时使用陶泥儿 logo �明 PNG 作为玩家角色。
 
 首版目标：
 
 1. 创作输入��留主题，标题�简介�标签和�示�由系统派生；
-2. image2 �生�一张 `5x5` 地�图集，�端�匀切� 25 张 PNG；
+2. image2 �生�一张 `1024x1536` 地� UV 展开图集，�端切� 18 组�共 108 张�贴图 PNG；
 3. 角色���独生图，v1 使用 `public/branding/jump-hop-taonier-character.png` 陶泥儿 logo �明 PNG；
 4. �行����展示 3 个地�：当�地��目标地��下一预览地�；
-5. �作方�为按��幕��拖动蓄力，�手�角色�拖拽�方�弹出；
+5. �作方�为长按�幕蓄力，�手�角色�下一�地�中心方�弹出；
 6. ���点未命中下一个地�，本局立�失败并冻结计时；
 7. �绩记录�功跳跃次数和游�时长；
 8. 排行榜按作�维度展示玩家 ID��功跳跃次数和游�时长，排�为�功跳跃次数���游�时长���更新时间��。
@@ -21,10 +21,10 @@
 - 展示�：`跳一跳`
 - 工程域：`jump-hop`
 - 创作入��：`subtitle = 主题驱动平�跳跃`，`imageSrc = /creation-type-references/jump-hop.webp`
-- �行�：`DOM 平� / DOM 角色 + Three.js �明扩展层 + DOM HUD`
+- �行�：`Three.js 标准 1x1x1 等比��倒角立方体地� + DOM 角色 + DOM HUD`
 - 画�比例：移动端竖�优先，桌�端居中承载 `9:16`
-- 素�策略：2D 地�图集 + 陶泥儿 logo �明角色
-- 渲染分层：生�地�切片必须由 DOM 平�层直接渲染为图片；角色必须由 DOM �明 PNG 层渲染并��最高层级，Three.js �明画布�作为�续扩展层，�能把地�图片或角色回退为 WebGL ���质
+- 素�策略：18 个立方体主题物体 UV 展开包装 + Three.js �用标准 1x1x1 等比立方体几何 + 陶泥儿 logo �明角色
+- 渲染分层：Three.js 平�层�用一份标准 `1x1x1` 等比��倒角立方体几何体，`tileAssets[]` 切片�作为主题身份方�包装贴图；��立方体必须正轴�摆放，�� Y 轴�航或 Z 轴歪斜旋转，也�得用�� x/y/z scale 压��盒�；�行�视角采用约 `1.3x` 近�相机和 45° 下压视角，当�脚下地�基准�于�幕中线略下方，�续两��上展开且��紧凑的纵� / 横�间�；Three.js 平�层与 DOM 角色层必须���幕 X 轴��，�止通过��相机 `up` 或镜�容器把平�左�翻转；DOM 地�图片层�用于�签�预加载�WebGL ��用和测试 fallback，Three.js 平�层 ready �必须�� DOM 地�图片和 DOM 阴影，退出地���相机推进自然离�，�播放独立飞走动画，超过�幕��销�，��旧地�退出期露出被放大的平� DOM 贴图；角色必须由 DOM �明 PNG 层渲染并��在 Three.js 平�层之上
 
 本玩法�是横版平�跳跃，也�是关�制闯关。平�从�幕下方�上无�延展，目标地�在当�地�上方�� x 轴�置�机出现。
 
@@ -35,12 +35,12 @@
 - �图资产槽�：无独立角色图槽�；v1 固定使用陶泥儿 logo �明 PNG 角色
 - 系列素�槽�：
   - `batchId = jump-hop-tile-atlas`
-  - `sheetSpec = 5x5 / 1:1 / PNG / 纯绿色绿幕背景 / �端切图�明化`
-  - `slotSpecs = tile-01 ... tile-25`，�个 slot 必须对应唯一 OSS path / `assetObjectId`
-  - 切图规则：按原图宽高�分为 5 行 5 列，从上到下�从左到�切出 25 张 PNG；�格�明化���留最大的 alpha 连通主体，��边并补�明安全边，��相邻格越界碎片或方形�边进入 tile
-  - �明化规则：生�时�求绿幕背景，�端上传 OSS �抠��明 PNG，并清�与主体分离的�型残片
+  - `sheetSpec = 1024x1536 / 3列*6行大�元 / �格4列*3行UV网 / PNG / 纯洋红 #FF00FF 安全�与外圈背景 / �端切图为�贴图 PNG`
+  - `slotSpecs = tile-01 ... tile-18`，�个 tile �包� `top/front/right/back/left/bottom` 六个� slot，所有 slot 必须对应唯一 OSS path / `assetObjectId`
+  - 切图规则：先按原图宽高�分为 3 列 6 行，从上到下�从左到�得到 18 个大�元；�个大�元内部固定 4 列 3 行 UV 网，`top` 在第 1 行第 2 列，`left/front/right/back` 在第 2 行第 1-4 列，`bottom` 在第 3 行第 2 列；�个�输出 `256x256` ��明 PNG
+  - �明化规则：生�时�求纯洋红 key 安全�和 UV 空�，�端���明化抠图，�把�切�残留的洋红 key 色转为��明�质底色，�留绿色�白色�雪地�云朵��地�花朵�果肉粉色和浅黄色等主题纹�
   - 失败回写：生�失败时 session �� failed，�从生�页�试
-  - 局部�生�：结果页�许�生�地�图集，��调用一次 image2；�端展示生�图时以 `assetObjectId` 作为刷新键，���一路径�写�的旧签�或旧缓存
+  - 局部�生�：结果页�许�生�地�贴图图集，��调用一次 image2；�端展示生�图时以 `assetObjectId` 作为刷新键，���一路径�写�的旧签�或旧缓存
 - API 命�空间：`/api/creation/jump-hop/*`�`/api/runtime/jump-hop/*`
 - 业务真相：�端�决�点�失败��功跳跃次数�冻结时长和排行榜
 - 创作工具模�例外：无
@@ -55,33 +55,35 @@
 1. 作�标题：主题为空白修剪�的短标题，默认�缀�外露；
 2. 作�简介：基于主题生�一�短简介；
 3. 标签：`跳一跳`�`休闲` 和主题关键�；
-4. 地��示�：围绕主题生� 25 个风格一致的俯视角清爽游�化 2D 平�素�，�一�都是符�主题的�独�跳跃平�；实际 image2 prompt 使用“独立��脚平�素� / 平�裸素� / 完整平��措辞，��把正�主体�述�图标集或游�界�资�；
+4. 地�贴图�示�：围绕主题生� 18 个风格一致的立方体主题物体 UV 展开包装，�个包装由 top/front/right/back/left/bottom 六�组�，供 Three.js 标准 1x1x1 等比��倒角立方体地��用；实际 image2 prompt 使用“立方体主题物体 UV 展开包装图集 / cube object UV unwrap atlas�措辞，�求六�共�表达�一个完整方�化主题物体，例如水果主题�生��一眼辨认的方�苹果�方�香蕉�方�橙��方�西瓜等，而�是�纯生�平铺�质�抽象纹��平��跳��地�����张图��六�或游�界�资�；
 5. �始平���数：固定 v1 标准�数，�让创作者手工调规则。
 
-## 5. 地�图集
+## 5. 地�贴图图集
 
-image2 �生�一张 `1:1` 图片，画�为 `5x5` �匀分布平�裸素�；实际�示�必须先约�“画��包� 25 个独立跳一跳��脚平�素��，并明确�是游�界��棋盘�背包�装备�或图标集页�。
+image2 �生�一张 `1024x1536` 竖版图片，画�为 `3列*6行` �匀分布的立方体主题物体 UV 展开包装；实际�示�必须先约�“画��包� 18 个用于跳一跳地�的立方体主题物体 UV 展开包装图�，并明确这是供 Three.js 标准 1x1x1 等比��倒角立方体使用的 cube object UV unwrap atlas。�个大�元格代表一个完整方�化主题物体，并在固定 `4列*3行` UV 网中�供六张�贴图；�是�纯�质贴片��张图��六��地���图�跳��物体剪影�游�界��棋盘�背包�装备�或图标集页�。
 
 图集�求：
 
-1. �格�放一个完整地�资�；
-2. 资�为纯 2D 平�素�，但�表现为符�主题且有设计感的俯视角清爽游�化立体感平�，有顶��主体内部明暗和清晰轮廓；主题元素必须直接�为平�主体，例如“水果�应生�苹果切片�橙�切片�西瓜���莓����香蕉等水果造型平�；
-3. 25 个地��自�一主题��一光�和�一�质体系；
-4. 背景为纯绿色绿幕，方便�端�明化；
-5. �包�角色�文字�水��UI�游����棋盘�背包�装备��按钮�标题�外层边框�网格线�场景背景��地投影�接触阴影�方形阴影�方形底��白底��底或黑底；
-6. 地��能跨格�贴边或进入相邻格，主体必须居中并�留至少 18% 纯绿色安全留白；�个平�之间�能是纯绿色空白，�画容器框或棋盘格。
+1. �个大�元内部固定使用 `4列*3行` UV 网，�有六个�置有贴图：第 1 行第 2 列是 `top`；第 2 行第 1-4 列�次是 `left / front / right / back`；第 3 行第 2 列是 `bottom`；其它�置��纯洋红 `#FF00FF`；
+2. �个�都是 full-bleed ��明正方形贴图，四角�边缘和中心都�有�识别内容；六个�共�组��一个完整方�化主题物体，�能把�一张纹���六次，也�能六��画互�相关的�图标；
+3. 贴图�生�已�渲染好的�视 3D �体��，�包�摄�机角度�已烘焙侧��已烘焙厚度�自身投影�接触阴影或烘焙高光；真实倒角�侧���视和阴影由�行� Three.js 生�；
+4. 18 个方��自�一主题��一哑光手绘包装体系，但应表达��方�化主题物体或明显��的包装识别特�；水果主题�混排方�苹果�方�香蕉�方�橙��方�西瓜�方��莓�方�葡��方�奇异果�方����方�柠檬�方�桃��方�梨�方��莓�方�芒果�方�椰��方��龙果�方�樱桃�方�哈密瓜�方�石榴，�� 18 个方�都�是�一�果皮�果肉或�脉纹�；
+5. 大�元之间�UV 空��六�之间和画布外圈为纯洋红 `#FF00FF`，方便�端安全切图；
+6. �包�角色�文字�水��UI�游����棋盘�背包�装备��按钮�标题�外层边框���网格线�场景背景��地投影�接触阴影�方形阴影�方形底��白底��底或黑底；
+7. 贴图�能跨格�贴边串色或进入相邻格；�个�贴图应尽�铺满自己的 UV �，纯洋红�作为安全��UV 空�和外圈 key 色。
 
-切片顺�固定为：
+大�元切片顺�固定为：
 
 ```text
-tile-01 tile-02 tile-03 tile-04 tile-05
-tile-06 tile-07 tile-08 tile-09 tile-10
-tile-11 tile-12 tile-13 tile-14 tile-15
-tile-16 tile-17 tile-18 tile-19 tile-20
-tile-21 tile-22 tile-23 tile-24 tile-25
+tile-01 tile-02 tile-03
+tile-04 tile-05 tile-06
+tile-07 tile-08 tile-09
+tile-10 tile-11 tile-12
+tile-13 tile-14 tile-15
+tile-16 tile-17 tile-18
 ```
 
-�行��机使用这 25 个地�作为�续平�外观。起点地���用第一个切片，其余平�从完整池中�机选择。
+�个 `tile-XX` �切出 `top/front/right/back/left/bottom` 六个�贴图并写入 `tileAssets[].faceAssets`。历�兼容字段 `imageSrc/imageObjectKey/assetObjectId` �存 top �，旧作�没有 `faceAssets` 时�行���把�张旧贴图应用到立方体所有�。�行��机使用这 18 个地�作为�续平�外观。起点地���用第一个切片，其余平�从完整池中�机选择。
 
 ## 6. �行�规则
 
@@ -97,23 +99,24 @@ tile-21 tile-22 tile-23 tile-24 tile-25
 
 ### 6.2 �作
 
-1. 用户按�当�地�或画�；
-2. ��拖动形�蓄力��；
-3. �手�角色沿拖拽�方�弹出；
-4. 拖拽�离决定力度，拖拽方�决定�点方�；
-5. 力度和方�都由�端�交给�端�决。
+1. 用户按�当�地�或画�开始蓄力；
+2. 长按时长形�蓄力值，达到 `maxChargeMs` ��顶；
+3. �手�角色�下一�地�中心方�弹出；
+4. 蓄力值决定跳跃�离，跳跃方���手指拖动方�影�；
+5. �端��交蓄力值，�端基于当�地�中心到下一�地�中心的方��决真实�点。
 
-手感�数固定由�端 `module-jump-hop` �供：`chargeToDistanceRatio = 0.008`。该值表示�等世界跳跃�离�需�旧版 `0.004` �置的一��幕拖动�离；旧作��行时若��带 `0.004`，开局归一化为 `0.008`。
+手感�数固定由�端 `module-jump-hop` �供：`chargeToDistanceRatio = 0.004`。该值表示蓄力时长到世界跳跃�离的�算系数；旧作��行时若��带其它系数，开局归一化为 `0.004`。契约中的 `dragDistance` 继续作为兼容字段�留，但当�语义是�端�交的蓄力值；`dragVectorX/dragVectorY` 仅兼容旧客户端，�端�决必须忽略。
 
-�手��端必须立�生� `visualJump`，用当�角色�置作为起点��端预测�点作为终点，播放约 `560ms` 的角色飞行动画；角色从当�地�弹�预测�点，蓄力阶段角色应沿拖拽方�明显拉长，�地����方�回弹两次。动画期间 DOM 地�窗���在本次起跳�的 3 �布局，动画路径�得等待�端新 run。若�端新 run 晚于飞行动画返回，角色必须�在预测�点等待，直到新 run 到达��把显示�切到�端返回的最新 run，并进入约 `1440ms` 的相机推进过渡。推进过渡中，地� DOM 层和 DOM 角色层必须放在�一个相机层里统一�移，��许 p1/p2 �独改 `top/left` �过渡；旧当�地��相机推进自然离开视野，新预览地�从上方自然露出，��角色和地���步或闪现。相机推进必须�时�带 X/Y �移，从旧目标地��置斜�滑到新当�地��焦�置，��许先横�瞬切居中����纵�滑动。地��以�留当� / 目标 / 预览的深度尺寸差异，但该差异必须通过固定基准宽高上的 CSS `transform: scale(...)` 表达，并在相机推进期间用�一 `1440ms` 缓动过渡；�得通过直接改宽高造�瞬切�大。当�地�高亮�得�外通过 CSS `scale` 放大。该动画�属于表现层，命中�失败��功跳跃次数和冻结时长�以�端�决为准。
+�手��端必须立�生� `visualJump`，用当�角色�置作为起点��端预测真实�点作为终点，播放约 `560ms` 的角色飞行动画；视觉预测必须使用当�显示窗�的 current/next 地�作为方���，�使�端最新 run 已��返回，也�能拿新 run 目标�旧窗�角色导致下一跳��；角色从当�地�沿下一�地�中心方�弹�预测真实�点，蓄力阶段角色��垂直压缩，�沿目标方�拉长。�功�地�必须�留 `lastJump.landedX/landedY` 对应的真实�点�移，�得强制�附回目标地�中心；�地��以轻�回弹，但�能把角色�置拉离真实�点。动画期间 DOM 地�窗���在本次起跳�的 3 �布局，动画路径�得等待�端新 run。若�端新 run 晚于飞行动画返回，角色必须�在预测真实�点等待；新 run 到达�应先使用�端真实�点对�显示�，�进入约 `1440ms` 的相机推进过渡，��角色先飞过很远�瞬间拉回地�。推进过渡中，地� DOM 层和 DOM 角色层必须放在�一个相机层里统一�移，��许 p1/p2 �独改 `top/left` �过渡；旧当�地���相机推进�留在�幕�方，��独执行飞走动画，玩家继续��跳时�被新的相机推进自然带出�幕并销�，新预览地�从上方自然露出，��角色和地���步或闪现。相机推进必须�时�带 X/Y �移，从旧真实�点�置斜�滑到新当�地��焦�置，��许先横�瞬切居中����纵�滑动。地��以�留当� / 目标 / 预览的深度尺寸差异，但该差异必须通过固定基准宽高上的 CSS `transform: scale(...)` 表达，并在相机推进期间用�一 `1440ms` 缓动过渡；�得通过直接改宽高造�瞬切�大。当�地�高亮�得�外通过 CSS `scale` 放大。该动画�属于表现层，命中�失败��功跳跃次数和冻结时长�以�端�决为准。
 
 ### 6.3 判定
 
 1. 目标永远是当�地��的下一个地�；
-2. �点进入下一个地��地�径，则�功；
-3. �点未进入下一个地��地�径，则失败；
-4. 失败�状�改为 `failed`，计时冻结；
-5. v1 没有通关状��combo�perfect 或生命数。
+2. 真实�点沿当�地�中心到下一�地�中心方�计算；
+3. �点进入下一个地���顶� footprint，则�功；footprint 使用当�路径里该地� `width/height` 的收缩矩形模拟 45° 视角下的��顶�，当�命中区约为宽度 72% 和高度 52%；
+4. �点未进入下一个地���顶� footprint，则失败；旧 `landingRadius/perfectRadius` 字段仅�留兼容读写，��作为当� v1 �功判定；
+5. 失败�状�改为 `failed`，计时冻结；
+6. v1 没有通关状��combo�perfect 或生命数。
 
 ### 6.4 计分与时间
 
@@ -149,7 +152,7 @@ successfulJumpCount desc -> durationMs asc -> updatedAt asc
 结果页展示：
 
 1. 陶泥儿 logo �明角色预览；
-2. 25 个地�资�池预览；
+2. 18 个地�资�池预览；
 3. 首� 3 �平�预览；
 4. 试玩；
 5. �布；
@@ -183,14 +186,14 @@ successfulJumpCount desc -> durationMs asc -> updatedAt asc
 ## 10. 验收
 
 1. 创作页�显示主题输入；
-2. 生�链路�调用一次地�图集 image2，��调用角色生图；
-3. 地�图集为 `5x5`，�端切出 25 个地� PNG；
+2. 生�链路�调用一次地�贴图图集 image2，��调用角色生图；
+3. 地�贴图图集为 `1024x1536 / 3列*6行 / �格4列*3行UV网`，�端切出 18 组�共 108 张�贴图 PNG；
 4. 结果页��赖旧角色图片槽；
 5. �行�为竖�俯视角，首��� 3 个地���；
-6. 拖拽方�和力度会影��点；
+6. 长按蓄力值影��点�离，跳跃方�固定�下一�地�中心；
 7. 未�到下一个地�立�失败；
 8. �功跳跃次数累加，失败�计时冻结；
 9. 排行榜按�功跳跃次数优先排�；
 10. 作���存��布�分享并从公开入��动。
-11. �行�地�必须显示 `tileAssets[]` 中的生�切片图片；拖拽蓄力�计时刷新和角色�置更新�得销��建�明画布�平�图片层或 DOM 角色层。
-12. �等跳跃�离的拖动�离必须比旧 `0.004` 系数缩短一�，�手�必须先看到角色飞行动画，�看到地�窗��移。
+11. �行� Three.js 地�必须优先把 `tileAssets[].faceAssets` 六�贴图按 right/left/top/bottom/front/back �质顺�贴到标准 `1x1x1` 等比立方体上；旧作�没有 `faceAssets` 时�使用 `tileAssets[].imageSrc` �贴图 fallback。立方体正轴�摆放，�� Y 轴�航或 Z 轴歪斜旋转，�得把 x/y/z 缩放��盒�；相机��近� 45° 下压视角，当�脚下地�基准�于�幕中线略下方，��三�地�之间的�幕间�必须�紧凑；长按蓄力�计时刷新和角色�置更新�得销��建�明画布�平�贴图预加载层或 DOM 角色层。
+12. �等世界�离的蓄力�算必须使用 `0.004` 系数，�手�必须先看到角色飞行动画，�看到地�窗��移；�功�地显示必须�留真实�点�移。
diff --git a/docs/�开��维】本地开�验�与生产�维-2026-05-15.md b/docs/�开��维】本地开�验�与生产�维-2026-05-15.md
index ac61896e..255026f0 100644
--- a/docs/�开��维】本地开�验�与生产�维-2026-05-15.md
+++ b/docs/�开��维】本地开�验�与生产�维-2026-05-15.md
@@ -73,7 +73,7 @@ spacetime sql <database> "SELECT * FROM puzzle_gallery_card_view LIMIT 1" --serv
 
 本地 `.env`�`.env.local` 或 `.env.secrets.local` 修改�必须�� `api-server` �会生效；若已�通过 `npm run dev` �动完整�调，�在该终端输入 `rs api-server`。排查 RPG / 拼图 / 抓大鹅等 VectorEngine 生图链路时，确认 `VECTOR_ENGINE_BASE_URL`�`VECTOR_ENGINE_API_KEY` 和 `VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS` �在本地或�务器密钥文件中�置，�能写入 Git。VectorEngine `gpt-image-2` 图片�议�URL / base64 �应解��远端图片下载和 provider 侧结构化日志在 `server-rs/crates/platform-image`；`api-server` ���置�玩法编排�OSS / asset �久化�计费和失败审计�库。开局 CG 故事��首图�背景和图集都属于长耗时图片请求；�端默认会把 `VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS` 下�收�到 `1000000`，旧进程��能沿用���的短超时。若 VectorEngine 在 `send()` 阶段失败且日志显示 `SendRequest`，先看�一 `request_id` 的 provider 日志字段 `source`�`source_chain`�`source_chain_depth`，�查 `external_api_call_failure.metadata_json.errorSource`；当� multipart `/v1/images/edits` �独强制 HTTP/1.1。拼图关�资产按 `level_scene -> ui_spritesheet -> level_background` 顺�生�，日志会带 `slot`�`asset_kind` 和 `elapsed_ms`。
 
-VectorEngine 图片生� / 编辑在 `request_send` 阶段出现 `timeout` 或 `connect` 错误时，`platform-image` 会对�一请求最多�� 3 次；multipart 图片编辑�次�试都会�新构造 form，���用已消费的 body。日志中 `VectorEngine 图片请求��失败，准备�试` 表示本次失败已进入下一次�试；最终�失败时�会写入 `external_api_call_failure` 并返回 504。排查生产失败时应�时统计 retry �的�试日志和最终 audit，��把一次用户请求内的多次��误判�多个用户请求。
+VectorEngine 图片生� / 编辑在 `request_send` 阶段出现 `timeout`�`connect`�libcurl 35 SSL connect reset�libcurl 56 receive error / `unexpected eof while reading`�recv failure 等临时传输错误，或在 `upstream_status` 阶段收到 408 / 429 / 5xx（例如 Nginx HTML `502 Bad Gateway`）时，`platform-image` 会对�一请求最多�� 5 次；multipart 图片编辑�次�试都会�新构造 form，���用已消费的 body。日志中 `VectorEngine 图片请求��失败，准备�试` 或 `VectorEngine 图片上游状���试，准备�试` 表示本次失败已进入下一次�试；最终�失败时�会写入 `external_api_call_failure` 并返回 504 / 502。排查生产失败时应�时统计 retry �的�试日志和最终 audit，��把一次用户请求内的多次��误判�多个用户请求。
 
 拼图入�直创的 `compile_puzzle_draft` 是长耗时链路：�端会先快速编译�稿并返回 `image_refining` / `generating` 快照，然�在 api-server ��任务中完�首图�UI 资产�OSS �久化�作�投影�计费退款和失败�回写。生产排查�程� `Failed to fetch` 时，若 Nginx access log 里 action POST 是 `499`�`upstream_status=-`，说明客户端或 WebView 先断开；此时�应�把长 POST 是�返回作为生��败��，而应继续按实际 `session_id` 查��任务日志�VectorEngine provider 日志�`external_api_call_failure` 和�续 GET 轮询结果。�一用户�能先轮询旧的 `puzzle-session-*`，�� POST 新建实际生� session；必须用 action POST 的 `request_id` 和 `/api/runtime/puzzle/agent/sessions/<session_id>/actions` 路径对�真实失败请求，��被�端显示的“���稿�误导。
 
diff --git a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
index 31ea9b3d..76e75013 100644
--- a/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
+++ b/docs/�玩法创作】平�入�与玩法链路-2026-05-15.md
@@ -170,21 +170,25 @@ RPG / 拼图等�行�存档�以 `/api/profile/save-archives` 的�端列
 
 1. 创作端��留主题输入，作�标题�简介�标签和地��示�由系统派生；
 2. v1 ���独生�角色图片，�行�固定使用抠除白底�的陶泥儿 logo �明 PNG 作为玩家角色；
-3. 地��调用一次 image2，输出一张 `5行*5列`�`1:1`��一纯洋红 `#FF00FF` key 背景的主题地�图集；跳一跳地�常包��地�花�雪�白石和云朵，�端�明化必须使用跳一跳专用洋红 key，��用近白底扣除，也�清��边缘连通的 key 色�素，��把绿色或白色主体误扣；�处�必须对边缘连通 key 色�容差清��去彩边 defringe 和底部残影清�，主体图�得自带洋红阴影�紫色底边�粉色�边�彩色光晕或�光底边，�行�阴影统一由 DOM 绘制；地�造型�示��求以主题物体本身外轮廓为准，�许苹果近似圆形�香蕉近似长�或长方形�西瓜近似扇形等自然差异，�统一�格规格�安全留白�正�30度视角和 2D/2.5D 手绘风格包装；所有地�素�必须��统一正�30度视角，相机�于物体正�方略高�置�镜头�下约30度，必须看到清晰正��侧��下沿�明显自身厚度和少�上表�，主体正�或侧����积必须接近或大于顶��积，顶��能作为辅助���；水果主题需�明确�求橙瓣看到橙皮正�外侧和果肉厚度�椰�看到壳的正�侧�和切�厚度�浆果�能�是从上往下看的圆形�顶；��生�纯俯视�正上方俯��鸟瞰地图��平铺俯��圆形顶视图或�平图标；主题物体本身必须是唯一��脚体，�能用自身切��边缘厚度�花瓣层或果皮边表现承�，�止在主题物体下方�外垫石��土墩�木��圆��托盘�岛屿底座或通用地�；�端和�端默认 `tilePrompt` 都必须使用“正�30度视角主题物体图集，物体本身作为跳跃�点�的�径，���交“平�素� / 跳� / 地� / 地砖�等会把模型拉回通用平�造型的�，�端生��也会清洗旧�稿�留的这些�；当主题或地��示�命中��梦 / 神奇�� / �袋妖怪 / Pokemon / Pikachu / 精��等��梦相关�时，仅生图请求侧改写为“原创幻想�宠冒险�具 / 彩色冒险能�� / 黄色闪电�宠符��，用户�稿标题和主题展示�改；
+3. 地�贴图�调用一次 image2，输出一张 `1024x1536` 竖版�`3列*6行`��一纯洋红 `#FF00FF` key 安全� / 外圈背景的立方体主题物体 UV 展开图集；image2 �生� 18 个完整 `1x1x1` 立方体主题物体包装，�个大�元格内部固定为 `4列*3行` UV 网：第 1 行第 2 列为 `top`，第 2 行�次为 `left / front / right / back`，第 3 行第 2 列为 `bottom`，其它 UV 空���纯洋红。�个大�元格的六个�必须属于�一个方�化主题物体，top/front/right/back/left/bottom 之间的果皮�切��籽点��纹�果柄��片等身份特��连续一致，�能把�一张纹���六次，也�能六��画互�相关的�图标。水果主题应生� 18 ��一眼辨认的方�水果 UV，例如方�苹果�方�香蕉�方�橙��方�西瓜�方��莓�方�葡��方�奇异果�方����方�柠檬�方�桃��方�梨�方��莓�方�芒果�方�椰��方��龙果�方�樱桃�方�哈密瓜�方�石榴；苹果需�果柄�片跨 top/front，香蕉需�剥皮�带跨 front/right，橙�需�放射切�跨 top/front，西瓜需�红瓤黑籽和绿皮�纹在��连续。�止文字�UI�底座�托盘�圆��地�垫层��地投影�接触阴影�方形阴影�洋红�边�紫色底边�粉色�边�彩色光晕��光边��明背景�留白�自然圆形水果�自然长�香蕉�孤立水果照片��型贴纸�纯果皮�质�纯果肉纹��纯�脉纹�和无法分辨具体物体的抽象纹�；真实�视���倒角�侧�厚度和阴影统一由�行� Three.js 标准 `1x1x1` 等比立方体生�。�端�把洋红 key 作为图集安全边界处�，先按 3x6 大�元格切出 18 个方�，�按�格 4x3 UV 网切出 108 张 `256x256` ��明�贴图，���行�明化抠图�最大 alpha 连通主体�留或�明安全边补白；若�切��残留�少洋红 key 色，会转���明�质底色。�端和�端默认 `tilePrompt` 都必须使用“立方体主题物体 UV 展开包装图集 / cube object UV unwrap atlas�的�径，���交“正�30度主题物体 / 平�素� / 跳� / 地��� / 地砖 / �质贴片 / 平铺纹��等会把模型拉回 2D 地��平�或�纯�质的�，�端生��也会清洗旧�稿�留的这些�；当主题或地��示�命中��梦 / 神奇�� / �袋妖怪 / Pokemon / Pikachu / 精��等��梦相关�时，仅生图请求侧改写为“原创幻想�宠冒险�具 / 彩色冒险能�� / 黄色闪电�宠符��，用户�稿标题和主题展示�改；
 4. 背景底图�样由 image2 生�，�用现有 `coverComposite` / `coverImageSrc` 作为�行�背景读写字段，OSS 槽�固定为 `background/image.png`；�示�必须严格以用户主题关键�为背景主题，结构以左�两侧氛围为主，中央纵轴 1/2 区域��少元素�简���读且有纵深感，两侧�许更强立体层次和行进感；背景�作为底图，�止生�跳��地���脚物�角色�UI�返回按钮�文字�路径箭头或海报排版；左上角返回按钮��许画进背景，而是�独生� `backButtonAsset` �明 PNG，OSS 槽�固定为 `back-button/image.png`，�示��求标准圆形�主题色�质包装�居中左箭头�纯绿色 key 背景，�端去绿�写入作� profile；
-5. �端按从上到下�从左到��匀切分为 `tile-01` 到 `tile-25` 的�明 PNG，�个切片必须使用唯一 slot/path �久化，�能按��的 `tileType` �用槽�；
-6. 结果页�展示陶泥儿 logo �明角色预览�地�池预览和首� 3 地�预览；���供旧角色图生�槽；
-7. �端跳一跳创作 client 的创建会�与执行生�动作请求都必须使用 20 分钟等待窗�，��背景底图�地�图集�切片�抠图和 OSS 写入�在�端执行时被共创会�默认 15 秒超时中断。
+5. �端按从上到下�从左到��匀切分为 `tile-01` 到 `tile-18`，�个方���久化 `tile-XX-top/front/right/back/left/bottom` 六个独立 slot/path，�能按��的 `tileType` �用槽�；`tileAssets[].faceAssets` �存六�贴图，历�兼容字段 `imageSrc/imageObjectKey/assetObjectId` 写 top �作为旧�贴图 fallback，�行�对旧作�没有 `faceAssets` 时��把�张贴图应用到立方体所有�；
+6. 结果页�展示陶泥儿 logo �明角色预览�地�池预览和首� 3 地�预览；���供旧角色图生�槽；移动端结果页必须由结果页根容器承接纵�滚动并�留底部安全区，确�素�预览较长时�能下滑到返回编辑�试玩和�布按钮；
+7. �端跳一跳创作 client 的创建会�与执行生�动作请求都必须使用 20 分钟等待窗�，��背景底图�返回按钮去绿�地�贴图图集切片和 OSS 写入�在�端执行时被共创会�默认 15 秒超时中断。
 
-�行�规则真相必须沉到 `module-jump-hop`，�端��拖拽蓄力�角色�移�投影和�地�馈。失败��功跳跃次数�游�时长冻结��行�快照和�布作�状�以�端为准。v1 ��留公开 combo / perfect / 通关语义，旧 `score` 兼容映射为�功跳跃次数。公开列表应走 `jump_hop_gallery_card_view` 订阅缓存，���次 HTTP 请求调用 procedure 组装全�列表。
+待解决问题（风险程度：高）：跳一跳创作链路目��是一次 HTTP 请求内串行生�背景底图�返回按钮�地�贴图图集�切片和 OSS 写入；VectorEngine image2 �步 timeout/connect 失败会在�端最多�试 5 次，而�端�有 20 分钟总等待窗�。若�次背景底图生�接近或超过 18 分钟，�端会先报“请求超时，请���试�，但�端�能继续跑完并在数分钟�写入�稿；�时因为背景�返回按钮和图集等中间资产未按阶段�库，�一 session 超时��试会�新从背景图开始生�，存在��生图���计费�用户误以为失败�作�架状�短时间�一致的风险。�续应将跳一跳生�改为�端任务化 / �轮询真实阶段进度，并在�个素�阶段�功�写入���状�；�时收��端全局生� deadline��端等待策略和失败�回写，确�超时��试和最终�功�会互相打架。
+
+生�页“当�跳一跳信���展示实际�与创作�示�的主题�地��示�等用户��解信�；`stylePreset` 等未�与当� image2 �示�组装的内部风格枚举�得作为兜底内容展示，��把 `minimal-blocks`�`paper-toy` 等工程值暴露给创作者。
+
+�行�规则真相必须沉到 `module-jump-hop`，�端��长按蓄力�角色�移�投影和�地�馈。失败��功跳跃次数�游�时长冻结��行�快照和�布作�状�以�端为准。v1 ��留公开 combo / perfect / 通关语义，旧 `score` 兼容映射为�功跳跃次数。公开列表应走 `jump_hop_gallery_card_view` 订阅缓存，���次 HTTP 请求调用 procedure 组装全�列表。
 
 ���展示 3 个地�：当�地��目标地�和下一预览地�。平��按�一 seed 无�生�，�端�得自行生�正�路径。�行� HUD 顶部��留返回按钮和�功跳跃次数，�展示计时器或�上角�开按钮；生�背景和游�舞�必须覆盖整个�行�视�，HUD 直接�对定�压在背景上，��用外层白底�居中窄���片边框或游�区域圆角�切背景。返回按钮固定在左上角安全区，交互热区固定为移动端 `56px`�桌�约 `62px`，�显示“返回�文字，并通过顶部锚点微调与得分标题牌���调；�行�优先使用独立 `backButtonAsset` �明 PNG 作为真实�点击按钮图，旧作�缺失该字段时�使用�尺寸 CSS 主题色圆形按钮兜底。上方�功跳跃次数 UI �用拼图模�顶部 HUD 结构：`puzzle-runtime-header-card` 内包�陶泥儿 IP logo�居中的“得分�标题牌，以�下挂 `puzzle-runtime-timer-card / puzzle-runtime-timer` 居中数字�；数字�展示�功跳跃次数而�是倒计时。游玩中�显示左下角“进行中�状�，也�在�幕底部常驻排行榜。排行榜按作�维度展示玩家 ID��功跳跃次数和游�时长；��玩家��留 1 �最佳记录，排�固定为 `�功跳跃次数 desc -> 游�时长 asc -> 更新时间 asc`，并�在失败结算弹窗内展示，弹窗�留�开和返回动作。
 
-�行�渲染分层固定为：舞�底层 `.jump-hop-runtime__scene-backdrop` 优先使用 `coverComposite` / `coverImageSrc` 中的 image2 背景底图，图片读�继续走平�资产�签，没有背景时�回退到内置��；DOM 平�层直接使用 `tileAssets[]` 的生�切片图片显示地�，图片读�继续走平�资产�签，并以 `assetObjectId` 作为刷新键���生��沿用旧签�或旧图片缓存；�个地�下方的统一软椭圆阴影�自�行� DOM 的 `.jump-hop-runtime__platform-shadow`，�是 image2 地�切片的必需内容，调整阴影优先改�行� CSS；有真实地�图片 URL 时�得在加载空档显示 fallback 原型地�，下一�预览地�必须在进入相机视野���预加载；DOM 角色层固定使用 `public/branding/jump-hop-taonier-character.png` 陶泥儿 logo �明 PNG 并��最高层级；Three.js �明画布仅作为�续扩展层。拖拽蓄力�计时刷新和角色�置�化�能更新 refs 或 DOM 状�，�得销��建�明画布�背景或平�图片层，�则会造�背景�地�和角色层频闪。
+�行�渲染分层固定为：舞�底层 `.jump-hop-runtime__scene-backdrop` 优先使用 `coverComposite` / `coverImageSrc` 中的 image2 背景底图，图片读�继续走平�资产�签，没有背景时�回退到内置��；Three.js 平�层�用�一份标准 `1x1x1` 等比��倒角立方体几何体，�按�一 side 等比缩放当� / 目标 / 预览地�，并把 `tileAssets[]` 的生�切片作为主题身份方�包装贴图加载到立方体表�；��地���正轴�摆放，�� Y 轴�航或 Z 轴歪斜旋转；�行�采用约 `1.3x` 近�相机�45° 下压视角和更紧凑的��地�间�，当�脚下地�基准�于�幕中线略下方，目标和预览地��上展开，侧��倒角��视和软椭圆阴影�由 Three.js 统一表现；Three.js 相机和 DOM 角色层必须���幕 X 轴��，�得通过�� `camera.up` 或镜� wrapper 把平�层左�翻转，�则会出现地�显示在�侧但蓄力与飞行动画�左侧的��错觉；DOM 地�图片层�作为资产�签�预加载�WebGL ��用和测试环境 fallback，Three.js 平�层 ready �必须�� DOM 地�图片和 DOM 阴影，��露出旧原型方�或�层闪现；推进期存在旧地�退出�留时，Three 平�层必须继续承接 3D 地�渲染，旧地��跟��续相机推进�步离�，�播放独立飞走动画，超过�幕�自然销�；图片读�继续走平�资产�签，并以 `assetObjectId` 作为刷新键���生��沿用旧签�或旧图片缓存。DOM 角色层固定使用 `public/branding/jump-hop-taonier-character.png` 陶泥儿 logo �明 PNG 并��在 Three.js 平�层之上。长按蓄力�计时刷新和角色�置�化�能更新 refs 或 DOM 状�，�得销��建�明画布�背景�平�贴图预加载层或 DOM 角色层，�则会造�背景�地�和角色层频闪。
 
-跳一跳当�拖拽手感统一采用 `chargeToDistanceRatio=0.008`，用于把�等跳跃�离所需拖拽�离缩短到旧 `0.004` 的一�；如果历�路径��存旧系数，`start_run` 会在开局归一化到新系数。拖拽中�显示弹弓拉线，�显示�点辅助点�投影圈或其它命中�示。�手��行�必须立�生� `visualJump`，用当�角色�置作为起点��端预测�点作为终点，播放约 `560ms` 的角色飞行动画：蓄力时角色沿拖拽方�明显拉长，角色弹�预测�点，�地���方�回弹两次；动画路径�得等待�端新 run。若�端新 run 晚于飞行动画返回，角色必须�在预测�点等待，直到新 run 到达��把显示�切到�端最新 run，并用约 `1440ms` 的相机层推进过渡承接新窗�。推进时地� DOM 层和 DOM 角色层统一包在�一个 camera layer 下移动，旧当�地�自然离开视野，新预览地�从上方露出，�止用 p1/p2 �自 `top/left` 过渡造�角色和地���步。相机层推进必须�时使用 X/Y �移，从旧目标地��置斜�滑到新当�地��焦�置，�得先横�瞬切到居中�纵�滑动。地��许�留当� / 目标 / 预览的深度尺寸差异，但该差异必须通过固定基准宽高上的 `transform: scale(...)` 缓动呈现，并与相机推进使用�一 `1440ms` 节�；��直接修改宽高造�瞬切，也���给当���外� CSS scale。相机推进期间角色自身必须�用 `left/top` transition，��许父级 camera layer 负责�移，�则角色局部�标切�和相机推进会�加，表现为�地��从�幕外闪回。
+跳一跳当�长按蓄力手感统一采用 `chargeToDistanceRatio=0.004`，用于把长按时长�算�世界跳跃�离；如果历�路径��存其它系数，`start_run` 会在开局归一化到新系数。用户按�画�开始蓄力，�手立�起跳；跳跃��永远由当�地�中心指�下一�地�中心，�端���交拖拽方�，�端�使收到旧客户端的 `dragVectorX/dragVectorY` 也必须忽略。实际�点�由蓄力时长�算出的跳跃�离决定，�功判定使用下一�地���顶� footprint：�端以该地� `width/height` 的收缩矩形模拟 45° 视角下的��顶�，当�命中区约为宽度 72% 和高度 52%，�点进入该视觉顶�则�功，未进入则失败；旧 `landingRadius/perfectRadius` ��留兼容读写，��作为当�命中真相。蓄力中角色��垂直压缩，�沿目标方�拉伸；蓄力�馈�显示��下一�中心的轻�引导，但�显示�点辅助点�投影圈或其它命中�示。�手��行�必须立�生� `visualJump`，用当�角色�置作为起点��端预测真实�点作为终点，播放约 `560ms` 的角色飞行动画：视觉预测必须使用当�显示窗�的 current/next 地�作为方���，�使�端最新 run 已��返回，也�能拿新 run 目标�旧窗�角色导致下一跳��；角色沿当�地�中心到下一�地�中心方�弹�预测真实�点，�功也�得强制�附回目标地�中心。若�端新 run 晚于飞行动画返回，角色必须�在预测真实�点等待；新 run 到达�应优先用 `lastJump.landedX/landedY` 映射出的真实�点显示角色，�把显示�切到�端最新 run，并用约 `1440ms` 的相机层推进过渡承接新窗�，��先飞过很远�瞬间拉回地�造�闪现。推进时地� DOM 层和 DOM 角色层统一包在�一个 camera layer 下移动，旧当�地���相机推进�留在�幕�方，��独执行�上 / �下飞走动画；玩家继续��跳时，旧地�继续被新的相机推进带离视�，超过离�阈值�自然销�，新预览地�从上方露出，�止用 p1/p2 �自 `top/left` 过渡造�角色和地���步。相机层推进必须�时使用 X/Y �移，从旧真实�点�置斜�滑到新当�地��焦�置，�得先横�瞬切到居中�纵�滑动。地��许�留当� / 目标 / 预览的深度尺寸差异，但该差异必须通过固定基准宽高上的 `transform: scale(...)` 缓动呈现，并与相机推进使用�一 `1440ms` 节�；��直接修改宽高造�瞬切，也���给当���外� CSS scale。相机推进期间角色自身必须�用 `left/top` transition，��许父级 camera layer 负责�移，�则角色局部�标切�和相机推进会�加，表现为�地��从�幕外闪回。
 
-平�首页推��精选�最新�公开详情��索�已玩作�和公开试玩统一按 `sourceType='jump-hop'` 与 `JH-*` 公开作��识别跳一跳作�；从公开详情或推���动�行�时，若�片摘��足以�带地�图集和路径�置，必须先补读完整 work profile �传入�行�。平�壳层必须�步注册 `jump-hop-workspace`�`jump-hop-generating`�`jump-hop-result`�`jump-hop-runtime`�`jump-hop-gallery-detail` 阶段，并在 `appPageRoutes.ts` 映射 `/creation/jump-hop/workspace`�`/creation/jump-hop/generating`�`/creation/jump-hop/result`�`/gallery/jump-hop/detail`�`/runtime/jump-hop`，�时�有 session�work�run�gallery�busy/error 与生�进度状�，����入渲染分支但��状��或分享路径导致 typecheck 失败�刷新回首页。
+平�首页推��精选�最新�公开详情��索�已玩作�和公开试玩统一按 `sourceType='jump-hop'` 与 `JH-*` 公开作��识别跳一跳作�；从公开详情或推���动�行�时，若�片摘��足以�带地�贴图图集和路径�置，必须先补读完整 work profile �传入�行�。`/runtime/jump-hop?work=JH-*` 这类正�深链必须先通过公开作��回读 gallery detail，�以 profileId �动 published run；直接打开没有 `work` �数的 `/runtime/jump-hop` 时�能�留在空�行�或“正在加载内容�，应回到平�首页。平�壳层必须�步注册 `jump-hop-workspace`�`jump-hop-generating`�`jump-hop-result`�`jump-hop-runtime`�`jump-hop-gallery-detail` 阶段，并在 `appPageRoutes.ts` 映射 `/creation/jump-hop`�`/creation/jump-hop/generating`�`/creation/jump-hop/result`�`/gallery/jump-hop/detail`�`/runtime/jump-hop`，�时�有 session�work�run�gallery�busy/error 与生�进度状�，����入渲染分支但��状��或分享路径导致 typecheck 失败�刷新回首页。
 
 跳一跳作�架走创作中心的统一作�列表：�端通过 `/api/creation/jump-hop/works` 拉�作�摘�，�稿�会与 pending notice �并�显示在作�架里，已�布作�点击�会先按 profileId 读�完整详情�进入详情或�行�。生�中作��以�端摘�里的 `generationStatus` 为准，刷新�应能��等待�罩，�能��赖内存 notice。
 
diff --git a/packages/shared/src/contracts/jumpHop.ts b/packages/shared/src/contracts/jumpHop.ts
index 8b2621e1..9379baa0 100644
--- a/packages/shared/src/contracts/jumpHop.ts
+++ b/packages/shared/src/contracts/jumpHop.ts
@@ -96,6 +96,37 @@ export interface JumpHopTileAsset {
   visualHeight: number;
   topSurfaceRadius: number;
   landingRadius: number;
+  faceAssets?: JumpHopTileFaceAssets | null;
+}
+
+export type JumpHopTileFaceKey =
+  | 'top'
+  | 'front'
+  | 'right'
+  | 'back'
+  | 'left'
+  | 'bottom';
+
+export interface JumpHopTileFaceAsset {
+  face: JumpHopTileFaceKey;
+  assetId: string;
+  imageSrc: string;
+  imageObjectKey: string;
+  assetObjectId: string;
+  generationProvider: string;
+  prompt: string;
+  width: number;
+  height: number;
+  sourceAtlasCell: string;
+}
+
+export interface JumpHopTileFaceAssets {
+  top: JumpHopTileFaceAsset;
+  front: JumpHopTileFaceAsset;
+  right: JumpHopTileFaceAsset;
+  back: JumpHopTileFaceAsset;
+  left: JumpHopTileFaceAsset;
+  bottom: JumpHopTileFaceAsset;
 }
 
 export interface JumpHopScoring {
diff --git a/server-rs/crates/api-server/src/jump_hop.rs b/server-rs/crates/api-server/src/jump_hop.rs
index f76aa730..015a510e 100644
--- a/server-rs/crates/api-server/src/jump_hop.rs
+++ b/server-rs/crates/api-server/src/jump_hop.rs
@@ -15,23 +15,20 @@ use shared_contracts::jump_hop::{
     JumpHopGalleryDetailResponse, JumpHopGenerationStatus, JumpHopJumpRequest, JumpHopJumpResponse,
     JumpHopLeaderboardEntry, JumpHopLeaderboardResponse, JumpHopRestartRunRequest,
     JumpHopRunResponse, JumpHopSessionResponse, JumpHopSessionSnapshotResponse,
-    JumpHopStartRunRequest, JumpHopTileAsset, JumpHopTileType, JumpHopWorkDetailResponse,
-    JumpHopWorkMutationResponse, JumpHopWorksResponse, JumpHopWorkspaceCreateRequest,
+    JumpHopStartRunRequest, JumpHopTileAsset, JumpHopTileFaceAsset, JumpHopTileFaceAssets,
+    JumpHopTileFaceKey, JumpHopTileType, JumpHopWorkDetailResponse, JumpHopWorkMutationResponse,
+    JumpHopWorksResponse, JumpHopWorkspaceCreateRequest,
 };
 use shared_kernel::{build_prefixed_uuid_id, format_timestamp_micros};
 use spacetime_client::SpacetimeClientError;
 use std::{
-    collections::{BTreeMap, VecDeque},
+    collections::BTreeMap,
     time::{SystemTime, UNIX_EPOCH},
 };
 
 use crate::{
     api_response::json_success_body,
     auth::{AuthenticatedAccessToken, RuntimePrincipal},
-    generated_asset_sheets::{
-        GeneratedAssetSheetAlphaOptions, apply_generated_asset_sheet_alpha_with_options,
-        crop_generated_asset_sheet_view_edge_matte_with_options,
-    },
     generated_image_assets::{
         GeneratedImageAssetAdapter, GeneratedImageAssetDataUrl,
         adapter::{GeneratedImageAssetAdapterMetadata, GeneratedImageAssetPersistInput},
@@ -51,7 +48,7 @@ use crate::{
     work_play_tracking::{WorkPlayTrackingDraft, record_work_play_start_after_success},
 };
 
-const JUMP_HOP_TILE_ITEM_COUNT: usize = 25;
+const JUMP_HOP_TILE_ITEM_COUNT: usize = 18;
 
 const JUMP_HOP_PROVIDER: &str = "jump-hop";
 const JUMP_HOP_CREATION_PROVIDER: &str = "jump-hop-creation";
@@ -59,9 +56,15 @@ const JUMP_HOP_RUNTIME_PROVIDER: &str = "jump-hop-runtime";
 const JUMP_HOP_TEMPLATE_ID: &str = "jump-hop";
 const JUMP_HOP_TEMPLATE_NAME: &str = "跳一跳";
 const JUMP_HOP_RUNTIME_RUNS_ROUTE: &str = "/api/runtime/jump-hop/runs";
-const JUMP_HOP_TILE_ATLAS_ROWS: u32 = 5;
-const JUMP_HOP_TILE_ATLAS_COLS: u32 = 5;
+const JUMP_HOP_TILE_ATLAS_ROWS: u32 = 6;
+const JUMP_HOP_TILE_ATLAS_COLS: u32 = 3;
+const JUMP_HOP_TILE_UV_FACE_ROWS: u32 = 3;
+const JUMP_HOP_TILE_UV_FACE_COLS: u32 = 4;
 const JUMP_HOP_TILE_ATLAS_KEY_HEX: &str = "#FF00FF";
+const JUMP_HOP_TILE_ATLAS_IMAGE_SIZE: &str = "1024*1536";
+const JUMP_HOP_TILE_ATLAS_IMAGE_WIDTH: u32 = 1024;
+const JUMP_HOP_TILE_ATLAS_IMAGE_HEIGHT: u32 = 1536;
+const JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE: u32 = 256;
 const JUMP_HOP_BACKGROUND_IMAGE_SIZE: &str = "1024*1536";
 const JUMP_HOP_BACKGROUND_IMAGE_WIDTH: u32 = 1024;
 const JUMP_HOP_BACKGROUND_IMAGE_HEIGHT: u32 = 1536;
@@ -73,9 +76,26 @@ const JUMP_HOP_BACK_BUTTON_IMAGE_HEIGHT: u32 = 1024;
 struct JumpHopTileAtlasSlice {
     tile_type: JumpHopTileType,
     source_atlas_cell: String,
+    faces: JumpHopTileFaceSlices,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct JumpHopTileFaceSlice {
+    face: JumpHopTileFaceKey,
+    source_atlas_cell: String,
     bytes: Vec<u8>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct JumpHopTileFaceSlices {
+    top: JumpHopTileFaceSlice,
+    front: JumpHopTileFaceSlice,
+    right: JumpHopTileFaceSlice,
+    back: JumpHopTileFaceSlice,
+    left: JumpHopTileFaceSlice,
+    bottom: JumpHopTileFaceSlice,
+}
+
 pub async fn create_jump_hop_session(
     State(state): State<AppState>,
     Extension(request_context): Extension<RequestContext>,
@@ -720,10 +740,10 @@ async fn maybe_generate_jump_hop_assets(
             &settings,
             sheet_prompt.as_str(),
             Some(build_jump_hop_tile_atlas_negative_prompt()),
-            "1024*1024",
+            JUMP_HOP_TILE_ATLAS_IMAGE_SIZE,
             1,
             &[],
-            "跳一跳地�图集生�失败",
+            "跳一跳地�贴图图集生�失败",
         )
         .await
         .map_err(|error| {
@@ -735,7 +755,7 @@ async fn maybe_generate_jump_hop_assets(
                 JUMP_HOP_CREATION_PROVIDER,
                 AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                     "provider": "vector-engine",
-                    "message": "跳一跳地�图集生��功但未返回图片。",
+                    "message": "跳一跳地�贴图图集生��功但未返回图片。",
                 })),
             )
         })?;
@@ -750,8 +770,8 @@ async fn maybe_generate_jump_hop_assets(
             tile_prompt.as_str(),
             tile_image,
             LegacyAssetPrefix::JumpHopAssets,
-            1024,
-            1024,
+            JUMP_HOP_TILE_ATLAS_IMAGE_WIDTH,
+            JUMP_HOP_TILE_ATLAS_IMAGE_HEIGHT,
             request_context,
         )
         .await?;
@@ -836,7 +856,7 @@ fn replace_jump_hop_pokemon_prompt_terms(value: &str) -> String {
         return value;
     }
 
-    // 中文注释：仅对��梦相关��生�侧脱�，��地�图集触�上游安全拦截。
+    // 中文注释：仅对��梦相关��生�侧脱�，��贴图图集触�上游安全拦截。
     const POKEMON_REPLACEMENTS: [(&str, &str); 15] = [
         ("��梦", "原创幻想�宠冒险�具"),
         ("神奇��", "原创幻想�宠冒险�具"),
@@ -896,12 +916,12 @@ fn build_jump_hop_tile_atlas_prompt(theme_text: &str, tile_prompt: &str) -> Stri
     };
 
     format!(
-        "生�一张1:1图片，主题为“{theme_text}�。\n画��包�25个独立的跳跃�点主题物体，按五行五列�匀摆放在纯洋红抠图画布上；��画�游�界��棋盘�背包�装备�或图标集页�。\n视觉方�为正�30度视角的跳跃游�素�，画�内容是{subject_text}。所有�点素�都必须��统一的正�30度视角：相机�于物体正�方略高�置，镜头�下约30度，能看到清晰正��侧��下沿和少�上表�。\n构图验收标准：主体正�或侧����积必须接近或大于顶��积，顶��能作为辅助���；��让顶���主�视觉，��画�纯俯视�正上方俯��鸟瞰地图��平铺俯��圆形顶视图或�平图标。\n水果主题尤其���俯�：橙瓣必须看到橙皮正�外侧和果肉厚度，椰�必须看到壳的正�侧�和切�厚度，浆果�能�是一个从上往下看的圆形�顶。\n�一个�点都必须直接使用主题物体或���散物体�主体造型，主题�一眼��；例如主题为水果时，�以是苹果切片�橙瓣�西瓜���莓�����香蕉�葡�串等水果物体，苹果�近似圆，香蕉�近似长�或长方形，西瓜�近似扇形，造型以物体本身外轮廓为准。\n主题物体本身就是唯一��脚体：雪花�点就是一枚带厚度的雪花，�日葵�点就是一朵带厚度的�日葵，水果�点就是水果切片或水果本体；��在主题物体下��垫任何石头�土��木��圆��底盘�托盘�岛屿�花盆�地��或通用承托物。\n�画主题物体裸素�，�画外层���棋盘底座����UI按钮�标题�文字�角标�装饰边框�工具��装备��图标��角色或游�界�。\n整体风格为清爽自然的休闲手游主题物体素�，�2D/2.5D手绘质感，哑光�质，干净色�，轻微主体内部明暗，��写实摄影�油亮高光�塑料感�暗黑幻想风和厚�CG渲染。\n�个�点都是符�主题且有设计感的立体感物体，有清晰轮廓和明显自身厚度；��把��主题物体强行改造�统一地砖�统一按钮或统一抽象图标。\n造型规则完全由物体本身决定：�许圆形�长��弧形�三角�扇形��状���状�多件组��轻微夸张和一定程度�散；�在�一2D/2.5D手绘风格�正�30度视角��质包装�清晰轮廓��格规格和安全留白上��一致。\n25个�点应尽�选择��主题物体或相关�散物体，差异主��自物体�类和原生轮廓，�使用固定形状脚本；相邻格�以形状相似，��物体��且主题清楚。\n�许用主题物体自身的切��边缘厚度�花瓣层�果皮边�雪花厚边或云朵体积表现��脚感；�止�外支撑层�承托底座�脚下地��下方石��下方土墩�下方圆盘�下方托盘或“物体摆在平�上�的画法。\n�个�点必须居中，视觉尺寸���格56%-64%，四周至少�留18%纯洋红安全留白；任何�片�装饰�轮廓和光影都�得贴边�跨格或越界。\n�个�点��留主体内部明暗�外轮廓和自身厚度，�绘制�地投影�接触阴影�方形阴影�洋红阴影�紫色底边�彩色光晕��光底边�底��白底��底�黑底或背景色�，�行�会统一添加阴影。\n25个�点�一�质体系��一光�和�一正�30度视角，但物体类别�外轮廓和细节有�化；�个�点之间�能是纯洋红空白，�画分隔线�网格线�容器框或棋盘格。\n整张画布背景�格间空白和�格背景都必须是�一纯洋红 {JUMP_HOP_TILE_ATLAS_KEY_HEX}，背景平整无纹��无���无阴影�无黑底；主体�许使用绿色�白色�雪地�云朵��地和花朵，但主体自身�得使用接近 {JUMP_HOP_TILE_ATLAS_KEY_HEX} 的洋红色，主体边缘�得出现洋红色�边�紫色�边�粉色�边或彩色阴影。\n�止跨格�贴边�越界�文字�水��UI�边框�网格线�角色�场景�游����图标集页��物体下方�外底座或物体摆在地�上。\nEnglish guardrail: isolated front-facing 30-degree camera-pitch theme-object assets only, camera slightly above the object and looking down about 30 degrees from the front; every object must show a clear front face, side wall, lower rim, object thickness, and only a small top surface; visible front/side area must be close to or larger than the top area; never produce top-down, overhead, bird's-eye, flat icon, round top-view disk assets; the theme object itself is the only landing object, each object's native silhouette decides the shape, no extra base under the object, no pedestal, no plinth, no floor slab, no colored shadow or magenta fringe around objects, consistent 2D/2.5D style wrapper, solid magenta chroma key background {JUMP_HOP_TILE_ATLAS_KEY_HEX}, no text, no poster, no UI screen, no inventory icons."
+        "生�一张1024x1536竖版图片，主题为“{theme_text}�。\n画��包�18个用于跳一跳地�的立方体主题物体 UV 展开包装图，按三列六行�匀排布；�个大�元格代表一个完整的 1x1x1 立方体方�物体，�行�会把该�元内的六张�贴图精确贴到 Three.js 标准��倒角立方体的六个�上。\n画�内容是{subject_text}。这是一张 cube object UV unwrap atlas / 立方体主题物体六�展开图集，�是�纯平铺�质��是抽象纹���是�把主题颜色铺满，也�是已�渲染好的 3D 方����游�界�或图标集页�。\n�个大�元格内部必须使用固定 4列x3行 UV 展开结构，�有以下六个�置有贴图，其它�置��纯洋红安全色：第1行第2列是 top；第2行第1列是 left；第2行第2列是 front；第2行第3列是 right；第2行第4列是 back；第3行第2列是 bottom。��改�顺�，��旋转�，��把六个�画�一张连续�视图。\n�个方�都必须表现为“一个完整主题物体被塑造� 1x1x1 立方体�的六�包装�，六个��属于�一个物体并能组��完整方�造型；top/front/right/back/left/bottom 之间的颜色�边缘纹��切��果皮�籽点��纹�果柄和�片必须连续一致，�能六��画互�相关的图案，也�能把�一张纹���六次。\n水果主题�生�18��一眼辨认的方�水果 UV：方�苹果�方�香蕉�方�橙��方�西瓜�方��莓�方�葡��方�奇异果�方����方�柠檬�方�桃��方�梨�方��莓�方�芒果�方�椰��方��龙果�方�樱桃�方�哈密瓜�方�石榴等；苹果需�果柄�片跨 top/front，香蕉需�剥皮�带跨 front/right，橙�需�放射切�跨 top/front，西瓜需�红瓤黑籽和绿皮�纹在��连续。���画��果皮纹���机斑点��脉纹�或抽象�质。\n�个�都是满版��明正方形贴图 / full-bleed opaque square face texture：四角�边缘和中心都�有�识别内容，�留�明��留空白��留实底背景；�许大�积水果切��果柄�片�剥皮�带�籽点��纹和轮廓图案作为包装身份锚点，但��把一个�水果���片��石头或�物体放在�中央，也��画�贴纸��图标�徽章或孤立主体。\n这�是�视渲染图：��画摄�机视角��视��已烘焙侧��已烘焙厚度�自身投影�接触阴影或高光光斑；真实�视�倒角�侧�和阴影会由�行� Three.js 统一生�。�个�贴图在�行�会以约45度下压视角和较�尺寸显示，所以必须使用大色��高对比�粗线�和简�图形，��在64x64缩略图里�能分辨主题物体身份。\n排布必须安全：18个大�元格必须完整�在自己的三列六行网格内，�能跨格�贴边串色或进入相邻方�；大�元之间�UV 空��六�之间和画布最外圈�能使用�一纯洋红 {JUMP_HOP_TILE_ATLAS_KEY_HEX} 作为切图安全色，�许�细纯洋红安全�，但��画��网格线�边框�编��face label 或�切标记。\n贴图内部�以使用绿色�白色�雪地�云朵��地�花朵�果肉粉色和浅黄色等主题颜色，但�得使用接近 {JUMP_HOP_TILE_ATLAS_KEY_HEX} 的纯洋红色；贴图边缘�得有洋红�边�紫色底边�粉色�边�彩色光晕或�光边。\n�止文字�Logo�水��UI按钮�标题�角标�装饰边框�face label�top/front/right/back/left/bottom文字�背包�装备�����角色�完整场景�自然圆形水果�自然长�香蕉��方�化完整水果�孤立水果照片��型果切贴纸��型橙片贴纸��贴纸图标��物体居中�纯果皮�质�纯果肉纹��纯�脉纹��纯颜色���明背景�留白�3D平��圆��底座�托盘�物体摆在平�上��视地��正�30度物体图�鸟瞰地图���地投影�接触阴影�方形阴影�白底��底�黑底。\nEnglish guardrail: one vertical 1024x1536 image, exactly 18 cube object UV unwraps in a 3 columns by 6 rows atlas; each large cell is one complete cube object skin with a fixed 4x3 UV net: row1 col2 top, row2 col1 left, row2 col2 front, row2 col3 right, row2 col4 back, row3 col2 bottom; empty UV cells and gutters are solid magenta {JUMP_HOP_TILE_ATLAS_KEY_HEX}; generate six different face textures that stitch into one recognizable cubified theme object, not one repeated texture and not unrelated icons; fruit theme must create 18 distinct cubified fruits with continuous identity marks across faces; no text labels, no perspective cube render, no baked lighting, no baked shadows, no pedestal, no floor slab, no small centered stickers, no generic flat material; every face is full-bleed opaque square texture and remains recognizable at 64x64 in a 45-degree game camera."
     )
 }
 
 fn build_jump_hop_tile_atlas_negative_prompt() -> &'static str {
-    "文字�Logo�水��UI按钮�UI 字�游�界��棋盘�背包�装备��图标集页��外层������工具��低清晰度�畸形肢体�多余角色��切主体�写实摄影�油亮高光�塑料质感�暗黑幻想风�厚�CG渲染�海报�UI图标��标题�说明文字�装饰边框�纯俯视角�正上方视角�鸟瞰视角�平铺俯��顶��主画���看顶��圆形顶视图��平图标��地投影�接触阴影�方形阴影�洋红阴影�紫色底边�粉色�边�洋红色�边�彩色光晕��光底边�方形底���外底座�承托底座��座�石��土墩�木�底座�圆��底盘�托盘�岛屿底座�花盆底座�地���脚下地��物体摆在平�上�物体下方垫地��白底��底�黑底�暗色背景�背景色��贴边�跨格�越界"
+    "文字�Logo�水��UI按钮�UI 字�游�界��棋盘�背包�装备��图标集页��外层������工具��低清晰度�畸形肢体�多余角色��切主体�写实摄影�油亮高光�塑料质感�暗黑幻想风�厚�CG渲染�海报�UI图标��标题�说明文字�装饰边框��纯平铺�质�抽象纹���机斑点��铺主题颜色�纯果皮�质�纯果肉纹��纯�脉纹��无法分辨具体物体�自然圆形水果�自然长�香蕉��方�化完整水果�孤立水果照片�果切�贴纸�橙片�贴纸��水果居中�苹果�贴纸�香蕉�贴纸��贴纸图标��物体居中��明背景�留白�3D平��跳����地����物体剪影�正�30度物体图�纯俯视地图��鸟瞰地图���视地��已�画好的侧��已�画好的厚度�烘焙高光�烘焙阴影��地投影�接触阴影�方形阴影�洋红阴影�紫色底边�粉色�边�洋红色�边�彩色光晕��光底边�方形底���外底座�承托底座��座�石��土墩�木�底座�圆��底盘�托盘�岛屿底座�花盆底座�地���脚下地��物体摆在平�上�物体下方垫地��白底��底�黑底�暗色背景�背景色��贴边�跨格�越界���网格线�编���切标记"
 }
 
 fn sanitize_jump_hop_tile_prompt(tile_prompt: &str) -> String {
@@ -911,32 +931,41 @@ fn sanitize_jump_hop_tile_prompt(tile_prompt: &str) -> String {
     }
     value = replace_jump_hop_pokemon_prompt_terms(value.as_str());
 
-    const REPLACEMENTS: [(&str, &str); 18] = [
-        ("俯视角", "正�30度视角"),
-        ("正上方视角", "正�30度视角"),
-        ("鸟瞰视角", "正�30度视角"),
-        ("平铺俯�", "正�30度视角"),
-        ("��脚平�素�", "跳跃�点主题物体"),
-        ("清爽游�化立体感平�素�", "清爽游�化立体感主题物体"),
-        ("平�裸素�", "主题物体裸素�"),
-        ("�格一个完整平�", "�格一个完整主题物体"),
-        ("平�素�", "主题物体"),
-        ("��脚平�", "跳跃�点"),
-        ("��脚", "�点"),
-        ("平�", "主题物体"),
-        ("跳�", "�点"),
-        ("地�", "主题物体"),
-        ("地砖", "主题物体"),
+    const REPLACEMENTS: [(&str, &str); 24] = [
+        ("正�30度视角主题物体图集", "3D立方体主题身份方�包装图集"),
+        ("物体本身作为跳跃�点", "主题物体方�化�作为立方体包装"),
+        ("3D立方体主题方�包装图集", "3D立方体主题身份方�包装图集"),
+        ("立方体主题方�包装图集", "立方体主题身份方�包装图集"),
+        ("俯视角", "正交平�"),
+        ("正上方视角", "正交平�"),
+        ("鸟瞰视角", "正交平�"),
+        ("平铺俯�", "正交平�"),
+        ("��脚平�素�", "立方体主题身份方�包装贴图"),
+        (
+            "清爽游�化立体感平�素�",
+            "清爽游�化立方体主题身份方�包装贴图",
+        ),
+        ("平�裸素�", "立方体主题身份方�包装贴图"),
+        ("�格一个完整平�", "�格一张完整身份方�包装贴图"),
+        ("主题物体图集", "立方体主题身份方�包装图集"),
+        ("主题物体", "主题身份方�包装"),
+        ("平�素�", "立方体身份方�包装贴图"),
+        ("��脚平�", "立方体主题身份方�包装"),
+        ("��脚", "�贴图"),
+        ("平�", "立方体地�"),
+        ("跳�", "立方体地�"),
+        ("地�", "身份方�包装贴图"),
+        ("地砖", "身份方�包装贴图"),
         ("底座", "承托物"),
         ("底盘", "承托物"),
-        ("地�", "承托物"),
+        ("地�", "立方体地�"),
     ];
 
     for (from, to) in REPLACEMENTS {
         value = value.replace(from, to);
     }
-    while value.contains("正�30度视角正�30度视角") {
-        value = value.replace("正�30度视角正�30度视角", "正�30度视角");
+    while value.contains("立方体立方体") {
+        value = value.replace("立方体立方体", "立方体");
     }
 
     value
@@ -945,14 +974,14 @@ fn sanitize_jump_hop_tile_prompt(tile_prompt: &str) -> String {
 fn slice_jump_hop_tile_atlas(
     image: &crate::openai_image_generation::DownloadedOpenAiImage,
 ) -> Result<Vec<JumpHopTileAtlasSlice>, AppError> {
-    let source = image::load_from_memory(image.bytes.as_slice()).map_err(|error| {
-        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
-            "provider": JUMP_HOP_CREATION_PROVIDER,
-            "message": format!("跳一跳地�图集解�失败：{error}"),
-        }))
-    })?;
-    let alpha_options = GeneratedAssetSheetAlphaOptions::jump_hop_magenta_screen();
-    let source = apply_generated_asset_sheet_alpha_with_options(source, alpha_options);
+    let source = image::load_from_memory(image.bytes.as_slice())
+        .map_err(|error| {
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": JUMP_HOP_CREATION_PROVIDER,
+                "message": format!("跳一跳地�贴图图集解�失败：{error}"),
+            }))
+        })?
+        .to_rgba8();
     let width = source.width();
     let height = source.height();
     let cell_width = width / JUMP_HOP_TILE_ATLAS_COLS;
@@ -961,7 +990,7 @@ fn slice_jump_hop_tile_atlas(
         return Err(
             AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                 "provider": JUMP_HOP_CREATION_PROVIDER,
-                "message": "跳一跳地�图集尺寸过�，无法切割。",
+                "message": "跳一跳地�贴图图集尺寸过�，无法切割。",
             })),
         );
     }
@@ -974,133 +1003,187 @@ fn slice_jump_hop_tile_atlas(
         let x1 = (col.saturating_add(1)).saturating_mul(width) / JUMP_HOP_TILE_ATLAS_COLS;
         let y0 = row.saturating_mul(height) / JUMP_HOP_TILE_ATLAS_ROWS;
         let y1 = (row.saturating_add(1)).saturating_mul(height) / JUMP_HOP_TILE_ATLAS_ROWS;
-        let cropped = source.crop_imm(
+        let tile_width = x1.saturating_sub(x0).max(1);
+        let tile_height = y1.saturating_sub(y0).max(1);
+        let faces = slice_jump_hop_tile_uv_faces(
+            &source,
             x0,
             y0,
-            x1.saturating_sub(x0).max(1),
-            y1.saturating_sub(y0).max(1),
-        );
-        let cleaned =
-            crop_generated_asset_sheet_view_edge_matte_with_options(cropped, alpha_options);
-        let cleaned = keep_jump_hop_largest_alpha_component(cleaned);
-        let cleaned =
-            crop_generated_asset_sheet_view_edge_matte_with_options(cleaned, alpha_options);
-        let cleaned = pad_jump_hop_tile_slice_image(cleaned);
-        let mut cursor = std::io::Cursor::new(Vec::new());
-        cleaned
-            .write_to(&mut cursor, image::ImageFormat::Png)
-            .map_err(|error| {
-                AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
-                    "provider": JUMP_HOP_CREATION_PROVIDER,
-                    "message": format!("跳一跳地�图集切割失败：{error}"),
-                }))
-            })?;
+            tile_width,
+            tile_height,
+            row,
+            col,
+        )?;
         slices.push(JumpHopTileAtlasSlice {
             tile_type: jump_hop_tile_type_by_index(index),
             source_atlas_cell: format!("row-{}-col-{}", row + 1, col + 1),
-            bytes: cursor.into_inner(),
+            faces,
         });
     }
 
     Ok(slices)
 }
 
-fn pad_jump_hop_tile_slice_image(image: image::DynamicImage) -> image::DynamicImage {
-    let source = image.to_rgba8();
-    let (width, height) = source.dimensions();
-    if width == 0 || height == 0 {
-        return image::DynamicImage::ImageRgba8(source);
-    }
+fn slice_jump_hop_tile_uv_faces(
+    source: &image::RgbaImage,
+    tile_x: u32,
+    tile_y: u32,
+    tile_width: u32,
+    tile_height: u32,
+    atlas_row: u32,
+    atlas_col: u32,
+) -> Result<JumpHopTileFaceSlices, AppError> {
+    let face_side = (tile_width / JUMP_HOP_TILE_UV_FACE_COLS)
+        .min(tile_height / JUMP_HOP_TILE_UV_FACE_ROWS)
+        .max(1);
+    let uv_width = face_side.saturating_mul(JUMP_HOP_TILE_UV_FACE_COLS);
+    let uv_height = face_side.saturating_mul(JUMP_HOP_TILE_UV_FACE_ROWS);
+    let uv_x = tile_x.saturating_add(tile_width.saturating_sub(uv_width) / 2);
+    let uv_y = tile_y.saturating_add(tile_height.saturating_sub(uv_height) / 2);
 
-    // 中文注释：生图�尔会让主体贴近�元格边缘；切片入库�补�明安全边，
-    // ���行�缩放或滤镜让主体看起�被�掉。
-    let pad_x = (width / 12).clamp(8, 24);
-    let pad_y = (height / 12).clamp(8, 24);
-    let mut padded = image::RgbaImage::from_pixel(
-        width.saturating_add(pad_x.saturating_mul(2)),
-        height.saturating_add(pad_y.saturating_mul(2)),
-        image::Rgba([0, 0, 0, 0]),
-    );
-    image::imageops::overlay(&mut padded, &source, pad_x.into(), pad_y.into());
-    image::DynamicImage::ImageRgba8(padded)
+    Ok(JumpHopTileFaceSlices {
+        top: slice_jump_hop_tile_uv_face(
+            source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Top, 1, 0,
+        )?,
+        front: slice_jump_hop_tile_uv_face(
+            source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Front, 1, 1,
+        )?,
+        right: slice_jump_hop_tile_uv_face(
+            source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Right, 2, 1,
+        )?,
+        back: slice_jump_hop_tile_uv_face(
+            source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Back, 3, 1,
+        )?,
+        left: slice_jump_hop_tile_uv_face(
+            source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Left, 0, 1,
+        )?,
+        bottom: slice_jump_hop_tile_uv_face(
+            source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Bottom, 1, 2,
+        )?,
+    })
 }
 
-fn keep_jump_hop_largest_alpha_component(image: image::DynamicImage) -> image::DynamicImage {
-    let mut source = image.to_rgba8();
-    let (width, height) = source.dimensions();
-    if width == 0 || height == 0 {
-        return image::DynamicImage::ImageRgba8(source);
+#[allow(clippy::too_many_arguments)]
+fn slice_jump_hop_tile_uv_face(
+    source: &image::RgbaImage,
+    uv_x: u32,
+    uv_y: u32,
+    face_side: u32,
+    atlas_row: u32,
+    atlas_col: u32,
+    face: JumpHopTileFaceKey,
+    face_col: u32,
+    face_row: u32,
+) -> Result<JumpHopTileFaceSlice, AppError> {
+    let cleaned = crop_jump_hop_tile_texture_cell(
+        source,
+        uv_x.saturating_add(face_col.saturating_mul(face_side)),
+        uv_y.saturating_add(face_row.saturating_mul(face_side)),
+        face_side,
+        face_side,
+    );
+    let mut cursor = std::io::Cursor::new(Vec::new());
+    cleaned
+        .write_to(&mut cursor, image::ImageFormat::Png)
+        .map_err(|error| {
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": JUMP_HOP_CREATION_PROVIDER,
+                "message": format!("跳一跳地� UV �贴图切割失败：{error}"),
+            }))
+        })?;
+    let face_label = jump_hop_tile_face_key_label(&face);
+
+    Ok(JumpHopTileFaceSlice {
+        face,
+        source_atlas_cell: format!(
+            "row-{}-col-{}/{}",
+            atlas_row + 1,
+            atlas_col + 1,
+            face_label
+        ),
+        bytes: cursor.into_inner(),
+    })
+}
+
+fn crop_jump_hop_tile_texture_cell(
+    source: &image::RgbaImage,
+    x0: u32,
+    y0: u32,
+    width: u32,
+    height: u32,
+) -> image::DynamicImage {
+    let min_side = width.min(height).max(1);
+    let safe_inset = (min_side / 32).clamp(2, 12);
+    let inset_x = safe_inset.min(width.saturating_sub(1) / 2);
+    let inset_y = safe_inset.min(height.saturating_sub(1) / 2);
+    let crop_width = width.saturating_sub(inset_x.saturating_mul(2)).max(1);
+    let crop_height = height.saturating_sub(inset_y.saturating_mul(2)).max(1);
+    let cropped = image::imageops::crop_imm(
+        source,
+        x0.saturating_add(inset_x),
+        y0.saturating_add(inset_y),
+        crop_width,
+        crop_height,
+    )
+    .to_image();
+    let mut resized = image::imageops::resize(
+        &cropped,
+        JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
+        JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
+        image::imageops::FilterType::Lanczos3,
+    );
+    normalize_jump_hop_tile_texture_pixels(&mut resized);
+    image::DynamicImage::ImageRgba8(resized)
+}
+
+fn normalize_jump_hop_tile_texture_pixels(image: &mut image::RgbaImage) {
+    let fallback = average_jump_hop_tile_texture_color(image);
+    for pixel in image.pixels_mut() {
+        if is_jump_hop_tile_texture_key_pixel(*pixel) {
+            *pixel = fallback;
+        }
+        pixel.0[3] = 255;
     }
+}
 
-    // 中文注释：模型�尔会让相邻格的�片�果梗或阴影越界进当�格；
-    // �格��留最大的 alpha 连通主体，能去掉这些�碎片�入库。
-    let width_usize = width as usize;
-    let height_usize = height as usize;
-    let pixel_count = width_usize.saturating_mul(height_usize);
-    let mut visited = vec![false; pixel_count];
-    let mut best_component = Vec::<usize>::new();
+fn average_jump_hop_tile_texture_color(image: &image::RgbaImage) -> image::Rgba<u8> {
+    let mut total_r = 0u64;
+    let mut total_g = 0u64;
+    let mut total_b = 0u64;
+    let mut count = 0u64;
 
-    for start in 0..pixel_count {
-        if visited[start] || source.as_raw()[start * 4 + 3] <= 16 {
-            visited[start] = true;
+    for pixel in image.pixels() {
+        if is_jump_hop_tile_texture_key_pixel(*pixel) {
             continue;
         }
-
-        let mut queue = VecDeque::from([start]);
-        let mut component = Vec::<usize>::new();
-        visited[start] = true;
-
-        while let Some(index) = queue.pop_front() {
-            component.push(index);
-            let x = index % width_usize;
-            let y = index / width_usize;
-
-            for offset_y in -1i32..=1 {
-                for offset_x in -1i32..=1 {
-                    if offset_x == 0 && offset_y == 0 {
-                        continue;
-                    }
-                    let next_x = x as i32 + offset_x;
-                    let next_y = y as i32 + offset_y;
-                    if next_x < 0 || next_x >= width as i32 || next_y < 0 || next_y >= height as i32
-                    {
-                        continue;
-                    }
-                    let next = next_y as usize * width_usize + next_x as usize;
-                    if visited[next] {
-                        continue;
-                    }
-                    visited[next] = true;
-                    if source.as_raw()[next * 4 + 3] > 16 {
-                        queue.push_back(next);
-                    }
-                }
-            }
-        }
-
-        if component.len() > best_component.len() {
-            best_component = component;
-        }
+        total_r += pixel.0[0] as u64;
+        total_g += pixel.0[1] as u64;
+        total_b += pixel.0[2] as u64;
+        count += 1;
     }
 
-    if best_component.is_empty() {
-        return image::DynamicImage::ImageRgba8(source);
+    if count == 0 {
+        return image::Rgba([148, 163, 184, 255]);
     }
 
-    let mut keep = vec![false; pixel_count];
-    for index in best_component {
-        keep[index] = true;
-    }
-    for index in 0..pixel_count {
-        if keep[index] {
-            continue;
-        }
-        let pixel =
-            source.get_pixel_mut((index % width_usize) as u32, (index / width_usize) as u32);
-        pixel.0[3] = 0;
-    }
+    image::Rgba([
+        (total_r / count) as u8,
+        (total_g / count) as u8,
+        (total_b / count) as u8,
+        255,
+    ])
+}
 
-    image::DynamicImage::ImageRgba8(source)
+fn is_jump_hop_tile_texture_key_pixel(pixel: image::Rgba<u8>) -> bool {
+    let [red, green, blue, _] = pixel.0;
+    let red_delta = red.abs_diff(255) as u32;
+    let green_delta = green as u32;
+    let blue_delta = blue.abs_diff(255) as u32;
+
+    red_delta.saturating_mul(red_delta)
+        + green_delta.saturating_mul(green_delta)
+        + blue_delta.saturating_mul(blue_delta)
+        <= 24u32.saturating_mul(24)
 }
 
 fn jump_hop_tile_type_by_index(index: usize) -> JumpHopTileType {
@@ -1117,6 +1200,25 @@ fn jump_hop_tile_asset_slot_name(tile_index: usize) -> String {
     format!("tile-{:02}", tile_index + 1)
 }
 
+fn jump_hop_tile_face_key_label(face: &JumpHopTileFaceKey) -> &'static str {
+    match face {
+        JumpHopTileFaceKey::Top => "top",
+        JumpHopTileFaceKey::Front => "front",
+        JumpHopTileFaceKey::Right => "right",
+        JumpHopTileFaceKey::Back => "back",
+        JumpHopTileFaceKey::Left => "left",
+        JumpHopTileFaceKey::Bottom => "bottom",
+    }
+}
+
+fn jump_hop_tile_face_asset_slot_name(tile_index: usize, face: &JumpHopTileFaceKey) -> String {
+    format!(
+        "{}-{}",
+        jump_hop_tile_asset_slot_name(tile_index),
+        jump_hop_tile_face_key_label(face)
+    )
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn persist_jump_hop_tile_asset(
     state: &AppState,
@@ -1127,8 +1229,97 @@ async fn persist_jump_hop_tile_asset(
     request_context: &RequestContext,
 ) -> Result<JumpHopTileAsset, Response> {
     let slot = jump_hop_tile_asset_slot_name(tile_index);
+    let top = persist_jump_hop_tile_face_asset(
+        state,
+        owner_user_id,
+        profile_id,
+        tile_index,
+        tile_slice.faces.top,
+        request_context,
+    )
+    .await?;
+    let front = persist_jump_hop_tile_face_asset(
+        state,
+        owner_user_id,
+        profile_id,
+        tile_index,
+        tile_slice.faces.front,
+        request_context,
+    )
+    .await?;
+    let right = persist_jump_hop_tile_face_asset(
+        state,
+        owner_user_id,
+        profile_id,
+        tile_index,
+        tile_slice.faces.right,
+        request_context,
+    )
+    .await?;
+    let back = persist_jump_hop_tile_face_asset(
+        state,
+        owner_user_id,
+        profile_id,
+        tile_index,
+        tile_slice.faces.back,
+        request_context,
+    )
+    .await?;
+    let left = persist_jump_hop_tile_face_asset(
+        state,
+        owner_user_id,
+        profile_id,
+        tile_index,
+        tile_slice.faces.left,
+        request_context,
+    )
+    .await?;
+    let bottom = persist_jump_hop_tile_face_asset(
+        state,
+        owner_user_id,
+        profile_id,
+        tile_index,
+        tile_slice.faces.bottom,
+        request_context,
+    )
+    .await?;
+    let primary = top.clone();
+
+    Ok(JumpHopTileAsset {
+        tile_type: tile_slice.tile_type,
+        tile_id: Some(slot),
+        image_src: primary.image_src.clone(),
+        image_object_key: primary.image_object_key.clone(),
+        asset_object_id: primary.asset_object_id.clone(),
+        source_atlas_cell: tile_slice.source_atlas_cell,
+        atlas_row: Some((tile_index as u32 / JUMP_HOP_TILE_ATLAS_COLS) + 1),
+        atlas_col: Some((tile_index as u32 % JUMP_HOP_TILE_ATLAS_COLS) + 1),
+        visual_width: JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
+        visual_height: JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
+        top_surface_radius: 42.0,
+        landing_radius: 34.0,
+        face_assets: Some(JumpHopTileFaceAssets {
+            top,
+            front,
+            right,
+            back,
+            left,
+            bottom,
+        }),
+    })
+}
+
+async fn persist_jump_hop_tile_face_asset(
+    state: &AppState,
+    owner_user_id: &str,
+    profile_id: &str,
+    tile_index: usize,
+    face_slice: JumpHopTileFaceSlice,
+    request_context: &RequestContext,
+) -> Result<JumpHopTileFaceAsset, Response> {
+    let slot = jump_hop_tile_face_asset_slot_name(tile_index, &face_slice.face);
     let image = crate::openai_image_generation::DownloadedOpenAiImage {
-        bytes: tile_slice.bytes,
+        bytes: face_slice.bytes,
         mime_type: "image/png".to_string(),
         extension: "png".to_string(),
     };
@@ -1138,31 +1329,29 @@ async fn persist_jump_hop_tile_asset(
         profile_id,
         slot.as_str(),
         &format!(
-            "跳一跳地�切片 {}：{}",
+            "跳一跳地� UV �贴图 {}：{}",
             tile_index + 1,
-            tile_slice.source_atlas_cell
+            face_slice.source_atlas_cell
         ),
         image,
         LegacyAssetPrefix::JumpHopAssets,
-        256,
-        192,
+        JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
+        JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
         request_context,
     )
     .await?;
 
-    Ok(JumpHopTileAsset {
-        tile_type: tile_slice.tile_type,
-        tile_id: Some(slot),
+    Ok(JumpHopTileFaceAsset {
+        face: face_slice.face,
+        asset_id: persisted.asset_id,
         image_src: persisted.image_src,
         image_object_key: persisted.image_object_key,
         asset_object_id: persisted.asset_object_id,
-        source_atlas_cell: tile_slice.source_atlas_cell,
-        atlas_row: Some((tile_index as u32 / JUMP_HOP_TILE_ATLAS_COLS) + 1),
-        atlas_col: Some((tile_index as u32 % JUMP_HOP_TILE_ATLAS_COLS) + 1),
-        visual_width: 256,
-        visual_height: 192,
-        top_surface_radius: 42.0,
-        landing_radius: 34.0,
+        generation_provider: persisted.generation_provider,
+        prompt: persisted.prompt,
+        width: persisted.width,
+        height: persisted.height,
+        source_atlas_cell: face_slice.source_atlas_cell,
     })
 }
 
@@ -1432,7 +1621,7 @@ fn build_jump_hop_draft(payload: &JumpHopWorkspaceCreateRequest) -> JumpHopDraft
         character_prompt: clean_or_default(&payload.character_prompt, "内置默认 3D 角色"),
         tile_prompt: clean_or_default(
             &payload.tile_prompt,
-            &format!("{theme_text}主题的正�30度视角主题物体图集，物体本身作为跳跃�点"),
+            &format!("{theme_text}主题的3D立方体主题身份方�包装图集"),
         ),
         end_mood_prompt: payload
             .end_mood_prompt
@@ -1631,68 +1820,80 @@ mod tests {
     }
 
     #[test]
-    fn jump_hop_tile_atlas_prompt_uses_dedicated_five_by_five_floor_layout() {
+    fn jump_hop_tile_atlas_prompt_uses_dedicated_uv_unwrap_floor_layout() {
         let prompt = build_jump_hop_tile_atlas_prompt("森林冒险", "森林主题清爽游�化立体感平�");
 
-        assert!(prompt.contains("五行五列"));
-        assert!(prompt.contains("25个独立"));
-        assert!(prompt.contains("跳跃�点主题物体"));
-        assert!(prompt.contains("��画�游�界�"));
-        assert!(prompt.contains("视觉方�为正�30度视角"));
-        assert!(prompt.contains("所有�点素�都必须��统一的正�30度视角"));
-        assert!(prompt.contains("相机�于物体正�方略高�置"));
-        assert!(prompt.contains("镜头�下约30度"));
-        assert!(prompt.contains("能看到清晰正��侧��下沿和少�上表�"));
-        assert!(prompt.contains("主体正�或侧����积必须接近或大于顶��积"));
-        assert!(prompt.contains("顶��能作为辅助���"));
-        assert!(prompt.contains("��让顶���主�视觉"));
-        assert!(prompt.contains("��画�纯俯视�正上方俯��鸟瞰地图�"));
-        assert!(prompt.contains("水果主题尤其���俯�"));
-        assert!(prompt.contains("橙瓣必须看到橙皮正�外侧和果肉厚度"));
-        assert!(prompt.contains("浆果�能�是一个从上往下看的圆形�顶"));
-        assert!(prompt.contains("主题�一眼��"));
-        assert!(prompt.contains("�个�点都是符�主题且有设计感的立体感物体"));
-        assert!(prompt.contains("清爽自然的休闲手游主题物体素�"));
-        assert!(prompt.contains("符�主题且有设计感的立体感物体"));
-        assert!(prompt.contains("�一个�点都必须直接使用主题物体或���散物体"));
-        assert!(prompt.contains("苹果�近似圆"));
-        assert!(prompt.contains("香蕉�近似长�或长方形"));
-        assert!(prompt.contains("主题物体本身就是唯一��脚体"));
-        assert!(prompt.contains("雪花�点就是一枚带厚度的雪花"));
-        assert!(prompt.contains("��在主题物体下��垫任何石头�土��木�"));
-        assert!(prompt.contains("造型规则完全由物体本身决定"));
-        assert!(prompt.contains("�许圆形�长��弧形�三角�扇形��状"));
-        assert!(prompt.contains("�在�一2D/2.5D手绘风格"));
-        assert!(prompt.contains("�一正�30度视角"));
-        assert!(prompt.contains("�使用固定形状脚本"));
-        assert!(prompt.contains("�许用主题物体自身的切��边缘厚度"));
-        assert!(prompt.contains("�止�外支撑层�承托底座�脚下地�"));
-        assert!(prompt.contains("四周至少�留18%纯洋红安全留白"));
+        assert!(prompt.contains("生�一张1024x1536竖版图片"));
+        assert!(prompt.contains("18个用于跳一跳地�的立方体主题物体 UV 展开包装图"));
+        assert!(prompt.contains("按三列六行�匀排布"));
+        assert!(prompt.contains("�个大�元格代表一个完整的 1x1x1 立方体方�物体"));
+        assert!(prompt.contains("该�元内的六张�贴图精确贴到 Three.js 标准��倒角立方体的六个�上"));
+        assert!(prompt.contains("cube object UV unwrap atlas / 立方体主题物体六�展开图集"));
+        assert!(prompt.contains("�是�纯平铺�质��是抽象纹���是�把主题颜色铺满"));
+        assert!(prompt.contains("游�界�或图标集页�"));
+        assert!(prompt.contains("固定 4列x3行 UV 展开结构"));
+        assert!(prompt.contains("第1行第2列是 top"));
+        assert!(prompt.contains("第2行第1列是 left"));
+        assert!(prompt.contains("第2行第2列是 front"));
+        assert!(prompt.contains("第2行第3列是 right"));
+        assert!(prompt.contains("第2行第4列是 back"));
+        assert!(prompt.contains("第3行第2列是 bottom"));
+        assert!(prompt.contains("��改�顺�，��旋转�"));
+        assert!(prompt.contains("六个��属于�一个物体并能组��完整方�造型"));
+        assert!(prompt.contains("�能六��画互�相关的图案，也�能把�一张纹���六次"));
+        assert!(prompt.contains("水果主题�生�18��一眼辨认的方�水果 UV"));
+        assert!(prompt.contains("方�苹果�方�香蕉�方�橙��方�西瓜"));
+        assert!(prompt.contains("苹果需�果柄�片跨 top/front"));
+        assert!(prompt.contains("香蕉需�剥皮�带跨 front/right"));
+        assert!(prompt.contains("西瓜需�红瓤黑籽和绿皮�纹在��连续"));
+        assert!(prompt.contains("���画��果皮纹���机斑点��脉纹�或抽象�质"));
+        assert!(prompt.contains("full-bleed opaque square face texture"));
+        assert!(prompt.contains("四角�边缘和中心都�有�识别内容"));
+        assert!(prompt.contains("�留�明��留空白��留实底背景"));
+        assert!(prompt.contains("�许大�积水果切��果柄�片�剥皮�带�籽点��纹和轮廓图案作为包装身份锚点"));
+        assert!(prompt.contains("��把一个�水果���片��石头或�物体放在�中央"));
+        assert!(prompt.contains("这�是�视渲染图"));
+        assert!(prompt.contains("��画摄�机视角��视��已烘焙侧�"));
+        assert!(prompt.contains("真实�视�倒角�侧�和阴影会由�行� Three.js 统一生�"));
+        assert!(prompt.contains("64x64缩略图里�能分辨主题物体身份"));
+        assert!(prompt.contains("18个大�元格必须完整�在自己的三列六行网格内"));
+        assert!(prompt.contains("大�元之间�UV 空��六�之间和画布最外圈�能使用�一纯洋红"));
         assert!(prompt.contains(JUMP_HOP_TILE_ATLAS_KEY_HEX));
-        assert!(prompt.contains("主体�许使用绿色�白色�雪地�云朵��地和花朵"));
-        assert!(prompt.contains("�绘制�地投影"));
-        assert!(prompt.contains("�绘制�地投影�接触阴影�方形阴影�洋红阴影"));
-        assert!(prompt.contains("紫色底边�彩色光晕��光底边"));
-        assert!(prompt.contains("�画分隔线�网格线�容器框或棋盘格"));
-        assert!(prompt.contains("主体边缘�得出现洋红色�边�紫色�边�粉色�边或彩色阴影"));
-        assert!(prompt.contains("English guardrail"));
-        assert!(prompt.contains("front-facing 30-degree camera-pitch"));
-        assert!(prompt.contains("camera slightly above the object"));
         assert!(
-            prompt.contains("visible front/side area must be close to or larger than the top area")
+            prompt.contains("贴图内部�以使用绿色�白色�雪地�云朵��地�花朵�果肉粉色和浅黄色")
         );
-        assert!(prompt.contains("never produce top-down"));
-        assert!(prompt.contains("each object's native silhouette decides the shape"));
-        assert!(prompt.contains("no extra base under the object"));
+        assert!(prompt.contains("�得使用接近"));
+        assert!(prompt.contains("贴图边缘�得有洋红�边�紫色底边�粉色�边"));
+        assert!(prompt.contains("自然圆形水果�自然长�香蕉��方�化完整水果"));
+        assert!(prompt.contains("�贴纸图标��物体居中�纯果皮�质�纯果肉纹�"));
+        assert!(prompt.contains("English guardrail"));
+        assert!(prompt.contains("one vertical 1024x1536 image"));
+        assert!(prompt.contains("exactly 18 cube object UV unwraps in a 3 columns by 6 rows atlas"));
+        assert!(prompt.contains("row1 col2 top"));
+        assert!(prompt.contains("row2 col1 left"));
+        assert!(prompt.contains("row2 col2 front"));
+        assert!(prompt.contains("row2 col3 right"));
+        assert!(prompt.contains("row2 col4 back"));
+        assert!(prompt.contains("row3 col2 bottom"));
+        assert!(prompt.contains("six different face textures that stitch into one recognizable cubified theme object"));
+        assert!(prompt.contains("no generic flat material"));
+        assert!(prompt.contains("no small centered stickers"));
+        assert!(prompt.contains("every face is full-bleed opaque square texture"));
+        assert!(prompt.contains("no perspective cube render"));
+        assert!(prompt.contains("no baked shadows"));
         assert!(prompt.contains("no pedestal"));
         assert!(prompt.contains("no floor slab"));
-        assert!(prompt.contains("no colored shadow or magenta fringe around objects"));
+        assert!(prompt.contains("empty UV cells and gutters are solid magenta"));
         assert!(!prompt.contains("��脚平�素�"));
         assert!(!prompt.contains("平�裸素�"));
         assert!(!prompt.contains("�格一个完整平�"));
         assert!(!prompt.contains("25个平�"));
-        assert!(!prompt.contains("platform, each"));
-        assert!(!prompt.contains("only platform"));
+        assert!(!prompt.contains("跳跃�点主题物体"));
+        assert!(!prompt.contains("正�30度视角"));
+        assert!(!prompt.contains("五行五列"));
+        assert!(!prompt.contains("25张用于跳一跳地�"));
+        assert!(!prompt.contains("25 full-bleed"));
+        assert!(!prompt.contains("one square 5x5"));
         assert!(!prompt.contains("基础轮廓优先��规则主题剪影"));
         assert!(!prompt.contains("25格造型�混排"));
         assert!(!prompt.contains("no simple circles"));
@@ -1811,7 +2012,7 @@ mod tests {
         let normal_prompt =
             build_jump_hop_tile_atlas_prompt("水果", "水果主题的正�30度视角主题物体图集");
         assert!(normal_prompt.contains("主题为“水果�"));
-        assert!(normal_prompt.contains("画�内容是水果主题的正�30度视角主题物体图集"));
+        assert!(normal_prompt.contains("画�内容是水果主题的3D立方体主题身份方�包装图集"));
     }
 
     #[test]
@@ -1821,14 +2022,15 @@ mod tests {
             "科幻芯片主题的俯视角清爽游�化立体感平�素�",
         );
 
-        assert!(prompt.contains("画�内容是科幻芯片主题的正�30度视角清爽游�化立体感主题物体"));
+        assert!(prompt.contains("画�内容是科幻芯片主题的正交平�清爽游�化立方体主题身份方�包装贴图"));
         assert!(!prompt.contains("画�内容是科幻芯片主题的俯视角清爽游�化立体感平�素�"));
         assert!(!prompt.contains("画�内容是科幻芯片主题的俯视角"));
 
         let top_down_prompt =
             build_jump_hop_tile_atlas_prompt("水果", "水果主题鸟瞰视角平铺俯�圆形平�");
 
-        assert!(top_down_prompt.contains("画�内容是水果主题正�30度视角圆形主题物体"));
+        assert!(top_down_prompt.contains("画�内容是水果主题正交平�"));
+        assert!(top_down_prompt.contains("圆形立方体地�"));
         assert!(!top_down_prompt.contains("画�内容是水果主题鸟瞰视角"));
         assert!(!top_down_prompt.contains("画�内容是水果主题平铺俯�"));
 
@@ -1837,8 +2039,8 @@ mod tests {
             "雪花主题��脚平�素�，�格一个完整平�，��底座",
         );
 
-        assert!(legacy_prompt.contains("雪花主题跳跃�点主题物体"));
-        assert!(legacy_prompt.contains("�格一个完整主题物体"));
+        assert!(legacy_prompt.contains("雪花主题立方体主题身份方�包装贴图"));
+        assert!(legacy_prompt.contains("�格一张完整身份方�包装贴图"));
         assert!(legacy_prompt.contains("��承托物"));
         assert!(!legacy_prompt.contains("画�内容是雪花主题��脚平�素�"));
         assert!(!legacy_prompt.contains("画�内容是雪花主题��脚"));
@@ -1854,13 +2056,28 @@ mod tests {
         assert!(negative_prompt.contains("厚�CG渲染"));
         assert!(negative_prompt.contains("游�界�"));
         assert!(negative_prompt.contains("图标集页�"));
-        assert!(negative_prompt.contains("纯俯视角"));
-        assert!(negative_prompt.contains("正上方视角"));
-        assert!(negative_prompt.contains("鸟瞰视角"));
-        assert!(negative_prompt.contains("顶��主画�"));
-        assert!(negative_prompt.contains("�看顶�"));
-        assert!(negative_prompt.contains("圆形顶视图"));
-        assert!(negative_prompt.contains("�平图标"));
+        assert!(negative_prompt.contains("完整水果"));
+        assert!(negative_prompt.contains("孤立水果"));
+        assert!(negative_prompt.contains("果切"));
+        assert!(negative_prompt.contains("橙片"));
+        assert!(negative_prompt.contains("苹果�贴纸"));
+        assert!(negative_prompt.contains("香蕉�贴纸"));
+        assert!(negative_prompt.contains("�贴纸图标"));
+        assert!(negative_prompt.contains("纯果皮�质"));
+        assert!(negative_prompt.contains("无法分辨具体物体"));
+        assert!(negative_prompt.contains("�物体居中"));
+        assert!(negative_prompt.contains("�明背景"));
+        assert!(negative_prompt.contains("留白"));
+        assert!(negative_prompt.contains("3D平�"));
+        assert!(negative_prompt.contains("跳���"));
+        assert!(negative_prompt.contains("地���"));
+        assert!(negative_prompt.contains("物体剪影"));
+        assert!(negative_prompt.contains("正�30度物体图"));
+        assert!(negative_prompt.contains("�视地�"));
+        assert!(negative_prompt.contains("已�画好的侧�"));
+        assert!(negative_prompt.contains("已�画好的厚度"));
+        assert!(negative_prompt.contains("烘焙高光"));
+        assert!(negative_prompt.contains("烘焙阴影"));
         assert!(negative_prompt.contains("方形阴影"));
         assert!(negative_prompt.contains("洋红阴影"));
         assert!(negative_prompt.contains("紫色底边"));
@@ -1874,6 +2091,8 @@ mod tests {
         assert!(negative_prompt.contains("�座"));
         assert!(negative_prompt.contains("物体摆在平�上"));
         assert!(negative_prompt.contains("物体下方垫地�"));
+        assert!(negative_prompt.contains("��网格线"));
+        assert!(negative_prompt.contains("�切标记"));
         assert!(!negative_prompt.contains("规则圆盘"));
         assert!(!negative_prompt.contains("正圆平�"));
         assert!(!negative_prompt.contains("规则方�"));
@@ -1884,100 +2103,195 @@ mod tests {
         assert!(!negative_prompt.contains("楼房"));
     }
 
-    #[test]
-    fn jump_hop_tile_slice_keeps_largest_alpha_component() {
-        let mut image = image::RgbaImage::from_pixel(80, 80, image::Rgba([0, 0, 0, 0]));
-        for y in 12..52 {
-            for x in 12..52 {
-                image.put_pixel(x, y, image::Rgba([220, 70, 50, 255]));
-            }
-        }
-        for y in 68..74 {
-            for x in 36..42 {
-                image.put_pixel(x, y, image::Rgba([40, 190, 80, 255]));
-            }
-        }
-
-        let cleaned = keep_jump_hop_largest_alpha_component(image::DynamicImage::ImageRgba8(image))
-            .to_rgba8();
-
-        assert_eq!(cleaned.get_pixel(20, 20).0[3], 255);
-        assert_eq!(
-            cleaned.get_pixel(38, 70).0[3],
-            0,
-            "相邻格侵入的�碎片�应扩大当�地�切片边界"
+    fn paint_test_uv_face(
+        atlas: &mut image::RgbaImage,
+        atlas_col: u32,
+        atlas_row: u32,
+        face_col: u32,
+        face_row: u32,
+        color: image::Rgba<u8>,
+    ) {
+        let cell_width = atlas.width() / JUMP_HOP_TILE_ATLAS_COLS;
+        let cell_height = atlas.height() / JUMP_HOP_TILE_ATLAS_ROWS;
+        let face_side = (cell_width / JUMP_HOP_TILE_UV_FACE_COLS)
+            .min(cell_height / JUMP_HOP_TILE_UV_FACE_ROWS)
+            .max(1);
+        let tile_x = atlas_col.saturating_mul(cell_width);
+        let tile_y = atlas_row.saturating_mul(cell_height);
+        let uv_x = tile_x.saturating_add(
+            cell_width.saturating_sub(face_side * JUMP_HOP_TILE_UV_FACE_COLS) / 2,
         );
+        let uv_y = tile_y.saturating_add(
+            cell_height.saturating_sub(face_side * JUMP_HOP_TILE_UV_FACE_ROWS) / 2,
+        );
+        for y in uv_y + face_row * face_side..uv_y + (face_row + 1) * face_side {
+            for x in uv_x + face_col * face_side..uv_x + (face_col + 1) * face_side {
+                atlas.put_pixel(x, y, color);
+            }
+        }
     }
 
-    #[test]
-    fn jump_hop_tile_atlas_slices_twenty_five_png_tiles() {
-        let width = 500;
-        let height = 500;
-        let mut atlas = image::RgbaImage::new(width, height);
-        for row in 0..5 {
-            for col in 0..5 {
-                let index = row * 5 + col;
-                let color = image::Rgba([
-                    40 + index as u8 * 3,
-                    24 + index as u8 * 5,
-                    120 + index as u8 * 2,
-                    255,
-                ]);
-                for y in row as u32 * 100..(row as u32 + 1) * 100 {
-                    for x in col as u32 * 100..(col as u32 + 1) * 100 {
-                        atlas.put_pixel(x, y, color);
-                    }
-                }
-            }
+    fn load_test_png(bytes: Vec<u8>) -> crate::openai_image_generation::DownloadedOpenAiImage {
+        crate::openai_image_generation::DownloadedOpenAiImage {
+            bytes,
+            mime_type: "image/png".to_string(),
+            extension: "png".to_string(),
         }
+    }
+
+    fn encode_test_atlas(atlas: image::RgbaImage) -> Vec<u8> {
         let mut encoded = std::io::Cursor::new(Vec::new());
         image::DynamicImage::ImageRgba8(atlas)
             .write_to(&mut encoded, image::ImageFormat::Png)
             .expect("atlas should encode");
-        let image = crate::openai_image_generation::DownloadedOpenAiImage {
-            bytes: encoded.into_inner(),
-            mime_type: "image/png".to_string(),
-            extension: "png".to_string(),
-        };
+        encoded.into_inner()
+    }
+
+    fn assert_png_contains_color(bytes: &[u8], color: [u8; 4], message: &str) {
+        let decoded = image::load_from_memory(bytes)
+            .expect("tile face slice should decode")
+            .to_rgba8();
+        assert_eq!(
+            decoded.dimensions(),
+            (
+                JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE,
+                JUMP_HOP_TILE_TEXTURE_OUTPUT_SIZE
+            ),
+            "{message}"
+        );
+        assert!(
+            decoded.pixels().any(|pixel| pixel.0 == color),
+            "{message}"
+        );
+        assert!(
+            decoded.pixels().all(|pixel| pixel.0[3] == 255),
+            "{message}"
+        );
+    }
+
+    #[test]
+    fn jump_hop_tile_atlas_slices_eighteen_cube_uv_unwrap_tiles() {
+        let width = 384;
+        let height = 576;
+        let mut atlas =
+            image::RgbaImage::from_pixel(width, height, image::Rgba([255, 0, 255, 255]));
+        for row in 0..JUMP_HOP_TILE_ATLAS_ROWS {
+            for col in 0..JUMP_HOP_TILE_ATLAS_COLS {
+                let index = row * JUMP_HOP_TILE_ATLAS_COLS + col;
+                let base = index as u8;
+                paint_test_uv_face(
+                    &mut atlas,
+                    col,
+                    row,
+                    1,
+                    0,
+                    image::Rgba([40 + base * 3, 24 + base * 2, 100, 255]),
+                );
+                paint_test_uv_face(
+                    &mut atlas,
+                    col,
+                    row,
+                    1,
+                    1,
+                    image::Rgba([50 + base * 3, 34 + base * 2, 110, 255]),
+                );
+                paint_test_uv_face(
+                    &mut atlas,
+                    col,
+                    row,
+                    2,
+                    1,
+                    image::Rgba([60 + base * 3, 44 + base * 2, 120, 255]),
+                );
+                paint_test_uv_face(
+                    &mut atlas,
+                    col,
+                    row,
+                    3,
+                    1,
+                    image::Rgba([70 + base * 3, 54 + base * 2, 130, 255]),
+                );
+                paint_test_uv_face(
+                    &mut atlas,
+                    col,
+                    row,
+                    0,
+                    1,
+                    image::Rgba([80 + base * 3, 64 + base * 2, 140, 255]),
+                );
+                paint_test_uv_face(
+                    &mut atlas,
+                    col,
+                    row,
+                    1,
+                    2,
+                    image::Rgba([90 + base * 3, 74 + base * 2, 150, 255]),
+                );
+            }
+        }
+        let image = load_test_png(encode_test_atlas(atlas));
 
         let slices = slice_jump_hop_tile_atlas(&image).expect("atlas should slice");
 
         assert_eq!(slices.len(), JUMP_HOP_TILE_ITEM_COUNT);
         for (index, slice) in slices.iter().enumerate() {
+            let row = index as u32 / JUMP_HOP_TILE_ATLAS_COLS;
+            let col = index as u32 % JUMP_HOP_TILE_ATLAS_COLS;
+            let base = index as u8;
             assert_eq!(slice.tile_type, jump_hop_tile_type_by_index(index));
             assert_eq!(
                 slice.source_atlas_cell,
-                format!("row-{}-col-{}", index / 5 + 1, index % 5 + 1)
+                format!("row-{}-col-{}", row + 1, col + 1)
             );
-            let decoded = image::load_from_memory(slice.bytes.as_slice())
-                .expect("tile slice should decode")
-                .to_rgba8();
             assert_eq!(
-                decoded.dimensions(),
-                (116, 116),
-                "跳一跳地�切片应在 100x100 �元格外补�明安全边"
+                slice.faces.top.source_atlas_cell,
+                format!("row-{}-col-{}/top", row + 1, col + 1)
             );
-            let color = [
-                40 + index as u8 * 3,
-                24 + index as u8 * 5,
-                120 + index as u8 * 2,
-                255,
-            ];
-            assert!(
-                decoded.pixels().any(|pixel| pixel.0 == color),
-                "第 {index} 个地�切片应�留对应格�的主体颜色"
+            assert_eq!(
+                slice.faces.front.source_atlas_cell,
+                format!("row-{}-col-{}/front", row + 1, col + 1)
+            );
+            assert_png_contains_color(
+                slice.faces.top.bytes.as_slice(),
+                [40 + base * 3, 24 + base * 2, 100, 255],
+                "top �应从�格第1行第2列切出",
+            );
+            assert_png_contains_color(
+                slice.faces.front.bytes.as_slice(),
+                [50 + base * 3, 34 + base * 2, 110, 255],
+                "front �应从�格第2行第2列切出",
+            );
+            assert_png_contains_color(
+                slice.faces.right.bytes.as_slice(),
+                [60 + base * 3, 44 + base * 2, 120, 255],
+                "right �应从�格第2行第3列切出",
+            );
+            assert_png_contains_color(
+                slice.faces.back.bytes.as_slice(),
+                [70 + base * 3, 54 + base * 2, 130, 255],
+                "back �应从�格第2行第4列切出",
+            );
+            assert_png_contains_color(
+                slice.faces.left.bytes.as_slice(),
+                [80 + base * 3, 64 + base * 2, 140, 255],
+                "left �应从�格第2行第1列切出",
+            );
+            assert_png_contains_color(
+                slice.faces.bottom.bytes.as_slice(),
+                [90 + base * 3, 74 + base * 2, 150, 255],
+                "bottom �应从�格第3行第2列切出",
             );
         }
     }
 
     #[test]
     fn jump_hop_tile_atlas_slicing_preserves_green_and_white_tile_materials() {
-        let width = 500;
-        let height = 500;
+        let width = 384;
+        let height = 576;
         let mut atlas =
             image::RgbaImage::from_pixel(width, height, image::Rgba([255, 0, 255, 255]));
-        for row in 0..5 {
-            for col in 0..5 {
+        for row in 0..JUMP_HOP_TILE_ATLAS_ROWS {
+            for col in 0..JUMP_HOP_TILE_ATLAS_COLS {
                 let color = if row == 0 && col == 0 {
                     image::Rgba([62, 188, 74, 255])
                 } else if row == 0 && col == 1 {
@@ -1985,30 +2299,16 @@ mod tests {
                 } else {
                     image::Rgba([120, 96, 72, 255])
                 };
-                let center_x = col as u32 * 100 + 50;
-                let center_y = row as u32 * 100 + 50;
-                for y in center_y - 24..center_y + 24 {
-                    for x in center_x - 28..center_x + 28 {
-                        atlas.put_pixel(x, y, color);
-                    }
-                }
+                paint_test_uv_face(&mut atlas, col, row, 1, 0, color);
             }
         }
-        let mut encoded = std::io::Cursor::new(Vec::new());
-        image::DynamicImage::ImageRgba8(atlas)
-            .write_to(&mut encoded, image::ImageFormat::Png)
-            .expect("atlas should encode");
-        let image = crate::openai_image_generation::DownloadedOpenAiImage {
-            bytes: encoded.into_inner(),
-            mime_type: "image/png".to_string(),
-            extension: "png".to_string(),
-        };
+        let image = load_test_png(encode_test_atlas(atlas));
 
         let slices = slice_jump_hop_tile_atlas(&image).expect("atlas should slice");
-        let green_tile = image::load_from_memory(slices[0].bytes.as_slice())
+        let green_tile = image::load_from_memory(slices[0].faces.top.bytes.as_slice())
             .expect("green tile should decode")
             .to_rgba8();
-        let white_tile = image::load_from_memory(slices[1].bytes.as_slice())
+        let white_tile = image::load_from_memory(slices[1].faces.top.bytes.as_slice())
             .expect("white tile should decode")
             .to_rgba8();
 
@@ -2022,12 +2322,32 @@ mod tests {
                 .pixels()
                 .any(|pixel| pixel.0 == [246, 246, 238, 255])
         );
-        assert_eq!(green_tile.get_pixel(0, 0).0[3], 0);
-        assert_eq!(white_tile.get_pixel(0, 0).0[3], 0);
+        assert_eq!(green_tile.get_pixel(0, 0).0[3], 255);
+        assert_eq!(white_tile.get_pixel(0, 0).0[3], 255);
+        assert!(
+            green_tile.pixels().all(|pixel| pixel.0[3] == 255),
+            "绿色主题�质�能被�明化扣掉"
+        );
+        assert!(
+            white_tile.pixels().all(|pixel| pixel.0[3] == 255),
+            "白色主题�质�能被�明化扣掉"
+        );
+        assert!(
+            green_tile
+                .pixels()
+                .all(|pixel| pixel.0 != [255, 0, 255, 255]),
+            "残留洋红 key 色应被转���明�质底色，�能留���边"
+        );
+        assert!(
+            white_tile
+                .pixels()
+                .all(|pixel| pixel.0 != [255, 0, 255, 255]),
+            "残留洋红 key 色应被转���明�质底色，�能留���边"
+        );
     }
 
     #[test]
-    fn jump_hop_tile_asset_slots_are_unique_for_twenty_five_slices() {
+    fn jump_hop_tile_asset_slots_are_unique_for_eighteen_slices() {
         let slots = (0..JUMP_HOP_TILE_ITEM_COUNT)
             .map(jump_hop_tile_asset_slot_name)
             .collect::<Vec<_>>();
@@ -2039,7 +2359,31 @@ mod tests {
         assert_eq!(
             unique_slots.len(),
             JUMP_HOP_TILE_ITEM_COUNT,
-            "25 个地�切片必须写入 25 个独立 slot/path，�能按��的 tile_type 互相覆盖"
+            "18 个地� UV 大�元必须写入 18 个独立 slot/path，�能按��的 tile_type 互相覆盖"
+        );
+
+        let face_slots = (0..JUMP_HOP_TILE_ITEM_COUNT)
+            .flat_map(|index| {
+                [
+                    JumpHopTileFaceKey::Top,
+                    JumpHopTileFaceKey::Front,
+                    JumpHopTileFaceKey::Right,
+                    JumpHopTileFaceKey::Back,
+                    JumpHopTileFaceKey::Left,
+                    JumpHopTileFaceKey::Bottom,
+                ]
+                .into_iter()
+                .map(move |face| jump_hop_tile_face_asset_slot_name(index, &face))
+            })
+            .collect::<Vec<_>>();
+        let unique_face_slots = face_slots
+            .iter()
+            .cloned()
+            .collect::<std::collections::BTreeSet<_>>();
+        assert_eq!(
+            unique_face_slots.len(),
+            JUMP_HOP_TILE_ITEM_COUNT * 6,
+            "18 个地� UV 大�元的 108 张�贴图必须写入独立 slot/path"
         );
     }
 }
diff --git a/server-rs/crates/module-jump-hop/src/application.rs b/server-rs/crates/module-jump-hop/src/application.rs
index 71a990d5..8e7021a6 100644
--- a/server-rs/crates/module-jump-hop/src/application.rs
+++ b/server-rs/crates/module-jump-hop/src/application.rs
@@ -6,7 +6,9 @@ use crate::{
 };
 
 const JUMP_HOP_PLATFORM_SIZE_MULTIPLIER: f32 = 2.0;
-const JUMP_HOP_CHARGE_TO_DISTANCE_RATIO: f32 = 0.008;
+const JUMP_HOP_CHARGE_TO_DISTANCE_RATIO: f32 = 0.004;
+const JUMP_HOP_TOP_FACE_HITBOX_WIDTH_RATIO: f32 = 0.72;
+const JUMP_HOP_TOP_FACE_HITBOX_HEIGHT_RATIO: f32 = 0.52;
 
 pub fn generate_jump_hop_path(seed: &str, difficulty: JumpHopDifficulty) -> JumpHopPath {
     let config = difficulty_config(difficulty);
@@ -62,8 +64,8 @@ pub fn start_run(
 pub fn apply_jump(
     run: &JumpHopRunSnapshot,
     drag_distance: f32,
-    drag_vector_x: Option<f32>,
-    drag_vector_y: Option<f32>,
+    _drag_vector_x: Option<f32>,
+    _drag_vector_y: Option<f32>,
     jumped_at_ms: u64,
 ) -> Result<JumpHopRunSnapshot, JumpHopError> {
     if run.status != JumpHopRunStatus::Playing {
@@ -86,20 +88,15 @@ pub fn apply_jump(
     let vector_x = target.x - current.x;
     let vector_y = target.y - current.y;
     let target_distance = vector_x.hypot(vector_y).max(0.0001);
-    let (unit_x, unit_y) = normalize_jump_direction(
-        drag_vector_x,
-        drag_vector_y,
-        vector_x / target_distance,
-        vector_y / target_distance,
-    );
+    let unit_x = vector_x / target_distance;
+    let unit_y = vector_y / target_distance;
     let landed_x = current.x + unit_x * jump_distance;
     let landed_y = current.y + unit_y * jump_distance;
-    let landing_error = (landed_x - target.x).hypot(landed_y - target.y);
-    let target_landing_radius = target.landing_radius;
+    let landed_on_target = is_landing_inside_platform_footprint(target, landed_x, landed_y);
 
     let mut next = run.clone();
     next.path = path;
-    let result = if landing_error <= target_landing_radius {
+    let result = if landed_on_target {
         JumpHopJumpResultKind::Hit
     } else {
         JumpHopJumpResultKind::Miss
@@ -128,6 +125,19 @@ pub fn apply_jump(
     Ok(next)
 }
 
+fn is_landing_inside_platform_footprint(
+    platform: &JumpHopPlatform,
+    landed_x: f32,
+    landed_y: f32,
+) -> bool {
+    let half_width = (platform.width * 0.5 * JUMP_HOP_TOP_FACE_HITBOX_WIDTH_RATIO).max(0.0);
+    let half_height = (platform.height * 0.5 * JUMP_HOP_TOP_FACE_HITBOX_HEIGHT_RATIO).max(0.0);
+    let error_x = landed_x - platform.x;
+    let error_y = landed_y - platform.y;
+
+    error_x.abs() <= half_width && error_y.abs() <= half_height
+}
+
 pub fn restart_run(
     run: &JumpHopRunSnapshot,
     next_run_id: String,
@@ -250,30 +260,6 @@ fn extend_jump_hop_path(mut path: JumpHopPath, required_count: usize) -> JumpHop
     path
 }
 
-fn normalize_jump_direction(
-    drag_vector_x: Option<f32>,
-    drag_vector_y: Option<f32>,
-    fallback_x: f32,
-    fallback_y: f32,
-) -> (f32, f32) {
-    let Some(drag_x) = drag_vector_x.filter(|value| value.is_finite()) else {
-        return (fallback_x, fallback_y);
-    };
-    let Some(drag_y) = drag_vector_y.filter(|value| value.is_finite()) else {
-        return (fallback_x, fallback_y);
-    };
-    // �端�交的是�幕拖拽��：x 轴��，y 轴�下为正。
-    // 真实起跳需�“��弹出�，�时把�幕 y 翻回世界�标的�上为正。
-    let jump_x = -drag_x;
-    let jump_y = drag_y;
-    let length = jump_x.hypot(jump_y);
-    if length < 0.0001 {
-        (fallback_x, fallback_y)
-    } else {
-        (jump_x / length, jump_y / length)
-    }
-}
-
 fn difficulty_config(difficulty: JumpHopDifficulty) -> DifficultyConfig {
     match difficulty {
         JumpHopDifficulty::Easy => DifficultyConfig {
@@ -353,8 +339,8 @@ impl DeterministicRng {
 #[cfg(test)]
 mod tests {
     use crate::{
-        JumpHopDifficulty, JumpHopJumpResultKind, JumpHopRunStatus, apply_jump,
-        generate_jump_hop_path, restart_run, start_run,
+        JumpHopDifficulty, JumpHopJumpResultKind, JumpHopPlatform, JumpHopRunStatus,
+        JumpHopTileType, apply_jump, generate_jump_hop_path, restart_run, start_run,
     };
 
     #[test]
@@ -371,16 +357,17 @@ mod tests {
     }
 
     #[test]
-    fn difficulty_charge_to_distance_ratio_is_doubled() {
+    fn difficulty_charge_to_distance_ratio_is_reduced_for_long_press() {
         let easy = generate_jump_hop_path("seed-ratio-easy", JumpHopDifficulty::Easy);
         let standard = generate_jump_hop_path("seed-ratio-standard", JumpHopDifficulty::Standard);
         let advanced = generate_jump_hop_path("seed-ratio-advanced", JumpHopDifficulty::Advanced);
-        let challenge = generate_jump_hop_path("seed-ratio-challenge", JumpHopDifficulty::Challenge);
+        let challenge =
+            generate_jump_hop_path("seed-ratio-challenge", JumpHopDifficulty::Challenge);
 
-        assert_eq!(easy.scoring.charge_to_distance_ratio, 0.008);
-        assert_eq!(standard.scoring.charge_to_distance_ratio, 0.008);
-        assert_eq!(advanced.scoring.charge_to_distance_ratio, 0.008);
-        assert_eq!(challenge.scoring.charge_to_distance_ratio, 0.008);
+        assert_eq!(easy.scoring.charge_to_distance_ratio, 0.004);
+        assert_eq!(standard.scoring.charge_to_distance_ratio, 0.004);
+        assert_eq!(advanced.scoring.charge_to_distance_ratio, 0.004);
+        assert_eq!(challenge.scoring.charge_to_distance_ratio, 0.004);
     }
 
     #[test]
@@ -454,7 +441,7 @@ mod tests {
             None,
             200,
         )
-            .expect("jump should resolve");
+        .expect("jump should resolve");
         assert_eq!(miss.status, JumpHopRunStatus::Failed);
         assert_eq!(
             miss.last_jump.as_ref().unwrap().result,
@@ -463,7 +450,7 @@ mod tests {
     }
 
     #[test]
-    fn jump_resolution_uses_screen_drag_y_axis_for_forward_jump_direction() {
+    fn jump_resolution_ignores_client_drag_direction_and_targets_next_center() {
         let path = generate_jump_hop_path("seed-screen-axis", JumpHopDifficulty::Easy);
         let run = start_run(
             "run-screen-axis".to_string(),
@@ -478,21 +465,49 @@ mod tests {
         let target_distance = (target.x - current.x).hypot(target.y - current.y);
         let charge = (target_distance / run.path.scoring.charge_to_distance_ratio).round() as u32;
 
-        let result = apply_jump(
-            &run,
-            charge as f32,
-            Some(-(target.x - current.x)),
-            Some(target.y - current.y),
-            200,
-        )
-        .expect("jump should resolve");
+        let result = apply_jump(&run, charge as f32, Some(-999.0), Some(-999.0), 200)
+            .expect("jump should resolve");
 
+        let last_jump = result.last_jump.as_ref().expect("last jump should exist");
         assert_eq!(result.status, JumpHopRunStatus::Playing);
-        assert_eq!(
-            result.last_jump.as_ref().unwrap().result,
-            JumpHopJumpResultKind::Hit
-        );
+        assert_eq!(last_jump.result, JumpHopJumpResultKind::Hit);
         assert_eq!(result.current_platform_index, 1);
+        assert!((last_jump.landed_x - target.x).abs() < target.landing_radius);
+        assert!((last_jump.landed_y - target.y).abs() < target.landing_radius);
+    }
+
+    #[test]
+    fn jump_resolution_uses_visual_top_face_footprint_instead_of_landing_radius() {
+        let mut path = generate_jump_hop_path("seed-footprint", JumpHopDifficulty::Easy);
+        path.platforms[0] = test_platform("p0", 0.0, 0.0, 1.2, 1.0);
+        path.platforms[1] = test_platform("p1", 1.0, 0.0, 2.0, 0.6);
+        path.scoring.max_charge_ms = 600;
+        let run = start_run(
+            "run-footprint".to_string(),
+            "user-footprint".to_string(),
+            "profile-footprint".to_string(),
+            path,
+            100,
+        )
+        .expect("run should start");
+
+        let edge_hit_charge = 1.6 / run.path.scoring.charge_to_distance_ratio;
+        let edge_hit =
+            apply_jump(&run, edge_hit_charge, None, None, 200).expect("jump should resolve");
+        let last_hit = edge_hit.last_jump.as_ref().expect("last jump should exist");
+        assert_eq!(edge_hit.status, JumpHopRunStatus::Playing);
+        assert_eq!(last_hit.result, JumpHopJumpResultKind::Hit);
+        assert!(last_hit.landed_x > 1.5);
+        assert!(last_hit.landed_x <= 1.72);
+
+        let outside_charge = 1.8 / run.path.scoring.charge_to_distance_ratio;
+        let outside =
+            apply_jump(&run, outside_charge, None, None, 200).expect("jump should resolve");
+        assert_eq!(outside.status, JumpHopRunStatus::Failed);
+        assert_eq!(
+            outside.last_jump.as_ref().unwrap().result,
+            JumpHopJumpResultKind::Miss
+        );
     }
 
     #[test]
@@ -551,4 +566,18 @@ mod tests {
         assert!(run.path.platforms.len() >= 12);
         assert!(run.finished_at_ms.is_none());
     }
+
+    fn test_platform(id: &str, x: f32, y: f32, width: f32, height: f32) -> JumpHopPlatform {
+        JumpHopPlatform {
+            platform_id: id.to_string(),
+            tile_type: JumpHopTileType::Normal,
+            x,
+            y,
+            width,
+            height,
+            landing_radius: 0.2,
+            perfect_radius: 0.1,
+            score_value: 1,
+        }
+    }
 }
diff --git a/server-rs/crates/platform-image/src/vector_engine/client.rs b/server-rs/crates/platform-image/src/vector_engine/client.rs
index 6fcd23dd..70754cae 100644
--- a/server-rs/crates/platform-image/src/vector_engine/client.rs
+++ b/server-rs/crates/platform-image/src/vector_engine/client.rs
@@ -18,6 +18,7 @@ use super::{
     },
     response::handle_vector_engine_response,
     types::{GeneratedImages, ReferenceImage, VectorEngineImageSettings},
+    util::truncate_raw,
 };
 
 pub async fn create_vector_engine_image_generation(
@@ -66,7 +67,25 @@ pub async fn create_vector_engine_image_generation(
         )
         .await
         {
-            Ok(response) => break response,
+            Ok(response) => {
+                if should_retry_vector_engine_upstream_status(response.status, attempt) {
+                    retry_vector_engine_upstream_status_after_delay(
+                        "generation",
+                        request_url.as_str(),
+                        attempt,
+                        response.status,
+                        response.body.as_str(),
+                        started_at.elapsed().as_millis() as u64,
+                        Some(prompt.chars().count()),
+                        Some(reference_images.len()),
+                        Some(&request_body),
+                    )
+                    .await;
+                    attempt += 1;
+                    continue;
+                }
+                break response;
+            }
             Err(error) => {
                 if should_retry_vector_engine_curl_send_error(&error, attempt) {
                     retry_vector_engine_send_after_delay(
@@ -75,7 +94,7 @@ pub async fn create_vector_engine_image_generation(
                         "request_send",
                         attempt,
                         error.is_timeout(),
-                        error.is_connect(),
+                        error.is_connect() || error.is_transient_transport(),
                         true,
                         false,
                         error.to_string().as_str(),
@@ -220,7 +239,25 @@ pub async fn create_vector_engine_image_edit_with_references(
         )
         .await
         {
-            Ok(response) => break response,
+            Ok(response) => {
+                if should_retry_vector_engine_upstream_status(response.status, attempt) {
+                    retry_vector_engine_upstream_status_after_delay(
+                        "edit",
+                        request_url.as_str(),
+                        attempt,
+                        response.status,
+                        response.body.as_str(),
+                        started_at.elapsed().as_millis() as u64,
+                        Some(prompt.chars().count()),
+                        Some(reference_image_count),
+                        Some(&request_params),
+                    )
+                    .await;
+                    attempt += 1;
+                    continue;
+                }
+                break response;
+            }
             Err(error) => {
                 if should_retry_vector_engine_curl_send_error(&error, attempt) {
                     retry_vector_engine_send_after_delay(
@@ -229,7 +266,7 @@ pub async fn create_vector_engine_image_edit_with_references(
                         "request_send",
                         attempt,
                         error.is_timeout(),
-                        error.is_connect(),
+                        error.is_connect() || error.is_transient_transport(),
                         true,
                         false,
                         error.to_string().as_str(),
@@ -290,7 +327,12 @@ fn should_retry_vector_engine_curl_send_error(
     error: &super::curl_transport::VectorEngineCurlError,
     attempt: u32,
 ) -> bool {
-    attempt < VECTOR_ENGINE_SEND_MAX_ATTEMPTS && (error.is_timeout() || error.is_connect())
+    attempt < VECTOR_ENGINE_SEND_MAX_ATTEMPTS
+        && (error.is_timeout() || error.is_connect() || error.is_transient_transport())
+}
+
+fn should_retry_vector_engine_upstream_status(status: u16, attempt: u32) -> bool {
+    attempt < VECTOR_ENGINE_SEND_MAX_ATTEMPTS && (status == 408 || status == 429 || status >= 500)
 }
 
 async fn retry_vector_engine_send_after_delay(
@@ -334,6 +376,40 @@ async fn retry_vector_engine_send_after_delay(
     tokio::time::sleep(std::time::Duration::from_millis(delay_ms)).await;
 }
 
+async fn retry_vector_engine_upstream_status_after_delay(
+    request_kind: &'static str,
+    request_url: &str,
+    attempt: u32,
+    status: u16,
+    raw_body: &str,
+    elapsed_ms: u64,
+    prompt_chars: Option<usize>,
+    reference_image_count: Option<usize>,
+    request_params: Option<&serde_json::Value>,
+) {
+    let delay_ms = vector_engine_send_retry_delay_ms(attempt, vector_engine_send_retry_jitter_ms());
+    tracing::warn!(
+        provider = VECTOR_ENGINE_PROVIDER,
+        endpoint = %request_url,
+        request_kind,
+        failure_stage = "upstream_status",
+        attempt,
+        max_attempts = VECTOR_ENGINE_SEND_MAX_ATTEMPTS,
+        retry_delay_ms = delay_ms,
+        status,
+        retryable = true,
+        elapsed_ms,
+        prompt_chars,
+        reference_image_count,
+        raw_excerpt = %truncate_raw(raw_body),
+        request_params = %request_params
+            .map(|value| value.to_string())
+            .unwrap_or_default(),
+        "VectorEngine 图片上游状���试，准备�试"
+    );
+    tokio::time::sleep(std::time::Duration::from_millis(delay_ms)).await;
+}
+
 fn vector_engine_send_retry_delay_ms(attempt: u32, jitter_ms: u64) -> u64 {
     let exponential_factor = 1_u64 << attempt.saturating_sub(1).min(10);
     let bounded_jitter_ms = jitter_ms.min(VECTOR_ENGINE_SEND_RETRY_MAX_JITTER_MS);
@@ -357,6 +433,33 @@ mod tests {
         assert_eq!(VECTOR_ENGINE_SEND_MAX_ATTEMPTS, 5);
     }
 
+    #[test]
+    fn vector_engine_send_retry_policy_treats_ssl_reset_as_transient_transport() {
+        let error = super::super::curl_transport::VectorEngineCurlError::Curl(curl::Error::new(35));
+
+        assert!(error.is_transient_transport());
+        assert!(should_retry_vector_engine_curl_send_error(&error, 1));
+        assert!(!should_retry_vector_engine_curl_send_error(&error, 5));
+    }
+
+    #[test]
+    fn vector_engine_send_retry_policy_treats_recv_eof_as_transient_transport() {
+        let error = super::super::curl_transport::VectorEngineCurlError::Curl(curl::Error::new(56));
+
+        assert!(error.is_transient_transport());
+        assert!(should_retry_vector_engine_curl_send_error(&error, 1));
+        assert!(!should_retry_vector_engine_curl_send_error(&error, 5));
+    }
+
+    #[test]
+    fn vector_engine_send_retry_policy_treats_upstream_502_as_retryable() {
+        assert!(should_retry_vector_engine_upstream_status(502, 1));
+        assert!(should_retry_vector_engine_upstream_status(429, 1));
+        assert!(should_retry_vector_engine_upstream_status(408, 1));
+        assert!(!should_retry_vector_engine_upstream_status(400, 1));
+        assert!(!should_retry_vector_engine_upstream_status(502, 5));
+    }
+
     #[test]
     fn vector_engine_send_retry_delay_uses_exponential_backoff_with_bounded_jitter() {
         assert_eq!(vector_engine_send_retry_delay_ms(1, 0), 500);
diff --git a/server-rs/crates/platform-image/src/vector_engine/curl_transport.rs b/server-rs/crates/platform-image/src/vector_engine/curl_transport.rs
index 1991bdda..a5c6af67 100644
--- a/server-rs/crates/platform-image/src/vector_engine/curl_transport.rs
+++ b/server-rs/crates/platform-image/src/vector_engine/curl_transport.rs
@@ -45,6 +45,25 @@ impl VectorEngineCurlError {
             Self::Form(_) | Self::WorkerJoin(_) => false,
         }
     }
+
+    pub(crate) fn is_transient_transport(&self) -> bool {
+        match self {
+            Self::Curl(error) => {
+                let message = error.to_string().to_ascii_lowercase();
+                error.is_ssl_connect_error()
+                    || error.is_recv_error()
+                    || error.is_send_error()
+                    || message.contains("connection reset")
+                    || message.contains("recv failure")
+                    || message.contains("receive failure")
+                    || message.contains("receiving data")
+                    || message.contains("unexpected eof")
+                    || message.contains("send failure")
+                    || message.contains("broken pipe")
+            }
+            Self::Form(_) | Self::WorkerJoin(_) => false,
+        }
+    }
 }
 
 impl fmt::Display for VectorEngineCurlError {
@@ -136,7 +155,7 @@ pub(crate) fn map_curl_error(
     request_params: Option<&Value>,
 ) -> PlatformImageError {
     let is_timeout = error.is_timeout();
-    let is_connect = error.is_connect();
+    let is_connect = error.is_connect() || error.is_transient_transport();
     let source = error.to_string();
     let message = format!("{context}：{source}");
     let audit = build_failure_audit(
diff --git a/server-rs/crates/platform-image/tests/vector_engine.rs b/server-rs/crates/platform-image/tests/vector_engine.rs
index c53d63c2..8dadd9eb 100644
--- a/server-rs/crates/platform-image/tests/vector_engine.rs
+++ b/server-rs/crates/platform-image/tests/vector_engine.rs
@@ -1,8 +1,8 @@
 use platform_image::vector_engine::{
     GPT_IMAGE_2_MODEL, ReferenceImage, VECTOR_ENGINE_PROVIDER, VectorEngineImageSettings,
     build_vector_engine_image_http_client, build_vector_engine_image_request_body,
-    create_vector_engine_image_edit, vector_engine_images_edit_url,
-    vector_engine_images_generation_url,
+    create_vector_engine_image_edit, create_vector_engine_image_generation,
+    vector_engine_images_edit_url, vector_engine_images_generation_url,
 };
 use std::{
     sync::{
@@ -109,3 +109,72 @@ async fn vector_engine_image_edit_retries_send_timeout_once_and_succeeds() {
     assert_eq!(request_count.load(Ordering::SeqCst), 2);
     server.abort();
 }
+
+#[tokio::test]
+async fn vector_engine_image_generation_retries_upstream_502_once_and_succeeds() {
+    let listener = TcpListener::bind("127.0.0.1:0")
+        .await
+        .expect("mock server should bind");
+    let server_addr = listener
+        .local_addr()
+        .expect("mock server address should be readable");
+    let request_count = Arc::new(AtomicUsize::new(0));
+    let request_count_for_server = Arc::clone(&request_count);
+
+    let server = tokio::spawn(async move {
+        loop {
+            let Ok((mut stream, _)) = listener.accept().await else {
+                break;
+            };
+            let request_index = request_count_for_server.fetch_add(1, Ordering::SeqCst);
+            tokio::spawn(async move {
+                let mut buffer = [0_u8; 4096];
+                let _ = stream.read(&mut buffer).await;
+                if request_index == 0 {
+                    let body = "<html><head><title>502 Bad Gateway</title></head><body><center><h1>502 Bad Gateway</h1></center><hr><center>nginx</center></body></html>";
+                    let response = format!(
+                        "HTTP/1.1 502 Bad Gateway\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{}",
+                        body.len(),
+                        body
+                    );
+                    let _ = stream.write_all(response.as_bytes()).await;
+                    return;
+                }
+
+                let body = r#"{"data":[{"b64_json":"iVBORw0KGgpyZXN0"}]}"#;
+                let response = format!(
+                    "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
+                    body.len(),
+                    body
+                );
+                let _ = stream.write_all(response.as_bytes()).await;
+            });
+        }
+    });
+
+    let settings = VectorEngineImageSettings {
+        base_url: format!("http://{server_addr}/v1"),
+        api_key: "test-key".to_string(),
+        request_timeout_ms: 1_000,
+    };
+    let http_client =
+        build_vector_engine_image_http_client(&settings).expect("client should build");
+
+    let generated = create_vector_engine_image_generation(
+        &http_client,
+        &settings,
+        "测试�示�",
+        None,
+        "1024x1024",
+        1,
+        &[],
+        "测试 VectorEngine 图片生�失败",
+    )
+    .await
+    .expect("second attempt should return generated image");
+
+    assert_eq!(generated.images.len(), 1);
+    assert_eq!(generated.images[0].mime_type, "image/png");
+    assert_eq!(request_count.load(Ordering::SeqCst), 2);
+    server.abort();
+}
diff --git a/server-rs/crates/shared-contracts/src/jump_hop.rs b/server-rs/crates/shared-contracts/src/jump_hop.rs
index 826130f4..3bc62911 100644
--- a/server-rs/crates/shared-contracts/src/jump_hop.rs
+++ b/server-rs/crates/shared-contracts/src/jump_hop.rs
@@ -166,6 +166,45 @@ pub struct JumpHopTileAsset {
     pub visual_height: u32,
     pub top_surface_radius: f32,
     pub landing_radius: f32,
+    #[serde(default)]
+    pub face_assets: Option<JumpHopTileFaceAssets>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopTileFaceKey {
+    Top,
+    Front,
+    Right,
+    Back,
+    Left,
+    Bottom,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopTileFaceAsset {
+    pub face: JumpHopTileFaceKey,
+    pub asset_id: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub generation_provider: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+    pub source_atlas_cell: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopTileFaceAssets {
+    pub top: JumpHopTileFaceAsset,
+    pub front: JumpHopTileFaceAsset,
+    pub right: JumpHopTileFaceAsset,
+    pub back: JumpHopTileFaceAsset,
+    pub left: JumpHopTileFaceAsset,
+    pub bottom: JumpHopTileFaceAsset,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
diff --git a/server-rs/crates/spacetime-client/src/jump_hop.rs b/server-rs/crates/spacetime-client/src/jump_hop.rs
index 9f1aeef1..6274315c 100644
--- a/server-rs/crates/spacetime-client/src/jump_hop.rs
+++ b/server-rs/crates/spacetime-client/src/jump_hop.rs
@@ -473,9 +473,9 @@ fn validate_jump_hop_runtime_ready(
     }
     validate_jump_hop_default_character_ready(work)?;
     validate_jump_hop_tile_atlas_asset_ready(&work.tile_atlas_asset, "tile_atlas_asset")?;
-    if work.tile_assets.len() < 25 {
+    if work.tile_assets.len() < 18 {
         return Err(SpacetimeClientError::validation_failed(
-            "jump-hop runtime 需� 25 个地�资产",
+            "jump-hop runtime 需� 18 个地�资产",
         ));
     }
     for (index, asset) in work.tile_assets.iter().enumerate() {
@@ -761,12 +761,12 @@ fn build_compile_input(
     draft.default_character = Some(default_jump_hop_default_character());
     let tile_atlas_asset = draft.tile_atlas_asset.clone().ok_or_else(|| {
         SpacetimeClientError::validation_failed(
-            "jump-hop compile-draft 缺少真实地�图集资产，请先由 api-server 生�并�久化 asset_object",
+            "jump-hop compile-draft 缺少真实地�贴图图集资产，请先由 api-server 生�并�久化 asset_object",
         )
     })?;
-    let tile_assets = if draft.tile_assets.len() < 25 {
+    let tile_assets = if draft.tile_assets.len() < 18 {
         return Err(SpacetimeClientError::validation_failed(
-            "jump-hop compile-draft 需� 25 个真实地�资产，请先由 api-server 生�并�久化 asset_object",
+            "jump-hop compile-draft 需� 18 个真实地�资产，请先由 api-server 生�并�久化 asset_object",
         ));
     } else {
         draft.tile_assets.clone()
@@ -878,7 +878,7 @@ fn default_draft() -> JumpHopDraftResponse {
         style_preset: JumpHopStylePreset::MinimalBlocks,
         default_character: Some(default_jump_hop_default_character()),
         character_prompt: "内置默认 3D 角色".to_string(),
-        tile_prompt: "跳一跳主题的正�30度视角主题物体图集，物体本身作为跳跃�点".to_string(),
+        tile_prompt: "跳一跳主题的3D立方体主题身份方�包装图集".to_string(),
         end_mood_prompt: None,
         character_asset: None,
         tile_atlas_asset: None,
@@ -994,7 +994,7 @@ mod tests {
     const NOW_MICROS: i64 = 1_763_456_789_000_000;
 
     #[test]
-    fn jump_hop_action_compile_draft_builds_compile_input_with_25_tile_assets_and_builtin_character()
+    fn jump_hop_action_compile_draft_builds_compile_input_with_18_tile_assets_and_builtin_character()
      {
         let session = session_with_draft(draft_without_character_asset());
         let payload = action(JumpHopActionType::CompileDraft);
@@ -1028,9 +1028,9 @@ mod tests {
                 .tile_assets_json
                 .as_deref()
                 .unwrap_or("")
-                .contains("old-tile-25-object")
+                .contains("old-tile-18-object")
         );
-        assert_eq!(draft.tile_assets.len(), 25);
+        assert_eq!(draft.tile_assets.len(), 18);
         assert_eq!(draft.generation_status, JumpHopGenerationStatus::Ready);
     }
 
@@ -1040,7 +1040,7 @@ mod tests {
         let mut payload = action(JumpHopActionType::RegenerateTiles);
         payload.tile_prompt = Some("新的地��示�".to_string());
         payload.tile_atlas_asset = Some(tile_atlas_asset("new-tile-atlas", NOW_MICROS));
-        payload.tile_assets = Some(tile_assets("new", 25));
+        payload.tile_assets = Some(tile_assets("new", 18));
 
         let (plan, _draft) =
             build_jump_hop_action_plan(&session, OWNER_USER_ID, &payload, NOW_MICROS)
@@ -1082,7 +1082,7 @@ mod tests {
                 .tile_assets_json
                 .as_deref()
                 .unwrap_or("")
-                .contains("new-tile-25-object")
+                .contains("new-tile-18-object")
         );
     }
 
@@ -1196,7 +1196,7 @@ mod tests {
         JumpHopDraftResponse {
             profile_id: None,
             tile_atlas_asset: Some(tile_atlas_asset("old-tile-atlas", 0)),
-            tile_assets: tile_assets("old", 25),
+            tile_assets: tile_assets("old", 18),
             ..base_draft()
         }
     }
@@ -1206,7 +1206,7 @@ mod tests {
             profile_id: Some(PROFILE_ID.to_string()),
             character_asset: Some(build_jump_hop_default_character_asset(PROFILE_ID, "旧主题")),
             tile_atlas_asset: Some(tile_atlas_asset("old-tile-atlas", 0)),
-            tile_assets: tile_assets("old", 25),
+            tile_assets: tile_assets("old", 18),
             path: Some(sample_jump_hop_path()),
             cover_composite: Some("/generated-jump-hop-assets/old-cover.png".to_string()),
             generation_status: JumpHopGenerationStatus::Ready,
@@ -1243,13 +1243,14 @@ mod tests {
                     index + 1
                 ),
                 asset_object_id: format!("{prefix}-tile-{:02}-object", index + 1),
-                source_atlas_cell: format!("row-{}-col-{}", index / 5 + 1, index % 5 + 1),
-                atlas_row: Some(index as u32 / 5 + 1),
-                atlas_col: Some(index as u32 % 5 + 1),
+                source_atlas_cell: format!("row-{}-col-{}", index / 3 + 1, index % 3 + 1),
+                atlas_row: Some(index as u32 / 3 + 1),
+                atlas_col: Some(index as u32 % 3 + 1),
                 visual_width: 256,
                 visual_height: 192,
                 top_surface_radius: 42.0,
                 landing_radius: 34.0,
+                face_assets: None,
             })
             .collect()
     }
diff --git a/server-rs/crates/spacetime-client/src/mapper/jump_hop.rs b/server-rs/crates/spacetime-client/src/mapper/jump_hop.rs
index 5a5a8a5e..b37dc8f3 100644
--- a/server-rs/crates/spacetime-client/src/mapper/jump_hop.rs
+++ b/server-rs/crates/spacetime-client/src/mapper/jump_hop.rs
@@ -8,9 +8,9 @@ pub use shared_contracts::jump_hop::{
     JumpHopRestartRunRequest, JumpHopRunResponse, JumpHopRunStatus,
     JumpHopRuntimeRunSnapshotResponse, JumpHopScoring, JumpHopSessionResponse,
     JumpHopSessionSnapshotResponse, JumpHopStartRunRequest, JumpHopStylePreset, JumpHopTileAsset,
-    JumpHopTileType, JumpHopWorkDetailResponse, JumpHopWorkMutationResponse,
-    JumpHopWorkProfileResponse, JumpHopWorkSummaryResponse, JumpHopWorksResponse,
-    JumpHopWorkspaceCreateRequest,
+    JumpHopTileFaceAsset, JumpHopTileFaceAssets, JumpHopTileFaceKey, JumpHopTileType,
+    JumpHopWorkDetailResponse, JumpHopWorkMutationResponse, JumpHopWorkProfileResponse,
+    JumpHopWorkSummaryResponse, JumpHopWorksResponse, JumpHopWorkspaceCreateRequest,
 };
 
 pub(crate) fn map_jump_hop_agent_session_procedure_result(
@@ -267,6 +267,33 @@ fn map_tile_asset(snapshot: JumpHopTileAssetSnapshot) -> JumpHopTileAsset {
         visual_height: snapshot.visual_height,
         top_surface_radius: snapshot.top_surface_radius,
         landing_radius: snapshot.landing_radius,
+        face_assets: snapshot.face_assets.map(map_tile_face_assets),
+    }
+}
+
+fn map_tile_face_assets(snapshot: JumpHopTileFaceAssetsSnapshot) -> JumpHopTileFaceAssets {
+    JumpHopTileFaceAssets {
+        top: map_tile_face_asset(snapshot.top),
+        front: map_tile_face_asset(snapshot.front),
+        right: map_tile_face_asset(snapshot.right),
+        back: map_tile_face_asset(snapshot.back),
+        left: map_tile_face_asset(snapshot.left),
+        bottom: map_tile_face_asset(snapshot.bottom),
+    }
+}
+
+fn map_tile_face_asset(snapshot: JumpHopTileFaceAssetSnapshot) -> JumpHopTileFaceAsset {
+    JumpHopTileFaceAsset {
+        face: parse_tile_face_key(&snapshot.face),
+        asset_id: snapshot.asset_id,
+        image_src: snapshot.image_src,
+        image_object_key: snapshot.image_object_key,
+        asset_object_id: snapshot.asset_object_id,
+        generation_provider: snapshot.generation_provider,
+        prompt: snapshot.prompt,
+        width: snapshot.width,
+        height: snapshot.height,
+        source_atlas_cell: snapshot.source_atlas_cell,
     }
 }
 
@@ -405,6 +432,17 @@ fn parse_tile_type(value: &str) -> JumpHopTileType {
     }
 }
 
+fn parse_tile_face_key(value: &str) -> JumpHopTileFaceKey {
+    match value {
+        "front" => JumpHopTileFaceKey::Front,
+        "right" => JumpHopTileFaceKey::Right,
+        "back" => JumpHopTileFaceKey::Back,
+        "left" => JumpHopTileFaceKey::Left,
+        "bottom" => JumpHopTileFaceKey::Bottom,
+        _ => JumpHopTileFaceKey::Top,
+    }
+}
+
 fn parse_domain_tile_type(value: crate::module_bindings::JumpHopTileType) -> JumpHopTileType {
     match value {
         crate::module_bindings::JumpHopTileType::Start => JumpHopTileType::Start,
diff --git a/server-rs/crates/spacetime-client/src/module_bindings.rs b/server-rs/crates/spacetime-client/src/module_bindings.rs
index acdf3fc5..d2ac5477 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings.rs
@@ -463,6 +463,8 @@ pub mod jump_hop_runtime_run_row_type;
 pub mod jump_hop_runtime_run_table;
 pub mod jump_hop_scoring_type;
 pub mod jump_hop_tile_asset_snapshot_type;
+pub mod jump_hop_tile_face_asset_snapshot_type;
+pub mod jump_hop_tile_face_assets_snapshot_type;
 pub mod jump_hop_tile_type_type;
 pub mod jump_hop_work_delete_input_type;
 pub mod jump_hop_work_get_input_type;
@@ -1567,6 +1569,8 @@ pub use jump_hop_runtime_run_row_type::JumpHopRuntimeRunRow;
 pub use jump_hop_runtime_run_table::*;
 pub use jump_hop_scoring_type::JumpHopScoring;
 pub use jump_hop_tile_asset_snapshot_type::JumpHopTileAssetSnapshot;
+pub use jump_hop_tile_face_asset_snapshot_type::JumpHopTileFaceAssetSnapshot;
+pub use jump_hop_tile_face_assets_snapshot_type::JumpHopTileFaceAssetsSnapshot;
 pub use jump_hop_tile_type_type::JumpHopTileType;
 pub use jump_hop_work_delete_input_type::JumpHopWorkDeleteInput;
 pub use jump_hop_work_get_input_type::JumpHopWorkGetInput;
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_asset_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_asset_snapshot_type.rs
index 9ca1fe02..5223f15a 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_asset_snapshot_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_asset_snapshot_type.rs
@@ -4,6 +4,8 @@
 #![allow(unused, clippy::all)]
 use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
 
+use super::jump_hop_tile_face_assets_snapshot_type::JumpHopTileFaceAssetsSnapshot;
+
 #[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
 #[sats(crate = __lib)]
 pub struct JumpHopTileAssetSnapshot {
@@ -19,6 +21,7 @@ pub struct JumpHopTileAssetSnapshot {
     pub visual_height: u32,
     pub top_surface_radius: f32,
     pub landing_radius: f32,
+    pub face_assets: Option<JumpHopTileFaceAssetsSnapshot>,
 }
 
 impl __sdk::InModule for JumpHopTileAssetSnapshot {
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_asset_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_asset_snapshot_type.rs
new file mode 100644
index 00000000..b2b27196
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_asset_snapshot_type.rs
@@ -0,0 +1,24 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopTileFaceAssetSnapshot {
+    pub face: String,
+    pub asset_id: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub generation_provider: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+    pub source_atlas_cell: String,
+}
+
+impl __sdk::InModule for JumpHopTileFaceAssetSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_assets_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_assets_snapshot_type.rs
new file mode 100644
index 00000000..7625d48f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_face_assets_snapshot_type.rs
@@ -0,0 +1,22 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::jump_hop_tile_face_asset_snapshot_type::JumpHopTileFaceAssetSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopTileFaceAssetsSnapshot {
+    pub top: JumpHopTileFaceAssetSnapshot,
+    pub front: JumpHopTileFaceAssetSnapshot,
+    pub right: JumpHopTileFaceAssetSnapshot,
+    pub back: JumpHopTileFaceAssetSnapshot,
+    pub left: JumpHopTileFaceAssetSnapshot,
+    pub bottom: JumpHopTileFaceAssetSnapshot,
+}
+
+impl __sdk::InModule for JumpHopTileFaceAssetsSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-module/src/jump_hop.rs b/server-rs/crates/spacetime-module/src/jump_hop.rs
index 743d62f9..ee865db2 100644
--- a/server-rs/crates/spacetime-module/src/jump_hop.rs
+++ b/server-rs/crates/spacetime-module/src/jump_hop.rs
@@ -1311,7 +1311,7 @@ fn default_config_from_seed(seed_text: &str) -> JumpHopCreatorConfigSnapshot {
         difficulty: JumpHopDifficulty::Standard.as_str().to_string(),
         style_preset: JUMP_HOP_STYLE_MINIMAL_BLOCKS.to_string(),
         character_prompt: "内置默认 3D 角色".to_string(),
-        tile_prompt: format!("{seed}主题的正�30度视角主题物体图集，物体本身作为跳跃�点"),
+        tile_prompt: format!("{seed}主题的3D立方体主题身份方�包装图集"),
         end_mood_prompt: String::new(),
     }
 }
diff --git a/server-rs/crates/spacetime-module/src/jump_hop/types.rs b/server-rs/crates/spacetime-module/src/jump_hop/types.rs
index 42c1d12b..218a4b46 100644
--- a/server-rs/crates/spacetime-module/src/jump_hop/types.rs
+++ b/server-rs/crates/spacetime-module/src/jump_hop/types.rs
@@ -232,6 +232,34 @@ pub struct JumpHopTileAssetSnapshot {
     pub visual_height: u32,
     pub top_surface_radius: f32,
     pub landing_radius: f32,
+    #[serde(default)]
+    pub face_assets: Option<JumpHopTileFaceAssetsSnapshot>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopTileFaceAssetSnapshot {
+    pub face: String,
+    pub asset_id: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub generation_provider: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+    pub source_atlas_cell: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopTileFaceAssetsSnapshot {
+    pub top: JumpHopTileFaceAssetSnapshot,
+    pub front: JumpHopTileFaceAssetSnapshot,
+    pub right: JumpHopTileFaceAssetSnapshot,
+    pub back: JumpHopTileFaceAssetSnapshot,
+    pub left: JumpHopTileFaceAssetSnapshot,
+    pub bottom: JumpHopTileFaceAssetSnapshot,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, SpacetimeType)]
diff --git a/src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx b/src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx
index e5497b6a..0fb789b3 100644
--- a/src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx
+++ b/src/components/jump-hop-runtime/JumpHopRuntimeShell.test.tsx
@@ -8,9 +8,12 @@ import type {
   JumpHopWorkProfileResponse,
 } from '../../../packages/shared/src/contracts/jumpHop';
 import { useResolvedAssetReadUrl } from '../../hooks/useResolvedAssetReadUrl';
-import { buildJumpHopVisiblePlatforms } from '../../services/jump-hop/jumpHopRuntimeModel';
 import { useJumpHopLeaderboard } from '../../services/jump-hop/useJumpHopLeaderboard';
-import { JumpHopRuntimeShell } from './JumpHopRuntimeShell';
+import {
+  JUMP_HOP_THREE_CAMERA_UP_Y,
+  JumpHopRuntimeShell,
+  getJumpHopThreeProjectedY,
+} from './JumpHopRuntimeShell';
 
 vi.mock('../../hooks/useResolvedAssetReadUrl', () => ({
   useResolvedAssetReadUrl: vi.fn((source: string | null | undefined) => ({
@@ -44,22 +47,10 @@ function dispatchPointerEvent(
   target.dispatchEvent(event);
 }
 
-test('跳一跳�行��手时�交��拖动��', async () => {
+test('跳一跳�行��手时��交长按蓄力值', async () => {
   vi.useFakeTimers();
   const onJump = vi.fn().mockResolvedValue(undefined);
   const run = buildRun();
-  const visiblePlatforms = buildJumpHopVisiblePlatforms(run.path, 0, []);
-  const current = visiblePlatforms[0]!;
-  const target = visiblePlatforms[1]!;
-  const stageSize = { width: 320, height: 568 };
-  const xPixelsPerWorldUnit =
-    Math.abs(
-      ((target.screenX - current.screenX) / 100) * stageSize.width,
-    ) / Math.abs(target.platform.x - current.platform.x);
-  const yPixelsPerWorldUnit =
-    Math.abs(
-      ((target.screenY - current.screenY) / 100) * stageSize.height,
-    ) / Math.abs(target.platform.y - current.platform.y);
 
   render(
     <JumpHopRuntimeShell
@@ -85,6 +76,9 @@ test('跳一跳�行��手时�交��拖动��', async () => {
       clientY: 478,
     });
   });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(360);
+  });
 
   await act(async () => {
     dispatchPointerEvent(stage, 'pointerup', {
@@ -96,28 +90,17 @@ test('跳一跳�行��手时�交��拖动��', async () => {
 
   expect(onJump).toHaveBeenCalledTimes(1);
   const jumpPayload = onJump.mock.calls[0]?.[0];
-  expect(jumpPayload?.dragVectorX).toBeCloseTo(-48 / xPixelsPerWorldUnit, 2);
-  expect(jumpPayload?.dragVectorY).toBeCloseTo(58 / yPixelsPerWorldUnit, 2);
-  expect(jumpPayload?.dragDistance).toBeGreaterThan(74);
-  expect(jumpPayload?.dragDistance).toBeLessThan(76);
+  expect(jumpPayload?.dragVectorX).toBeUndefined();
+  expect(jumpPayload?.dragVectorY).toBeUndefined();
+  expect(jumpPayload?.dragDistance).toBeGreaterThanOrEqual(360);
+  expect(jumpPayload?.dragDistance).toBeLessThanOrEqual(380);
   vi.useRealTimers();
 });
 
-test('跳一跳�行�拖拽方�按手指起点到�手点计算', async () => {
+test('跳一跳�行�手指移动�改��交方�', async () => {
+  vi.useFakeTimers();
   const onJump = vi.fn().mockResolvedValue(undefined);
   const run = buildRun();
-  const visiblePlatforms = buildJumpHopVisiblePlatforms(run.path, 0, []);
-  const current = visiblePlatforms[0]!;
-  const target = visiblePlatforms[1]!;
-  const stageSize = { width: 320, height: 568 };
-  const xPixelsPerWorldUnit =
-    Math.abs(
-      ((target.screenX - current.screenX) / 100) * stageSize.width,
-    ) / Math.abs(target.platform.x - current.platform.x);
-  const yPixelsPerWorldUnit =
-    Math.abs(
-      ((target.screenY - current.screenY) / 100) * stageSize.height,
-    ) / Math.abs(target.platform.y - current.platform.y);
 
   render(
     <JumpHopRuntimeShell
@@ -143,6 +126,9 @@ test('跳一跳�行�拖拽方�按手指起点到�手点计算', async ()
       clientY: 20,
     });
   });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(240);
+  });
   await act(async () => {
     dispatchPointerEvent(stage, 'pointerup', {
       pointerId: 1,
@@ -152,15 +138,61 @@ test('跳一跳�行�拖拽方�按手指起点到�手点计算', async ()
   });
 
   const jumpPayload = onJump.mock.calls[0]?.[0];
-  expect(jumpPayload?.dragVectorX).toBeLessThan(0);
-  expect(jumpPayload?.dragVectorY).toBeLessThan(0);
-  expect(Math.abs(jumpPayload?.dragVectorX ?? 0)).toBeLessThan(30);
-  expect(Math.abs(jumpPayload?.dragVectorY ?? 0)).toBeLessThan(20);
-  expect(jumpPayload?.dragVectorX).toBeCloseTo(-30 / xPixelsPerWorldUnit, 2);
-  expect(jumpPayload?.dragVectorY).toBeCloseTo(-20 / yPixelsPerWorldUnit, 2);
+  expect(jumpPayload?.dragVectorX).toBeUndefined();
+  expect(jumpPayload?.dragVectorY).toBeUndefined();
+  expect(jumpPayload?.dragDistance).toBeGreaterThanOrEqual(240);
+  expect(jumpPayload?.dragDistance).toBeLessThanOrEqual(260);
+  vi.useRealTimers();
 });
 
-test('跳一跳�行���显示旧圆弧蓄力�而是显示弹弓拉线', async () => {
+test('跳一跳�行�长按蓄力�会超过�端上�', async () => {
+  vi.useFakeTimers();
+  const onJump = vi.fn().mockResolvedValue(undefined);
+  const baseRun = buildRun();
+  const run: JumpHopRuntimeRunSnapshotResponse = {
+    ...baseRun,
+    path: {
+      ...baseRun.path,
+      scoring: {
+        ...baseRun.path.scoring,
+        maxChargeMs: 300,
+      },
+    },
+  };
+
+  render(
+    <JumpHopRuntimeShell
+      profile={buildProfile()}
+      run={run}
+      onJump={onJump}
+      onRestart={() => {}}
+    />,
+  );
+
+  const stage = screen.getByTestId('jump-hop-stage');
+  await act(async () => {
+    dispatchPointerEvent(stage, 'pointerdown', {
+      pointerId: 1,
+      clientX: 40,
+      clientY: 40,
+    });
+  });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(780);
+  });
+  await act(async () => {
+    dispatchPointerEvent(stage, 'pointerup', {
+      pointerId: 1,
+      clientX: 40,
+      clientY: 40,
+    });
+  });
+
+  expect(onJump.mock.calls[0]?.[0]?.dragDistance).toBe(300);
+  vi.useRealTimers();
+});
+
+test('跳一跳�行���显示旧圆弧蓄力�而是显示长按蓄力引导', async () => {
   const onJump = vi.fn().mockResolvedValue(undefined);
 
   render(
@@ -183,10 +215,12 @@ test('跳一跳�行���显示旧圆弧蓄力�而是显示弹弓拉线',
 
   expect(screen.queryByText('èµ·è·³')).toBeNull();
   expect(stage.querySelector('.jump-hop-runtime__charge-orbit')).toBeNull();
-  expect(stage.querySelector('.jump-hop-runtime__slingshot-guide')).toBeTruthy();
+  expect(stage.querySelector('.jump-hop-runtime__charge-guide')).toBeTruthy();
+  expect(stage.querySelector('.jump-hop-runtime__slingshot-guide')).toBeNull();
 });
 
-test('跳一跳蓄力时角色沿拖拽方�拉伸', async () => {
+test('跳一跳蓄力时角色��垂直压缩', async () => {
+  vi.useFakeTimers();
   render(
     <JumpHopRuntimeShell
       profile={buildProfile({ tileAssets: buildTileAssets() })}
@@ -205,11 +239,7 @@ test('跳一跳蓄力时角色沿拖拽方�拉伸', async () => {
     });
   });
   await act(async () => {
-    dispatchPointerEvent(stage, 'pointermove', {
-      pointerId: 1,
-      clientX: 132,
-      clientY: 478,
-    });
+    await vi.advanceTimersByTimeAsync(180);
   });
 
   const character = screen.getByTestId('jump-hop-character-logo')
@@ -221,12 +251,20 @@ test('跳一跳蓄力时角色沿拖拽方�拉伸', async () => {
     .map((style) => style.textContent ?? '')
     .join('\n');
 
-  expect(stretchTransform).toContain('matrix(');
-  expect(stretchTransform).not.toBe('matrix(1, 0, 0, 1, 0, 0)');
+  expect(stretchTransform).toMatch(/^scale\((?<x>[\d.]+), (?<y>[\d.]+)\)$/);
+  const scaleMatch = stretchTransform.match(
+    /^scale\((?<x>[\d.]+), (?<y>[\d.]+)\)$/,
+  );
+  const scaleX = Number(scaleMatch?.groups?.x ?? 1);
+  const scaleY = Number(scaleMatch?.groups?.y ?? 1);
+  expect(scaleX).toBeGreaterThan(1);
+  expect(scaleY).toBeLessThan(1);
+  expect(scaleY).toBeLessThan(scaleX);
   expect(styleText).toContain('var(--jump-hop-character-stretch-transform)');
   expect(styleText).not.toContain(
     'scaleY(calc(1 - (var(--jump-hop-charge) * 0.16)))',
   );
+  vi.useRealTimers();
 });
 
 test('跳一跳�行�游玩中��留得分并��常驻排行榜', () => {
@@ -379,7 +417,7 @@ test('跳一跳�稿�行失败��请求公开排行榜', () => {
   expect(screen.queryByTestId('jump-hop-runtime-leaderboard')).toBeNull();
 });
 
-test('跳一跳角色层永远压在地�层之上', () => {
+test('跳一跳 Three.js 地�层�于 DOM 角色层下方', () => {
   render(
     <JumpHopRuntimeShell
       profile={buildProfile({ tileAssets: buildTileAssets() })}
@@ -393,13 +431,19 @@ test('跳一跳角色层永远压在地�层之上', () => {
   const firstPlatform = screen.getAllByTestId('jump-hop-tile-image')[0]
     ?.parentElement?.parentElement as HTMLElement | undefined;
 
-  expect(threeScene.style.zIndex).toBe('100');
+  expect(threeScene.style.zIndex).toBe('42');
   expect(Number(threeScene.style.zIndex)).toBeGreaterThan(
     Number(firstPlatform?.style.zIndex ?? 0),
   );
 });
 
-test('跳一跳拖拽时���点辅助标识但�留弹弓拉线', async () => {
+test('跳一跳 Three.js 平�层和 DOM 角色层�����幕�标', () => {
+  expect(JUMP_HOP_THREE_CAMERA_UP_Y).toBe(1);
+  expect(getJumpHopThreeProjectedY(360, 568)).toBeLessThan(284);
+  expect(getJumpHopThreeProjectedY(200, 568)).toBeGreaterThan(284);
+});
+
+test('跳一跳蓄力时���点辅助标识但�留蓄力引导', async () => {
   const onJump = vi.fn().mockResolvedValue(undefined);
 
   render(
@@ -429,7 +473,7 @@ test('跳一跳拖拽时���点辅助标识但�留弹弓拉线', async ()
   });
 
   expect(screen.queryByTestId('jump-hop-landing-assist')).toBeNull();
-  expect(stage.querySelector('.jump-hop-runtime__slingshot-guide')).toBeTruthy();
+  expect(stage.querySelector('.jump-hop-runtime__charge-guide')).toBeTruthy();
 
   await act(async () => {
     dispatchPointerEvent(stage, 'pointermove', {
@@ -440,10 +484,11 @@ test('跳一跳拖拽时���点辅助标识但�留弹弓拉线', async ()
   });
 
   expect(screen.queryByTestId('jump-hop-landing-assist')).toBeNull();
-  expect(stage.querySelector('.jump-hop-runtime__slingshot-guide')).toBeTruthy();
+  expect(stage.querySelector('.jump-hop-runtime__charge-guide')).toBeTruthy();
+  expect(stage.querySelector('.jump-hop-runtime__slingshot-guide')).toBeNull();
 });
 
-test('跳一跳�行�直接渲染生�的地�切片图片', () => {
+test('跳一跳�行�直接渲染生�的地�贴图切片图片', () => {
   render(
     <JumpHopRuntimeShell
       profile={buildProfile({ tileAssets: buildTileAssets() })}
@@ -498,6 +543,48 @@ test('跳一跳�行���预加载下一�地�且�在真实图片加
   );
 });
 
+test('跳一跳新 UV 地�资�会解�六张�贴图而�是�用�张图', () => {
+  render(
+    <JumpHopRuntimeShell
+      profile={buildProfile({ tileAssets: buildTileAssets({ withFaceAssets: true }) })}
+      run={buildRun()}
+      onJump={vi.fn().mockResolvedValue(undefined)}
+      onRestart={() => {}}
+    />,
+  );
+
+  const preloadImages = screen.getAllByTestId('jump-hop-tile-preload-image');
+  const faceImageSources = preloadImages
+    .map((image) => image.getAttribute('src') ?? '')
+    .filter((source) =>
+      source.includes('/generated-jump-hop-assets/jump-hop-profile-test/tile-'),
+    );
+
+  const firstTileMatch = faceImageSources[0]?.match(/tile-(\d{2})-/);
+  const firstTileNumber = firstTileMatch?.[1];
+  expect(firstTileNumber).toBeTruthy();
+  expect(faceImageSources).toEqual(
+    expect.arrayContaining([
+      expect.stringContaining(`/tile-${firstTileNumber}-top/image.png`),
+      expect.stringContaining(`/tile-${firstTileNumber}-front/image.png`),
+      expect.stringContaining(`/tile-${firstTileNumber}-right/image.png`),
+      expect.stringContaining(`/tile-${firstTileNumber}-back/image.png`),
+      expect.stringContaining(`/tile-${firstTileNumber}-left/image.png`),
+      expect.stringContaining(`/tile-${firstTileNumber}-bottom/image.png`),
+    ]),
+  );
+  const frontSource = `/tile-${firstTileNumber}-front/image.png`;
+  const frontRefreshKey = `asset-object-${firstTileNumber}-front`;
+  expect(
+    vi
+      .mocked(useResolvedAssetReadUrl)
+      .mock.calls.some(
+        ([source, options]) =>
+          source?.includes(frontSource) && options?.refreshKey === frontRefreshKey,
+      ),
+  ).toBe(true);
+});
+
 test('跳一跳�行�首�地��在中下方并且�续两��中央和上方展开', () => {
   render(
     <JumpHopRuntimeShell
@@ -513,9 +600,9 @@ test('跳一跳�行�首�地��在中下方并且�续两��中央
   const first = tileImages[0]?.parentElement?.parentElement as HTMLElement | undefined;
   const second = tileImages[1]?.parentElement?.parentElement as HTMLElement | undefined;
   const third = tileImages[2]?.parentElement?.parentElement as HTMLElement | undefined;
-  expect(first?.style.top).toBe('78%');
-  expect(second?.style.top).toBe('50%');
-  expect(third?.style.top).toBe('22%');
+  expect(first?.style.top).toBe('64%');
+  expect(second?.style.top).toBe('47%');
+  expect(third?.style.top).toBe('30%');
 });
 
 test('跳一跳�行�用固定基准宽高和深度 scale 表达地�尺寸', () => {
@@ -604,11 +691,11 @@ test('跳一跳�端回包较慢时角色�在目标点等待推进', async ()
     successfulJumpCount: 1,
     score: 1,
     lastJump: {
-      chargeMs: 150,
-      jumpDistance: 1.44,
+      chargeMs: 420,
+      jumpDistance: 1.68,
       targetPlatformIndex: 1,
-      landedX: 0.8,
-      landedY: 1.2,
+      landedX: 0.93,
+      landedY: 1.4,
       result: 'hit',
     },
   };
@@ -636,6 +723,9 @@ test('跳一跳�端回包较慢时角色�在目标点等待推进', async ()
       clientY: 478,
     });
   });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(420);
+  });
   await act(async () => {
     dispatchPointerEvent(stage, 'pointerup', {
       pointerId: 1,
@@ -678,6 +768,63 @@ test('跳一跳�端回包较慢时角色�在目标点等待推进', async ()
   vi.useRealTimers();
 });
 
+test('跳一跳�功�点�移�下一跳视觉��下一�地�方�', async () => {
+  vi.useFakeTimers();
+  const onJump = vi.fn().mockResolvedValue(undefined);
+  const run: JumpHopRuntimeRunSnapshotResponse = {
+    ...buildRun(),
+    currentPlatformIndex: 1,
+    successfulJumpCount: 1,
+    score: 1,
+    lastJump: {
+      chargeMs: 300,
+      jumpDistance: 1.0,
+      targetPlatformIndex: 1,
+      landedX: 0,
+      landedY: 1.2,
+      result: 'hit',
+    },
+  };
+
+  render(
+    <JumpHopRuntimeShell
+      profile={buildProfile({ tileAssets: buildTileAssets() })}
+      run={run}
+      onJump={onJump}
+      onRestart={() => {}}
+    />,
+  );
+
+  const character = screen.getByTestId('jump-hop-character-logo')
+    .parentElement as HTMLElement;
+  const initialLeft = Number.parseFloat(character.style.left);
+  const initialTop = Number.parseFloat(character.style.top);
+  const stage = screen.getByTestId('jump-hop-stage');
+
+  await act(async () => {
+    dispatchPointerEvent(stage, 'pointerdown', {
+      pointerId: 1,
+      clientX: 180,
+      clientY: 420,
+    });
+  });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(120);
+  });
+  await act(async () => {
+    dispatchPointerEvent(stage, 'pointerup', {
+      pointerId: 1,
+      clientX: 180,
+      clientY: 420,
+    });
+  });
+
+  expect(onJump).toHaveBeenCalledTimes(1);
+  expect(Number.parseFloat(character.style.left)).toBeLessThan(initialLeft);
+  expect(Number.parseFloat(character.style.top)).toBeLessThan(initialTop);
+  vi.useRealTimers();
+});
+
 test('跳一跳�手�先播放飞行动画�切�到下一�地�', async () => {
   vi.useFakeTimers();
   const onJump = vi.fn().mockResolvedValue(undefined);
@@ -688,11 +835,25 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
     successfulJumpCount: 1,
     score: 1,
     lastJump: {
-      chargeMs: 150,
-      jumpDistance: 1.44,
+      chargeMs: 420,
+      jumpDistance: 1.68,
       targetPlatformIndex: 1,
-      landedX: 0.8,
-      landedY: 1.2,
+      landedX: 0.93,
+      landedY: 1.4,
+      result: 'hit',
+    },
+  };
+  const runAfterSecondJump: JumpHopRuntimeRunSnapshotResponse = {
+    ...buildRunWithExtraPreviewPlatform(),
+    currentPlatformIndex: 2,
+    successfulJumpCount: 2,
+    score: 2,
+    lastJump: {
+      chargeMs: 360,
+      jumpDistance: 1.44,
+      targetPlatformIndex: 2,
+      landedX: -0.2,
+      landedY: 2.4,
       result: 'hit',
     },
   };
@@ -720,6 +881,9 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
       clientY: 478,
     });
   });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(420);
+  });
   await act(async () => {
     dispatchPointerEvent(stage, 'pointerup', {
       pointerId: 1,
@@ -731,7 +895,7 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
   expect(onJump).toHaveBeenCalledTimes(1);
   expect(stage.getAttribute('data-jump-animating')).toBe('true');
   expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.style.top).toBe(
-    '78%',
+    '64%',
   );
   expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.getAttribute('data-current')).toBe(
     'true',
@@ -753,7 +917,7 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
     'true',
   );
   expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.style.top).toBe(
-    '78%',
+    '64%',
   );
   expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.getAttribute('data-current')).toBe(
     'true',
@@ -775,6 +939,8 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
   const landedCharacter = screen.getByTestId('jump-hop-character-logo')
     .parentElement as HTMLElement;
   expect(landedCharacter.getAttribute('data-landing-recoil')).toBe('true');
+  expect(Number.parseFloat(landedCharacter.style.left)).not.toBeCloseTo(50, 1);
+  expect(Number.parseFloat(landedCharacter.style.top)).not.toBeCloseTo(75, 1);
   expect(landedCharacter.style.getPropertyValue('--jump-hop-recoil-x')).not.toBe(
     '0px',
   );
@@ -783,18 +949,23 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
   );
   const cameraLayer = screen.getByTestId('jump-hop-camera-layer');
   expect(cameraLayer.getAttribute('data-platform-advancing')).toBe('true');
+  expect(cameraLayer.style.getPropertyValue('--jump-hop-camera-zoom')).toBe(
+    '1.3',
+  );
   expect(cameraLayer.style.getPropertyValue('--jump-hop-camera-shift-y')).toBe(
-    '-28%',
+    '-17%',
   );
   expect(
     Number.parseFloat(
       cameraLayer.style.getPropertyValue('--jump-hop-camera-shift-x'),
     ),
-  ).toBeCloseTo(12.29, 2);
+  ).toBeCloseTo(8.96, 2);
   const styleText = Array.from(document.querySelectorAll('style'))
     .map((style) => style.textContent ?? '')
     .join('\n');
   expect(styleText).toContain('@keyframes jump-hop-character-recoil');
+  expect(styleText).not.toContain('@keyframes jump-hop-platform-exit-drift');
+  expect(styleText).toContain('scale(var(--jump-hop-camera-zoom, 1))');
   expect(styleText).toMatch(
     /data-platform-advancing='true'\]\s+\.jump-hop-runtime__platform[\s\S]*transform 1440ms cubic-bezier/,
   );
@@ -826,7 +997,7 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
     'p1',
   );
   expect(screen.getAllByTestId('jump-hop-tile-image')[1]?.parentElement?.parentElement?.style.top).toBe(
-    '78%',
+    '64%',
   );
   expect(screen.getAllByTestId('jump-hop-tile-image')[1]?.parentElement?.parentElement?.style.getPropertyValue('--jump-hop-platform-scale')).toBe(
     '1.08',
@@ -835,7 +1006,7 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
     'p2',
   );
   expect(screen.getAllByTestId('jump-hop-tile-image')[2]?.parentElement?.parentElement?.style.top).toBe(
-    '50%',
+    '47%',
   );
 
   await act(async () => {
@@ -870,19 +1041,78 @@ test('跳一跳�手�先播放飞行动画�切�到下一�地�', async
   expect(screen.getByTestId('jump-hop-camera-layer').getAttribute('data-platform-advancing')).toBe(
     'false',
   );
-  expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.style.top).toBe(
-    '78%',
+  const retainedOldPlatform = screen
+    .getByTestId('jump-hop-stage')
+    .querySelector("[data-platform-id='p0']") as HTMLElement | null;
+  expect(retainedOldPlatform?.getAttribute('data-advance-state')).toBe(
+    'exiting',
   );
-  expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.getAttribute('data-current')).toBe(
+  expect(retainedOldPlatform?.style.top).toBe('81%');
+  const currentPlatform = screen
+    .getByTestId('jump-hop-stage')
+    .querySelector("[data-platform-id='p1']") as HTMLElement | null;
+  expect(currentPlatform?.style.top).toBe('64%');
+  expect(currentPlatform?.getAttribute('data-current')).toBe(
     'true',
   );
-  expect(screen.getAllByTestId('jump-hop-tile-image')[0]?.parentElement?.parentElement?.getAttribute('data-platform-id')).toBe(
+  expect(currentPlatform?.getAttribute('data-platform-id')).toBe(
     'p1',
   );
-  expect(screen.getAllByTestId('jump-hop-tile-image')[1]?.parentElement?.parentElement?.style.top).toBe(
-    '50%',
+  expect(
+    (
+      screen
+        .getByTestId('jump-hop-stage')
+        .querySelector("[data-platform-id='p2']") as HTMLElement | null
+    )?.style.top,
+  ).toBe('47%');
+
+  await act(async () => {
+    dispatchPointerEvent(stage, 'pointerdown', {
+      pointerId: 2,
+      clientX: 180,
+      clientY: 420,
+    });
+  });
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(160);
+  });
+  await act(async () => {
+    dispatchPointerEvent(stage, 'pointerup', {
+      pointerId: 2,
+      clientX: 180,
+      clientY: 420,
+    });
+  });
+
+  expect(onJump).toHaveBeenCalledTimes(2);
+
+  rerender(
+    <JumpHopRuntimeShell
+      profile={buildProfile({ tileAssets: buildTileAssets() })}
+      run={runAfterSecondJump}
+      onJump={onJump}
+      onRestart={() => {}}
+    />,
   );
 
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(580);
+  });
+
+  const movedOldPlatform = screen
+    .getByTestId('jump-hop-stage')
+    .querySelector("[data-platform-id='p0']") as HTMLElement | null;
+  if (movedOldPlatform) {
+    expect(Number.parseFloat(movedOldPlatform.style.top)).toBeGreaterThan(81);
+  }
+  expect(
+    (
+      screen
+        .getByTestId('jump-hop-stage')
+        .querySelector("[data-current='true']") as HTMLElement | null
+    )?.getAttribute('data-platform-id'),
+  ).toBe('p2');
+
   vi.useRealTimers();
 });
 
@@ -994,22 +1224,51 @@ function buildRunWithExtraPreviewPlatform(): JumpHopRuntimeRunSnapshotResponse {
   };
 }
 
-function buildTileAssets() {
-  return Array.from({ length: 25 }, (_, index) => {
+function buildTileAssets(options: { withFaceAssets?: boolean } = {}) {
+  return Array.from({ length: 18 }, (_, index) => {
     const tileNumber = String(index + 1).padStart(2, '0');
+    const atlasRow = Math.floor(index / 3) + 1;
+    const atlasCol = (index % 3) + 1;
+    const buildFaceAsset = (
+      face: keyof NonNullable<
+        JumpHopWorkProfileResponse['tileAssets'][number]['faceAssets']
+      >,
+    ) => ({
+      face,
+      assetId: `asset-${tileNumber}-${face}`,
+      imageSrc: `/generated-jump-hop-assets/jump-hop-profile-test/tile-${tileNumber}-${face}/image.png`,
+      imageObjectKey: `generated-jump-hop-assets/jump-hop-profile-test/tile-${tileNumber}-${face}/image.png`,
+      assetObjectId: `asset-object-${tileNumber}-${face}`,
+      generationProvider: 'vector-engine',
+      prompt: `tile ${tileNumber} ${face}`,
+      width: 256,
+      height: 256,
+      sourceAtlasCell: `row-${atlasRow}-col-${atlasCol}/${face}`,
+    });
+    const faceAssets: NonNullable<
+      JumpHopWorkProfileResponse['tileAssets'][number]['faceAssets']
+    > = {
+      top: buildFaceAsset('top'),
+      front: buildFaceAsset('front'),
+      right: buildFaceAsset('right'),
+      back: buildFaceAsset('back'),
+      left: buildFaceAsset('left'),
+      bottom: buildFaceAsset('bottom'),
+    };
     return {
       tileType: index === 0 ? 'start' : 'normal',
       tileId: `tile-${tileNumber}`,
       imageSrc: `/generated-jump-hop-assets/jump-hop-profile-test/tile-${tileNumber}/image.png`,
       imageObjectKey: `generated-jump-hop-assets/jump-hop-profile-test/tile-${tileNumber}/image.png`,
       assetObjectId: `asset-object-${tileNumber}`,
-      sourceAtlasCell: `row-${Math.floor(index / 5) + 1}-col-${(index % 5) + 1}`,
-      atlasRow: Math.floor(index / 5) + 1,
-      atlasCol: (index % 5) + 1,
+      sourceAtlasCell: `row-${atlasRow}-col-${atlasCol}`,
+      atlasRow,
+      atlasCol,
       visualWidth: 256,
-      visualHeight: 192,
+      visualHeight: 256,
       topSurfaceRadius: 42,
       landingRadius: 34,
+      faceAssets: options.withFaceAssets ? faceAssets : undefined,
     } satisfies JumpHopWorkProfileResponse['tileAssets'][number];
   });
 }
diff --git a/src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx b/src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx
index b0c9f1f4..3855216b 100644
--- a/src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx
+++ b/src/components/jump-hop-runtime/JumpHopRuntimeShell.tsx
@@ -14,15 +14,19 @@ import {
 import jumpHopRuntimeLevelLogo from '../../../media/logo.png';
 import type {
   JumpHopRuntimeRunSnapshotResponse,
+  JumpHopTileFaceAsset,
   JumpHopTileAsset,
   JumpHopWorkProfileResponse,
 } from '../../../packages/shared/src/contracts/jumpHop';
 import { useResolvedAssetReadUrl } from '../../hooks/useResolvedAssetReadUrl';
+import {
+  isGeneratedLegacyPath,
+  readAssetBytes,
+} from '../../services/assetReadUrlService';
 import type { JumpHopRuntimeRequestOptions } from '../../services/jump-hop/jumpHopClient';
 import {
   buildJumpHopVisiblePlatforms,
   formatJumpHopDurationLabel,
-  getJumpHopBackendDragVector,
   getJumpHopCharacterVisualPosition,
   getJumpHopJumpFeedbackLabel,
   getJumpHopLandingAssistVisualPosition,
@@ -40,8 +44,8 @@ import { RuntimeResourcePendingMarker } from '../common/RuntimeResourcePendingMa
 
 type JumpHopRuntimeJumpPayload = {
   dragDistance: number;
-  dragVectorX: number;
-  dragVectorY: number;
+  dragVectorX?: number;
+  dragVectorY?: number;
 };
 
 type JumpHopVisualJump = {
@@ -49,6 +53,25 @@ type JumpHopVisualJump = {
   to: JumpHopCharacterVisualPosition;
 };
 
+type JumpHopPlatformRenderItem = JumpHopVisiblePlatform & {
+  renderKey: string;
+  advanceState: 'exiting' | 'camera' | 'idle';
+};
+
+type JumpHopTilePreloadItem = {
+  textureKey: string;
+  asset: JumpHopTileAsset;
+};
+
+type JumpHopTileFaceKey = 'top' | 'front' | 'right' | 'back' | 'left' | 'bottom';
+
+type JumpHopTileTextureSource = {
+  imageSrc: string;
+  imageObjectKey?: string;
+  assetObjectId?: string;
+  tileId?: string;
+};
+
 type JumpHopRuntimeShellProps = {
   profile?: JumpHopWorkProfileResponse | null;
   run?: JumpHopRuntimeRunSnapshotResponse | null;
@@ -67,9 +90,25 @@ const DEFAULT_MAX_DRAG_DISTANCE_PX = 180;
 const JUMP_HOP_ANIMATION_DURATION_MS = 560;
 const JUMP_HOP_LANDING_RECOIL_DURATION_MS = 560;
 const JUMP_HOP_PLATFORM_ADVANCE_DURATION_MS = 1440;
+const JUMP_HOP_PLATFORM_RETAIN_OFFSCREEN_SCREEN_Y = 122;
+const JUMP_HOP_CAMERA_ZOOM = 1.3;
 const JUMP_HOP_TAONIER_CHARACTER_IMAGE_SRC =
   '/branding/jump-hop-taonier-character.png';
 const JUMP_HOP_TILE_PRELOAD_LOOKAHEAD_COUNT = 3;
+const JUMP_HOP_TILE_FACE_KEYS: JumpHopTileFaceKey[] = [
+  'top',
+  'front',
+  'right',
+  'back',
+  'left',
+  'bottom',
+];
+const JUMP_HOP_THREE_CAMERA_PITCH_RAD = Math.PI / 4;
+const JUMP_HOP_THREE_CAMERA_PITCH_COS = Math.cos(
+  JUMP_HOP_THREE_CAMERA_PITCH_RAD,
+);
+export const JUMP_HOP_THREE_CAMERA_UP_Y = 1;
+const JUMP_HOP_THREE_CAMERA_DISTANCE_MULTIPLIER = 1.34;
 
 function clamp(value: number, min: number, max: number) {
   return Math.min(max, Math.max(min, value));
@@ -82,36 +121,6 @@ function formatJumpHopCssNumber(value: number) {
   return value.toFixed(4).replace(/\.?0+$/, '');
 }
 
-function buildJumpHopDirectionalScaleMatrix({
-  directionX,
-  directionY,
-  stretchScale,
-  crossScale,
-}: {
-  directionX: number;
-  directionY: number;
-  stretchScale: number;
-  crossScale: number;
-}) {
-  const distance = Math.hypot(directionX, directionY);
-  if (distance < 0.1) {
-    return 'matrix(1, 0, 0, 1, 0, 0)';
-  }
-
-  const unitX = directionX / distance;
-  const unitY = directionY / distance;
-  const stretchDelta = stretchScale - crossScale;
-  const a = crossScale + stretchDelta * unitX * unitX;
-  const b = stretchDelta * unitX * unitY;
-  const c = stretchDelta * unitX * unitY;
-  const d = crossScale + stretchDelta * unitY * unitY;
-  return `matrix(${formatJumpHopCssNumber(a)}, ${formatJumpHopCssNumber(
-    b,
-  )}, ${formatJumpHopCssNumber(c)}, ${formatJumpHopCssNumber(
-    d,
-  )}, 0, 0)`;
-}
-
 function getRun(
   run: JumpHopRuntimeRunSnapshotResponse | null | undefined,
   snapshot: JumpHopRuntimeRunSnapshotResponse | null | undefined,
@@ -173,6 +182,41 @@ function buildJumpHopCharacterVisualPositionFromPlatform(
   };
 }
 
+function getJumpHopRunLandingVisualPosition({
+  run,
+  platforms,
+  stageSize,
+}: {
+  run: JumpHopRuntimeRunSnapshotResponse;
+  platforms: JumpHopVisiblePlatform[];
+  stageSize: { width: number; height: number };
+}) {
+  const lastJump = run.lastJump;
+  if (!lastJump || stageSize.width <= 0 || stageSize.height <= 0) {
+    return null;
+  }
+
+  return getJumpHopCharacterVisualPosition(run, platforms, stageSize);
+}
+
+function getJumpHopThreeCubeSide(
+  platform: JumpHopVisiblePlatform['platform'],
+  scale: number,
+) {
+  const platformSize = getJumpHopPlatformVisualSize(platform, scale);
+  return Math.max(56, Math.min(platformSize.width, platformSize.height) * 0.86);
+}
+
+export function getJumpHopThreeProjectedY(
+  screenY: number,
+  viewportHeight: number,
+) {
+  return (
+    viewportHeight / 2 +
+    (viewportHeight / 2 - screenY) / JUMP_HOP_THREE_CAMERA_PITCH_COS
+  );
+}
+
 function IsometricFallbackTile({
   platform,
 }: {
@@ -196,10 +240,104 @@ function IsometricFallbackTile({
   );
 }
 
-function getJumpHopTileAssetRefreshKey(asset: JumpHopTileAsset | null) {
+function getJumpHopTileAssetRefreshKey(
+  asset: JumpHopTileTextureSource | null | undefined,
+) {
   return asset?.assetObjectId || asset?.imageObjectKey || asset?.tileId || null;
 }
 
+function getJumpHopTileFaceAsset(
+  asset: JumpHopTileAsset | null | undefined,
+  face: JumpHopTileFaceKey,
+): JumpHopTileFaceAsset | null {
+  return asset?.faceAssets?.[face] ?? null;
+}
+
+function getJumpHopTileTextureSource(
+  asset: JumpHopTileAsset | null | undefined,
+  face?: JumpHopTileFaceKey,
+): JumpHopTileTextureSource | null {
+  const faceAsset = face ? getJumpHopTileFaceAsset(asset, face) : null;
+  if (faceAsset?.imageSrc) {
+    return {
+      imageSrc: faceAsset.imageSrc,
+      imageObjectKey: faceAsset.imageObjectKey,
+      assetObjectId: faceAsset.assetObjectId,
+      tileId: `${asset?.tileId ?? asset?.sourceAtlasCell ?? 'tile'}-${face}`,
+    };
+  }
+  if (!asset?.imageSrc) {
+    return null;
+  }
+  return {
+    imageSrc: asset.imageSrc,
+    imageObjectKey: asset.imageObjectKey,
+    assetObjectId: asset.assetObjectId,
+    tileId: asset.tileId ?? asset.sourceAtlasCell,
+  };
+}
+
+function getJumpHopTileTextureKey(renderKey: string, face: JumpHopTileFaceKey) {
+  return `${renderKey}::${face}`;
+}
+
+function getJumpHopTileTextureUrl(
+  textureUrls: Record<string, string>,
+  renderKey: string,
+  face: JumpHopTileFaceKey,
+) {
+  return textureUrls[getJumpHopTileTextureKey(renderKey, face)] ?? textureUrls[renderKey] ?? '';
+}
+
+function hasJumpHopTileTexturesReady(
+  textureUrls: Record<string, string>,
+  renderKey: string,
+  asset: JumpHopTileAsset | null | undefined,
+) {
+  if (!asset?.imageSrc) {
+    return true;
+  }
+  if (!asset.faceAssets) {
+    return Boolean(textureUrls[renderKey]);
+  }
+  return JUMP_HOP_TILE_FACE_KEYS.every((face) =>
+    Boolean(textureUrls[getJumpHopTileTextureKey(renderKey, face)]),
+  );
+}
+
+function getJumpHopActiveTextureKeys(
+  renderKey: string,
+  asset: JumpHopTileAsset | null | undefined,
+) {
+  if (!asset?.faceAssets) {
+    return [renderKey];
+  }
+  return [
+    renderKey,
+    ...JUMP_HOP_TILE_FACE_KEYS.map((face) =>
+      getJumpHopTileTextureKey(renderKey, face),
+    ),
+  ];
+}
+
+function buildJumpHopTileTextureEntries(
+  asset: JumpHopTileAsset,
+  textureKey: string,
+) {
+  if (!asset.faceAssets) {
+    const source = getJumpHopTileTextureSource(asset);
+    return source ? [{ textureKey, source }] : [];
+  }
+
+  return JUMP_HOP_TILE_FACE_KEYS.map((face) => ({
+    textureKey: getJumpHopTileTextureKey(textureKey, face),
+    source: getJumpHopTileTextureSource(asset, face),
+  })).filter(
+    (item): item is { textureKey: string; source: JumpHopTileTextureSource } =>
+      Boolean(item.source?.imageSrc),
+  );
+}
+
 function isJumpHopGeneratedBackgroundSource(source: string | null | undefined) {
   const value = source?.trim() ?? '';
   if (!value) {
@@ -214,13 +352,22 @@ function isJumpHopGeneratedBackgroundSource(source: string | null | undefined) {
 function JumpHopTileImage({
   asset,
   platform,
+  textureKey,
+  onResolvedTextureUrl,
 }: {
   asset: JumpHopTileAsset | null;
   platform: JumpHopVisiblePlatform['platform'];
+  textureKey?: string;
+  onResolvedTextureUrl?: (
+    textureKey: string,
+    resolvedUrl: string,
+    options?: { parentOwnedObjectUrl?: boolean },
+  ) => void;
 }) {
-  const assetRefreshKey = getJumpHopTileAssetRefreshKey(asset);
+  const textureSource = getJumpHopTileTextureSource(asset, 'top');
+  const assetRefreshKey = getJumpHopTileAssetRefreshKey(textureSource);
   const { resolvedUrl, isResolving } = useResolvedAssetReadUrl(
-    asset?.imageSrc,
+    textureSource?.imageSrc,
     {
       refreshKey: assetRefreshKey,
     },
@@ -236,14 +383,82 @@ function JumpHopTileImage({
   const shouldShowImage = Boolean(resolvedUrl && !hasError);
   const shouldShowFallback = !shouldShowImage;
 
+  useEffect(() => {
+    if (!textureKey || !onResolvedTextureUrl) {
+      return;
+    }
+
+    let disposed = false;
+    const assetSource = textureSource?.imageSrc?.trim() ?? '';
+    const publishTextureUrl = (
+      url: string,
+      options?: { parentOwnedObjectUrl?: boolean },
+    ) => {
+      if (!disposed) {
+        onResolvedTextureUrl(textureKey, url, options);
+      }
+    };
+
+    publishTextureUrl('');
+    if (!assetSource || !shouldShowImage || !isLoaded) {
+      return () => {
+        disposed = true;
+      };
+    }
+
+    if (!isGeneratedLegacyPath(assetSource)) {
+      publishTextureUrl(resolvedUrl ?? '');
+      return () => {
+        disposed = true;
+      };
+    }
+
+    // 中文注释：Three.js 纹��能直接�赖跨域 OSS 签� URL；转��字节为 blob，�� bucket CORS 导致 WebGL 贴图失败。
+    void readAssetBytes(assetSource)
+      .then((response) => response.blob())
+      .then((blob) => {
+        if (disposed) {
+          return;
+        }
+        publishTextureUrl(URL.createObjectURL(blob), {
+          parentOwnedObjectUrl: true,
+        });
+      })
+      .catch(() => {
+        publishTextureUrl('');
+      });
+
+    return () => {
+      disposed = true;
+      onResolvedTextureUrl(textureKey, '');
+    };
+  }, [
+    isLoaded,
+    onResolvedTextureUrl,
+    resolvedUrl,
+    shouldShowImage,
+    textureSource?.imageSrc,
+    textureKey,
+  ]);
+
   return (
     <div className="jump-hop-runtime__tile-image-stack">
       <RuntimeResourcePendingMarker
-        source={asset?.imageSrc}
+        source={textureSource?.imageSrc}
         kind="image"
         isPending={isResolving}
       />
       {shouldShowFallback ? <IsometricFallbackTile platform={platform} /> : null}
+      {asset?.faceAssets && textureKey
+        ? buildJumpHopTileTextureEntries(asset, textureKey).map((item) => (
+            <JumpHopTileTextureImage
+              key={item.textureKey}
+              source={item.source}
+              textureKey={item.textureKey}
+              onResolvedTextureUrl={onResolvedTextureUrl}
+            />
+          ))
+        : null}
       {shouldShowImage ? (
         <img
           src={resolvedUrl}
@@ -265,16 +480,79 @@ function JumpHopTileImage({
   );
 }
 
-function JumpHopTilePreloadImage({ asset }: { asset: JumpHopTileAsset }) {
-  const assetRefreshKey = getJumpHopTileAssetRefreshKey(asset);
-  const { resolvedUrl, isResolving } = useResolvedAssetReadUrl(asset.imageSrc, {
+function JumpHopTileTextureImage({
+  source,
+  textureKey,
+  onResolvedTextureUrl,
+}: {
+  source: JumpHopTileTextureSource;
+  textureKey: string;
+  onResolvedTextureUrl?: (
+    textureKey: string,
+    resolvedUrl: string,
+    options?: { parentOwnedObjectUrl?: boolean },
+  ) => void;
+}) {
+  const assetRefreshKey = getJumpHopTileAssetRefreshKey(source);
+  const { resolvedUrl, isResolving } = useResolvedAssetReadUrl(source.imageSrc, {
     refreshKey: assetRefreshKey,
   });
 
+  useEffect(() => {
+    if (!textureKey || !onResolvedTextureUrl) {
+      return undefined;
+    }
+
+    let disposed = false;
+    const assetSource = source.imageSrc?.trim() ?? '';
+    const publishTextureUrl = (
+      url: string,
+      options?: { parentOwnedObjectUrl?: boolean },
+    ) => {
+      if (!disposed) {
+        onResolvedTextureUrl(textureKey, url, options);
+      }
+    };
+
+    if (!assetSource || !resolvedUrl) {
+      return () => {
+        disposed = true;
+      };
+    }
+
+    if (!isGeneratedLegacyPath(assetSource)) {
+      publishTextureUrl(resolvedUrl);
+      return () => {
+        disposed = true;
+      };
+    }
+
+    void readAssetBytes(assetSource)
+      .then((response) => response.blob())
+      .then((blob) => {
+        if (disposed) {
+          return;
+        }
+        publishTextureUrl(URL.createObjectURL(blob), {
+          parentOwnedObjectUrl: true,
+        });
+      })
+      .catch(() => {});
+
+    return () => {
+      disposed = true;
+    };
+  }, [
+    onResolvedTextureUrl,
+    resolvedUrl,
+    source.imageSrc,
+    textureKey,
+  ]);
+
   if (!resolvedUrl) {
     return (
       <RuntimeResourcePendingMarker
-        source={asset.imageSrc}
+        source={source.imageSrc}
         kind="image"
         isPending={isResolving}
       />
@@ -284,7 +562,7 @@ function JumpHopTilePreloadImage({ asset }: { asset: JumpHopTileAsset }) {
   return (
     <>
       <RuntimeResourcePendingMarker
-        source={asset.imageSrc}
+        source={source.imageSrc}
         kind="image"
         isPending={isResolving}
       />
@@ -300,6 +578,35 @@ function JumpHopTilePreloadImage({ asset }: { asset: JumpHopTileAsset }) {
   );
 }
 
+function JumpHopTilePreloadImage({
+  asset,
+  textureKey,
+  onResolvedTextureUrl,
+}: {
+  asset: JumpHopTileAsset;
+  textureKey: string;
+  onResolvedTextureUrl?: (
+    textureKey: string,
+    resolvedUrl: string,
+    options?: { parentOwnedObjectUrl?: boolean },
+  ) => void;
+}) {
+  const sources = buildJumpHopTileTextureEntries(asset, textureKey);
+
+  return (
+    <>
+      {sources.map((item) => (
+        <JumpHopTileTextureImage
+          key={item.textureKey}
+          source={item.source}
+          textureKey={item.textureKey}
+          onResolvedTextureUrl={onResolvedTextureUrl}
+        />
+      ))}
+    </>
+  );
+}
+
 function hasJumpHopWebGLSupport() {
   if (import.meta.env.MODE === 'test') {
     return false;
@@ -338,21 +645,29 @@ function JumpHopThreeScene({
   characterPosition,
   chargeRatio,
   isJumpAnimating,
+  platforms,
   platformCount,
   renderCharacter,
+  textureUrlsByRenderKey,
   onCharacterLayerReadyChange,
+  onPlatformLayerReadyChange,
 }: {
   characterPosition: JumpHopCharacterVisualPosition | null;
   chargeRatio: number;
   isJumpAnimating: boolean;
+  platforms: JumpHopPlatformRenderItem[];
   platformCount: number;
   renderCharacter: boolean;
+  textureUrlsByRenderKey: Record<string, string>;
   onCharacterLayerReadyChange: Dispatch<SetStateAction<boolean>>;
+  onPlatformLayerReadyChange: Dispatch<SetStateAction<boolean>>;
 }) {
   const hostRef = useRef<HTMLDivElement | null>(null);
   const characterPositionRef = useRef(characterPosition);
   const chargeRatioRef = useRef(chargeRatio);
   const isJumpAnimatingRef = useRef(isJumpAnimating);
+  const platformsRef = useRef(platforms);
+  const textureUrlsByRenderKeyRef = useRef(textureUrlsByRenderKey);
 
   useEffect(() => {
     characterPositionRef.current = characterPosition;
@@ -366,6 +681,14 @@ function JumpHopThreeScene({
     isJumpAnimatingRef.current = isJumpAnimating;
   }, [isJumpAnimating]);
 
+  useEffect(() => {
+    platformsRef.current = platforms;
+  }, [platforms]);
+
+  useEffect(() => {
+    textureUrlsByRenderKeyRef.current = textureUrlsByRenderKey;
+  }, [textureUrlsByRenderKey]);
+
   useEffect(() => {
     const host = hostRef.current;
     if (!host) {
@@ -373,15 +696,17 @@ function JumpHopThreeScene({
     }
 
     onCharacterLayerReadyChange(false);
+    onPlatformLayerReadyChange(false);
     host.replaceChildren();
     const fallbackCanvas = document.createElement('canvas');
     applyJumpHopCanvasLayout(fallbackCanvas);
     fallbackCanvas.setAttribute('data-testid', 'jump-hop-three-canvas');
     host.appendChild(fallbackCanvas);
 
-    if (!renderCharacter || !hasJumpHopWebGLSupport()) {
+    if (!hasJumpHopWebGLSupport()) {
       return () => {
         onCharacterLayerReadyChange(false);
+        onPlatformLayerReadyChange(false);
         fallbackCanvas.remove();
       };
     }
@@ -391,7 +716,10 @@ function JumpHopThreeScene({
     let cleanup: (() => void) | null = null;
 
     const setup = async () => {
-      const three = await import('three');
+      const [three, roundedBoxModule] = await Promise.all([
+        import('three'),
+        import('three/examples/jsm/geometries/RoundedBoxGeometry.js'),
+      ]);
       if (disposed || !hostRef.current) {
         return;
       }
@@ -403,66 +731,290 @@ function JumpHopThreeScene({
       });
       renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 1.8));
       renderer.outputColorSpace = three.SRGBColorSpace;
+      renderer.sortObjects = true;
 
       const scene = new three.Scene();
       scene.background = null;
 
-      const camera = new three.OrthographicCamera(0, 320, 0, 568, -100, 100);
-      camera.position.set(0, 0, 50);
-      camera.lookAt(0, 0, 0);
+      const camera = new three.OrthographicCamera(
+        -160,
+        160,
+        284,
+        -284,
+        1,
+        2400,
+      );
+      // 中文注释：�� Three 平�层和 DOM 角色层的�幕 X 轴��，�� WebGL 地�左�镜��让跳跃看起���。
+      camera.up.set(0, JUMP_HOP_THREE_CAMERA_UP_Y, 0);
 
-      scene.add(new three.AmbientLight(0xffffff, 1.45));
-      const keyLight = new three.DirectionalLight(0xffffff, 2.2);
-      keyLight.position.set(-80, 120, 80);
+      scene.add(new three.AmbientLight(0xffffff, 1.22));
+      const keyLight = new three.DirectionalLight(0xffffff, 2.45);
+      keyLight.position.set(-90, 105, 110);
       scene.add(keyLight);
-      const rimLight = new three.DirectionalLight(0xffedd5, 0.8);
-      rimLight.position.set(120, 80, 60);
+      const fillLight = new three.DirectionalLight(0xfef3c7, 0.82);
+      fillLight.position.set(110, 96, 70);
+      scene.add(fillLight);
+      const rimLight = new three.DirectionalLight(0xffedd5, 0.64);
+      rimLight.position.set(120, 44, 120);
       scene.add(rimLight);
 
-      const character = new three.Group();
-      const body = new three.Mesh(
-        new three.CapsuleGeometry(10, 22, 8, 18),
-        new three.MeshStandardMaterial({
-          color: 0xdf7f40,
-          roughness: 0.74,
-        }),
-      );
-      body.position.y = -28;
-      const head = new three.Mesh(
-        new three.SphereGeometry(11, 28, 20),
-        new three.MeshStandardMaterial({
-          color: 0xf59e0b,
-          roughness: 0.7,
-        }),
-      );
-      head.position.y = -62;
-      const accent = new three.Mesh(
-        new three.BoxGeometry(15, 7, 7),
-        new three.MeshStandardMaterial({
-          color: 0x2563eb,
-          roughness: 0.64,
-        }),
-      );
-      accent.position.set(0, -36, 10);
-      character.add(body, head, accent);
-      scene.add(character);
+      const character = renderCharacter ? new three.Group() : null;
+      if (character) {
+        const body = new three.Mesh(
+          new three.CapsuleGeometry(10, 22, 8, 18),
+          new three.MeshStandardMaterial({
+            color: 0xdf7f40,
+            roughness: 0.74,
+          }),
+        );
+        body.position.y = -28;
+        const head = new three.Mesh(
+          new three.SphereGeometry(11, 28, 20),
+          new three.MeshStandardMaterial({
+            color: 0xf59e0b,
+            roughness: 0.7,
+          }),
+        );
+        head.position.y = -62;
+        const accent = new three.Mesh(
+          new three.BoxGeometry(15, 7, 7),
+          new three.MeshStandardMaterial({
+            color: 0x2563eb,
+            roughness: 0.64,
+          }),
+        );
+        accent.position.set(0, -36, 10);
+        character.add(body, head, accent);
+        scene.add(character);
+      }
 
-      const size = {
+      const platformGroup = new three.Group();
+      platformGroup.renderOrder = 20;
+      scene.add(platformGroup);
+
+      // 中文注释：平�几何�创建一份，�行���等比缩放，��标准 1x1x1 立方体规格。
+      const platformGeometry = new roundedBoxModule.RoundedBoxGeometry(
+        1,
+        1,
+        1,
+        2,
+        0.035,
+      );
+      const shadowGeometry = new three.CircleGeometry(1, 48);
+      const shadowMaterial = new three.MeshBasicMaterial({
+        color: 0x0f172a,
+        depthWrite: false,
+        opacity: 0.16,
+        transparent: true,
+      });
+      const textureLoader = new three.TextureLoader();
+      textureLoader.setCrossOrigin('anonymous');
+      const textureCache = new Map<string, import('three').Texture>();
+      const materialCache = new Map<
+        string,
+        import('three').Material | import('three').Material[]
+      >();
+      const fallbackMaterialCache = new Map<string, import('three').Material>();
+      let platformSignature = '';
+
+      const getTexture = (url: string) => {
+        const cached = textureCache.get(url);
+        if (cached) {
+          return cached;
+        }
+
+        const texture = textureLoader.load(url, () => {
+          renderer.render(scene, camera);
+        });
+        texture.colorSpace = three.SRGBColorSpace;
+        texture.wrapS = three.ClampToEdgeWrapping;
+        texture.wrapT = three.ClampToEdgeWrapping;
+        texture.anisotropy = Math.min(renderer.capabilities.getMaxAnisotropy(), 6);
+        textureCache.set(url, texture);
+        return texture;
+      };
+
+      const getPlatformMaterial = (
+        item: JumpHopPlatformRenderItem,
+        textureUrls: Record<string, string>,
+      ) => {
+        const textureUrl = getJumpHopTileTextureUrl(
+          textureUrls,
+          item.renderKey,
+          'top',
+        );
+        if (item.asset?.faceAssets && textureUrl) {
+          const cacheKey = JUMP_HOP_TILE_FACE_KEYS.map((face) =>
+            getJumpHopTileTextureUrl(textureUrls, item.renderKey, face),
+          ).join('|');
+          const cached = materialCache.get(cacheKey);
+          if (cached) {
+            return cached;
+          }
+
+          // 中文注释：Three.js Box/RoundedBox �质顺�为 right, left, top, bottom, front, back。
+          const materials = [
+            'right',
+            'left',
+            'top',
+            'bottom',
+            'front',
+            'back',
+          ].map((face) => {
+            const faceUrl =
+              getJumpHopTileTextureUrl(
+                textureUrls,
+                item.renderKey,
+                face as JumpHopTileFaceKey,
+              ) || textureUrl;
+            return new three.MeshStandardMaterial({
+              alphaTest: 0.04,
+              map: getTexture(faceUrl),
+              metalness: 0,
+              roughness: 0.76,
+              transparent: true,
+            });
+          });
+          materialCache.set(cacheKey, materials);
+          return materials;
+        }
+
+        if (textureUrl) {
+          const cached = materialCache.get(textureUrl);
+          if (cached) {
+            return cached;
+          }
+
+          const material = new three.MeshStandardMaterial({
+            alphaTest: 0.04,
+            map: getTexture(textureUrl),
+            metalness: 0,
+            roughness: 0.76,
+            transparent: true,
+          });
+          materialCache.set(textureUrl, material);
+          return material;
+        }
+
+        const tone = getJumpHopTileTone(item.platform.tileType);
+        const cached = fallbackMaterialCache.get(tone);
+        if (cached) {
+          return cached;
+        }
+
+        const material = new three.MeshStandardMaterial({
+          color: new three.Color(tone),
+          metalness: 0,
+          roughness: 0.82,
+        });
+        fallbackMaterialCache.set(tone, material);
+        return material;
+      };
+
+      const viewportSize = {
         width: 320,
         height: 568,
       };
+
+      const syncCamera = () => {
+        const distance =
+          Math.max(viewportSize.width, viewportSize.height) *
+          JUMP_HOP_THREE_CAMERA_DISTANCE_MULTIPLIER;
+        const targetX = viewportSize.width / 2;
+        const targetY = viewportSize.height / 2;
+        camera.left = -viewportSize.width / 2;
+        camera.right = viewportSize.width / 2;
+        camera.top = viewportSize.height / 2;
+        camera.bottom = -viewportSize.height / 2;
+        camera.position.set(
+          targetX,
+          targetY -
+            Math.cos(JUMP_HOP_THREE_CAMERA_PITCH_RAD) * distance,
+          Math.sin(JUMP_HOP_THREE_CAMERA_PITCH_RAD) * distance,
+        );
+        camera.lookAt(targetX, targetY, 0);
+        camera.updateProjectionMatrix();
+        camera.updateMatrixWorld();
+      };
+
+      const syncPlatformMeshes = () => {
+        const nextPlatforms = platformsRef.current;
+        const textureUrls = textureUrlsByRenderKeyRef.current;
+        const nextSignature = nextPlatforms
+          .map((item) => {
+            const cubeSide = getJumpHopThreeCubeSide(
+              item.platform,
+              item.scale,
+            );
+            return [
+              item.renderKey,
+              item.platform.platformId,
+              item.screenX.toFixed(3),
+              item.screenY.toFixed(3),
+              item.scale.toFixed(3),
+              cubeSide.toFixed(2),
+              textureUrls[item.renderKey] ?? '',
+              item.advanceState,
+            ].join(':');
+          })
+          .join('|');
+
+        if (nextSignature === platformSignature) {
+          return;
+        }
+
+        platformSignature = nextSignature;
+        platformGroup.clear();
+
+        nextPlatforms.forEach((item) => {
+          const cubeSide = getJumpHopThreeCubeSide(item.platform, item.scale);
+          const root = new three.Group();
+          const rootBaseX = (item.screenX / 100) * viewportSize.width;
+          const rootBaseY = getJumpHopThreeProjectedY(
+            (item.screenY / 100) * viewportSize.height,
+            viewportSize.height,
+          );
+          root.position.set(rootBaseX, rootBaseY, 0);
+          root.renderOrder = 20 + item.index;
+          root.userData = {
+            advanceState: item.advanceState,
+            baseX: rootBaseX,
+            baseY: rootBaseY,
+          };
+
+          const shadow = new three.Mesh(shadowGeometry, shadowMaterial);
+          shadow.position.set(0, cubeSide * 0.32, -9);
+          shadow.scale.set(
+            Math.max(24, cubeSide * 0.48),
+            Math.max(7, cubeSide * 0.13),
+            1,
+          );
+          shadow.renderOrder = 10 + item.index;
+
+          const mesh = new three.Mesh(
+            platformGeometry,
+            getPlatformMaterial(item, textureUrls),
+          );
+          mesh.position.set(0, 0, 0);
+          mesh.rotation.set(0, 0, 0);
+          mesh.scale.setScalar(cubeSide);
+          mesh.renderOrder = 30 + item.index;
+
+          root.add(shadow, mesh);
+          platformGroup.add(root);
+        });
+      };
+
       const resize = () => {
         const rect = host.getBoundingClientRect();
         const width = Math.max(1, rect.width || host.clientWidth || 320);
         const height = Math.max(1, rect.height || host.clientHeight || 568);
-        size.width = width;
-        size.height = height;
+        viewportSize.width = width;
+        viewportSize.height = height;
         renderer.setSize(width, height, false);
-        camera.left = 0;
-        camera.right = width;
-        camera.top = 0;
-        camera.bottom = height;
-        camera.updateProjectionMatrix();
+        syncCamera();
+        platformSignature = '';
+        syncPlatformMeshes();
         renderer.render(scene, camera);
       };
 
@@ -471,15 +1023,17 @@ function JumpHopThreeScene({
         : null;
       resizeObserver?.observe(host);
       resize();
-      onCharacterLayerReadyChange(true);
+      onCharacterLayerReadyChange(Boolean(character));
+      onPlatformLayerReadyChange(true);
 
       const animate = () => {
+        syncPlatformMeshes();
         const nextCharacterPosition = characterPositionRef.current;
-        if (nextCharacterPosition) {
+        if (character && nextCharacterPosition) {
           const nextChargeRatio = chargeRatioRef.current;
           const canvasPosition = resolveJumpHopCharacterCanvasPosition(
             nextCharacterPosition,
-            size,
+            viewportSize,
           );
           character.visible = true;
           character.position.set(canvasPosition?.x ?? 0, canvasPosition?.y ?? 0, 0);
@@ -499,7 +1053,7 @@ function JumpHopThreeScene({
             1 - nextChargeRatio * 0.12,
             1 + nextChargeRatio * 0.08,
           );
-        } else {
+        } else if (character) {
           character.visible = false;
         }
         renderer.render(scene, camera);
@@ -513,8 +1067,21 @@ function JumpHopThreeScene({
         }
         resizeObserver?.disconnect();
         disposeJumpHopThreeObject(scene);
+        textureCache.forEach((texture) => texture.dispose());
+        materialCache.forEach((material) => {
+          if (Array.isArray(material)) {
+            material.forEach((item) => item.dispose());
+          } else {
+            material.dispose();
+          }
+        });
+        fallbackMaterialCache.forEach((material) => material.dispose());
+        shadowMaterial.dispose();
+        platformGeometry.dispose();
+        shadowGeometry.dispose();
         renderer.dispose();
         onCharacterLayerReadyChange(false);
+        onPlatformLayerReadyChange(false);
       };
     };
 
@@ -526,14 +1093,18 @@ function JumpHopThreeScene({
       fallbackCanvas.remove();
       host.replaceChildren();
     };
-  }, [onCharacterLayerReadyChange, renderCharacter]);
+  }, [
+    onCharacterLayerReadyChange,
+    onPlatformLayerReadyChange,
+    renderCharacter,
+  ]);
 
   return (
     <div
       ref={hostRef}
       data-testid="jump-hop-three-scene"
       className="jump-hop-runtime__three-scene"
-      style={{ pointerEvents: 'none', zIndex: 100 }}
+      style={{ pointerEvents: 'none', zIndex: 42 }}
       data-platform-count={platformCount}
     />
   );
@@ -610,10 +1181,11 @@ export function JumpHopRuntimeShell({
   const [nowMs, setNowMs] = useState(() => Date.now());
   const [isThreeCharacterLayerReady, setIsThreeCharacterLayerReady] =
     useState(false);
-  const [dragPointerPosition, setDragPointerPosition] = useState<{
-    x: number;
-    y: number;
-  } | null>(null);
+  const [isThreePlatformLayerReady, setIsThreePlatformLayerReady] =
+    useState(false);
+  const [platformTextureUrlsByRenderKey, setPlatformTextureUrlsByRenderKey] =
+    useState<Record<string, string>>({});
+  const platformTextureParentObjectUrlsRef = useRef<Set<string>>(new Set());
   const [dragVector, setDragVector] = useState({ x: 0, y: 0 });
   const [jumpAnimationProgress, setJumpAnimationProgress] = useState(0);
   const [isPlatformAdvancing, setIsPlatformAdvancing] = useState(false);
@@ -625,8 +1197,8 @@ export function JumpHopRuntimeShell({
     useState(0);
   const [stageSize, setStageSize] = useState({ width: 0, height: 0 });
   const stageRef = useRef<HTMLElement | null>(null);
-  const dragStartRef = useRef<{ x: number; y: number } | null>(null);
-  const dragCurrentRef = useRef<{ x: number; y: number } | null>(null);
+  const chargeStartedAtRef = useRef<number | null>(null);
+  const chargeFrameRef = useRef<number | null>(null);
   const animationFrameRef = useRef<number | null>(null);
   const animationEndTimerRef = useRef<number | null>(null);
   const landingRecoilEndTimerRef = useRef<number | null>(null);
@@ -715,13 +1287,33 @@ export function JumpHopRuntimeShell({
     platformAdvanceExitingPlatforms,
     visiblePlatforms,
   ]);
+  const platformRenderKeySignature = useMemo(
+    () => platformRenderItems.map((item) => item.renderKey).join('|'),
+    [platformRenderItems],
+  );
+  const shouldUseThreePlatformLayer = useMemo(
+    () =>
+      isThreePlatformLayerReady &&
+      platformRenderItems.every((item) =>
+        hasJumpHopTileTexturesReady(
+          platformTextureUrlsByRenderKey,
+          item.renderKey,
+          item.asset,
+        ),
+      ),
+    [
+      isThreePlatformLayerReady,
+      platformRenderItems,
+      platformTextureUrlsByRenderKey,
+    ],
+  );
   const preloadTileAssets = useMemo(() => {
     const path = stageRun?.path;
     const tileAssets = profile?.tileAssets;
     const platforms = path?.platforms ?? [];
     const startIndex =
       (stageRun?.currentPlatformIndex ?? 0) + visiblePlatforms.length;
-    const assets = new Map<string, JumpHopTileAsset>();
+    const assets = new Map<string, JumpHopTilePreloadItem>();
 
     for (
       let index = startIndex;
@@ -745,8 +1337,11 @@ export function JumpHopRuntimeShell({
       if (!asset) {
         continue;
       }
-      const key = getJumpHopTileAssetRefreshKey(asset) ?? asset.imageSrc;
-      assets.set(key, asset);
+      const key = platform.platformId;
+      assets.set(key, {
+        textureKey: platform.platformId,
+        asset,
+      });
     }
 
     return [...assets.values()];
@@ -756,10 +1351,26 @@ export function JumpHopRuntimeShell({
     stageRun?.path,
     visiblePlatforms.length,
   ]);
+  const landingAssistStageSize =
+    stageSize.width > 0 && stageSize.height > 0
+      ? stageSize
+      : { width: 320, height: 568 };
   const characterPosition = getJumpHopCharacterVisualPosition(
     stageRun,
     visiblePlatforms,
+    landingAssistStageSize,
   );
+  const currentPlatformOriginPosition = useMemo(() => {
+    if (!stageRun) {
+      return null;
+    }
+    const currentPlatform = visiblePlatforms.find(
+      (item) => item.index === stageRun.currentPlatformIndex,
+    );
+    return currentPlatform
+      ? buildJumpHopCharacterVisualPositionFromPlatform(currentPlatform)
+      : null;
+  }, [stageRun, visiblePlatforms]);
   const jumpTargetPlatform = useMemo(() => {
     if (!stageRun) {
       return null;
@@ -770,6 +1381,27 @@ export function JumpHopRuntimeShell({
       ) ?? null
     );
   }, [stageRun, visiblePlatforms]);
+  const targetDirection = useMemo(() => {
+    const directionOrigin = currentPlatformOriginPosition ?? characterPosition;
+    if (!directionOrigin || !jumpTargetPlatform) {
+      return null;
+    }
+    const targetCharacterPosition =
+      buildJumpHopCharacterVisualPositionFromPlatform(jumpTargetPlatform);
+    const directionX = targetCharacterPosition.screenX - directionOrigin.screenX;
+    const directionY = targetCharacterPosition.screenY - directionOrigin.screenY;
+    const distance = Math.hypot(directionX, directionY);
+    if (distance < 0.0001) {
+      return null;
+    }
+
+    return {
+      screenX: directionX,
+      screenY: directionY,
+      unitScreenX: directionX / distance,
+      unitScreenY: directionY / distance,
+    };
+  }, [characterPosition, currentPlatformOriginPosition, jumpTargetPlatform]);
   const visualCharacterPosition = useMemo(() => {
     if (!characterPosition) {
       return null;
@@ -777,65 +1409,35 @@ export function JumpHopRuntimeShell({
     if (isJumpAnimating && visualJump) {
       return visualJump.to;
     }
-    if (!isJumpAnimating || !jumpTargetPlatform) {
-      return characterPosition;
-    }
-
-    const targetCharacterPosition = buildJumpHopCharacterVisualPositionFromPlatform(
-      jumpTargetPlatform,
-      false,
-    );
-    const easedProgress = 1 - Math.pow(1 - clamp(jumpAnimationProgress, 0, 1), 3);
-    const arcOffset = Math.sin(Math.PI * easedProgress) * -24;
-
-    return {
-      screenX:
-        characterPosition.screenX +
-        (targetCharacterPosition.screenX - characterPosition.screenX) * easedProgress,
-      screenY:
-        characterPosition.screenY +
-        (targetCharacterPosition.screenY - characterPosition.screenY) * easedProgress +
-        arcOffset,
-      sceneX:
-        characterPosition.sceneX +
-        (targetCharacterPosition.sceneX - characterPosition.sceneX) * easedProgress,
-      sceneY:
-        characterPosition.sceneY +
-        (targetCharacterPosition.sceneY - characterPosition.sceneY) * easedProgress,
-      sceneZ:
-        characterPosition.sceneZ +
-        (targetCharacterPosition.sceneZ - characterPosition.sceneZ) * easedProgress,
-      isMiss: characterPosition.isMiss,
-    };
+    return characterPosition;
   }, [
     characterPosition,
     isJumpAnimating,
-    jumpAnimationProgress,
-    jumpTargetPlatform,
     visualJump,
   ]);
-  const landingAssistStageSize =
-    stageSize.width > 0 && stageSize.height > 0
-      ? stageSize
-      : { width: 320, height: 568 };
   const characterMotionStyle = useMemo(() => {
     const idleTransform = 'matrix(1, 0, 0, 1, 0, 0)';
     const recoilDistance = Math.hypot(dragVector.x, dragVector.y);
-    const recoilUnitX = recoilDistance > 0 ? dragVector.x / recoilDistance : 0;
-    const recoilUnitY = recoilDistance > 0 ? dragVector.y / recoilDistance : 0;
+    const recoilUnitX =
+      recoilDistance > 0
+        ? dragVector.x / recoilDistance
+        : targetDirection
+          ? -targetDirection.unitScreenX
+          : 0;
+    const recoilUnitY =
+      recoilDistance > 0
+        ? dragVector.y / recoilDistance
+        : targetDirection
+          ? -targetDirection.unitScreenY
+          : 0;
     let stretchTransform = idleTransform;
 
-    if (isCharging && dragPointerPosition && characterPosition) {
-      const anchorX =
-        landingAssistStageSize.width * (characterPosition.screenX / 100);
-      const anchorY =
-        landingAssistStageSize.height * (characterPosition.screenY / 100);
-      stretchTransform = buildJumpHopDirectionalScaleMatrix({
-        directionX: dragPointerPosition.x - anchorX,
-        directionY: dragPointerPosition.y - anchorY,
-        stretchScale: 1 + chargeRatio * 0.62,
-        crossScale: 1 - chargeRatio * 0.16,
-      });
+    if (isCharging) {
+      const squashY = 1 - chargeRatio * 0.32;
+      const squashX = 1 + chargeRatio * 0.1;
+      stretchTransform = `scale(${formatJumpHopCssNumber(
+        squashX,
+      )}, ${formatJumpHopCssNumber(squashY)})`;
     }
 
     return {
@@ -857,13 +1459,12 @@ export function JumpHopRuntimeShell({
     };
   }, [
     chargeRatio,
-    characterPosition,
-    dragPointerPosition,
     dragVector.x,
     dragVector.y,
     isCharging,
     landingAssistStageSize.height,
     landingAssistStageSize.width,
+    targetDirection,
     visualJump,
   ]);
   const jumpFeedbackForDisplay = getJumpHopJumpFeedbackLabel(stageRun);
@@ -881,6 +1482,79 @@ export function JumpHopRuntimeShell({
     visiblePlatformsRef.current = visiblePlatforms;
   }, [visiblePlatforms]);
 
+  useEffect(() => {
+    const activeKeys = new Set([
+      ...platformRenderItems.flatMap((item) =>
+        getJumpHopActiveTextureKeys(item.renderKey, item.asset),
+      ),
+      ...preloadTileAssets.flatMap((item) =>
+        getJumpHopActiveTextureKeys(item.textureKey, item.asset),
+      ),
+    ]);
+    setPlatformTextureUrlsByRenderKey((current) => {
+      let changed = false;
+      const next: Record<string, string> = {};
+      for (const [key, value] of Object.entries(current)) {
+        if (activeKeys.has(key)) {
+          next[key] = value;
+        } else {
+          changed = true;
+          if (
+            value.startsWith('blob:') &&
+            platformTextureParentObjectUrlsRef.current.has(value)
+          ) {
+            URL.revokeObjectURL(value);
+            platformTextureParentObjectUrlsRef.current.delete(value);
+          }
+        }
+      }
+      return changed ? next : current;
+    });
+  }, [platformRenderItems, platformRenderKeySignature, preloadTileAssets]);
+
+  const handleResolvedPlatformTextureUrl = useCallback(
+    (
+      textureKey: string,
+      resolvedUrl: string,
+      options?: { parentOwnedObjectUrl?: boolean },
+    ) => {
+      setPlatformTextureUrlsByRenderKey((current) => {
+        const previousUrl = current[textureKey];
+        if (!resolvedUrl) {
+          return current;
+        }
+        if (previousUrl === resolvedUrl) {
+          return current;
+        }
+        if (
+          previousUrl &&
+          previousUrl.startsWith('blob:') &&
+          platformTextureParentObjectUrlsRef.current.has(previousUrl)
+        ) {
+          URL.revokeObjectURL(previousUrl);
+          platformTextureParentObjectUrlsRef.current.delete(previousUrl);
+        }
+        if (options?.parentOwnedObjectUrl && resolvedUrl.startsWith('blob:')) {
+          platformTextureParentObjectUrlsRef.current.add(resolvedUrl);
+        }
+        return {
+          ...current,
+          [textureKey]: resolvedUrl,
+        };
+      });
+    },
+    [],
+  );
+
+  useEffect(() => {
+    return () => {
+      platformTextureParentObjectUrlsRef.current.forEach((url) => {
+        URL.revokeObjectURL(url);
+      });
+      platformTextureParentObjectUrlsRef.current.clear();
+    };
+  }, []);
+
   useEffect(() => {
     tileAssetsRef.current = profile?.tileAssets;
   }, [profile?.tileAssets]);
@@ -904,6 +1578,13 @@ export function JumpHopRuntimeShell({
     setIsLandingRecoilAnimating(false);
   }, []);
 
+  const stopChargeFrame = useCallback(() => {
+    if (chargeFrameRef.current != null) {
+      window.cancelAnimationFrame(chargeFrameRef.current);
+      chargeFrameRef.current = null;
+    }
+  }, []);
+
   const beginPlatformAdvance = useCallback(
     (
       fromRun: JumpHopRuntimeRunSnapshotResponse,
@@ -923,30 +1604,75 @@ export function JumpHopRuntimeShell({
       const toPlatformIds = new Set(
         toVisiblePlatforms.map((item) => item.platform.platformId),
       );
-      const fromLandingPlatform = fromVisiblePlatforms.find(
-        (item) => item.index === toRun.currentPlatformIndex,
-      );
+      const fromLandingPosition =
+        getJumpHopRunLandingVisualPosition({
+          run: toRun,
+          platforms: fromVisiblePlatforms,
+          stageSize: landingAssistStageSize,
+        }) ??
+        (() => {
+          const fromLandingPlatform = fromVisiblePlatforms.find(
+            (item) => item.index === toRun.currentPlatformIndex,
+          );
+          return fromLandingPlatform
+            ? buildJumpHopCharacterVisualPositionFromPlatform(
+                fromLandingPlatform,
+              )
+            : null;
+        })();
+      const toLandingPosition =
+        getJumpHopRunLandingVisualPosition({
+          run: toRun,
+          platforms: toVisiblePlatforms,
+          stageSize: landingAssistStageSize,
+        }) ??
+        (() => {
+          const toCurrentPlatform = toVisiblePlatforms.find(
+            (item) => item.index === toRun.currentPlatformIndex,
+          );
+          return toCurrentPlatform
+            ? buildJumpHopCharacterVisualPositionFromPlatform(
+                toCurrentPlatform,
+              )
+            : null;
+        })();
       const toCurrentPlatform = toVisiblePlatforms.find(
         (item) => item.index === toRun.currentPlatformIndex,
       );
+      const fromLandingPlatform = fromVisiblePlatforms.find(
+        (item) => item.index === toRun.currentPlatformIndex,
+      );
       const cameraOffsetX =
-        (fromLandingPlatform?.screenX ?? toCurrentPlatform?.screenX ?? 0) -
-        (toCurrentPlatform?.screenX ?? fromLandingPlatform?.screenX ?? 0);
+        (fromLandingPosition?.screenX ?? fromLandingPlatform?.screenX ?? 0) -
+        (toLandingPosition?.screenX ?? toCurrentPlatform?.screenX ?? 0);
       const cameraOffsetY = Math.max(
         0,
-        (toCurrentPlatform?.screenY ?? 0) -
-          (fromLandingPlatform?.screenY ?? 0),
+        (toLandingPosition?.screenY ?? toCurrentPlatform?.screenY ?? 0) -
+          (fromLandingPosition?.screenY ?? fromLandingPlatform?.screenY ?? 0),
       );
 
-      setPlatformAdvanceExitingPlatforms(
-        fromVisiblePlatforms
+      const movePlatformBehindCamera = (item: JumpHopVisiblePlatform) => ({
+        ...item,
+        screenX: item.screenX - cameraOffsetX,
+        screenY: item.screenY + cameraOffsetY,
+      });
+      setPlatformAdvanceExitingPlatforms((currentRetainedPlatforms) => {
+        const retainedPlatforms = currentRetainedPlatforms
           .filter((item) => !toPlatformIds.has(item.platform.platformId))
-          .map((item) => ({
-            ...item,
-            screenX: item.screenX - cameraOffsetX,
-            screenY: item.screenY + cameraOffsetY,
-          })),
-      );
+          .map(movePlatformBehindCamera);
+        const newlyRetainedPlatforms = fromVisiblePlatforms
+          .filter((item) => !toPlatformIds.has(item.platform.platformId))
+          .map(movePlatformBehindCamera);
+        const byPlatformId = new Map<string, JumpHopVisiblePlatform>();
+
+        [...retainedPlatforms, ...newlyRetainedPlatforms].forEach((item) => {
+          if (item.screenY < JUMP_HOP_PLATFORM_RETAIN_OFFSCREEN_SCREEN_Y) {
+            byPlatformId.set(item.platform.platformId, item);
+          }
+        });
+
+        return [...byPlatformId.values()];
+      });
       setPlatformAdvanceCameraOffsetX(cameraOffsetX);
       setPlatformAdvanceCameraOffsetY(cameraOffsetY);
       setIsPlatformAdvancing(true);
@@ -957,12 +1683,11 @@ export function JumpHopRuntimeShell({
       platformAdvanceEndTimerRef.current = window.setTimeout(() => {
         platformAdvanceEndTimerRef.current = null;
         setIsPlatformAdvancing(false);
-        setPlatformAdvanceExitingPlatforms([]);
         setPlatformAdvanceCameraOffsetX(0);
         setPlatformAdvanceCameraOffsetY(0);
       }, JUMP_HOP_PLATFORM_ADVANCE_DURATION_MS);
     },
-    [clearPlatformAdvanceState],
+    [clearPlatformAdvanceState, landingAssistStageSize],
   );
 
   const finishJumpHopFlightAnimation = useCallback(
@@ -1057,11 +1782,10 @@ export function JumpHopRuntimeShell({
       setIsJumpAnimating(false);
       setJumpAnimationProgress(0);
       setIsCharging(false);
-      dragStartRef.current = null;
-      dragCurrentRef.current = null;
+      chargeStartedAtRef.current = null;
+      stopChargeFrame();
       setDragDistance(0);
       setDragVector({ x: 0, y: 0 });
-      setDragPointerPosition(null);
       setNowMs(Date.now());
       return;
     }
@@ -1083,11 +1807,10 @@ export function JumpHopRuntimeShell({
       setIsJumpAnimating(false);
       setJumpAnimationProgress(0);
       setIsCharging(false);
-      dragStartRef.current = null;
-      dragCurrentRef.current = null;
+      chargeStartedAtRef.current = null;
+      stopChargeFrame();
       setDragDistance(0);
       setDragVector({ x: 0, y: 0 });
-      setDragPointerPosition(null);
       setNowMs(Date.now());
       return;
     }
@@ -1118,6 +1841,7 @@ export function JumpHopRuntimeShell({
     finishJumpHopFlightAnimation,
     isJumpAnimating,
     jumpAnimationProgress,
+    stopChargeFrame,
   ]);
 
   useEffect(() => {
@@ -1134,6 +1858,9 @@ export function JumpHopRuntimeShell({
       if (landingRecoilEndTimerRef.current != null) {
         window.clearTimeout(landingRecoilEndTimerRef.current);
       }
+      if (chargeFrameRef.current != null) {
+        window.cancelAnimationFrame(chargeFrameRef.current);
+      }
     };
   }, []);
 
@@ -1202,50 +1929,39 @@ export function JumpHopRuntimeShell({
     };
   }, [finishJumpHopFlightAnimation, isJumpAnimating]);
 
-  const getStageLocalPoint = (event: PointerEvent<HTMLElement>) => {
-    const rect = event.currentTarget.getBoundingClientRect();
-    return {
-      x: event.clientX - rect.left,
-      y: event.clientY - rect.top,
-    };
-  };
-
-  const updateDragState = (x: number, y: number) => {
-    const dragStart = dragStartRef.current;
-    dragCurrentRef.current = { x, y };
-    setDragPointerPosition({ x, y });
-    if (!dragStart) {
-      setDragDistance(0);
-      setDragVector({ x: 0, y: 0 });
-      return;
-    }
-    setDragVector({
-      x: x - dragStart.x,
-      y: y - dragStart.y,
-    });
-    setDragDistance(Math.hypot(x - dragStart.x, y - dragStart.y));
-  };
-
   const beginCharge = (event: PointerEvent<HTMLElement>) => {
     if (!canJump) {
       return;
     }
     event.currentTarget.setPointerCapture?.(event.pointerId);
-    const dragPoint = getStageLocalPoint(event);
-    dragStartRef.current = dragPoint;
-    dragCurrentRef.current = dragPoint;
-    setDragPointerPosition(dragPoint);
+    chargeStartedAtRef.current = Date.now();
+    stopChargeFrame();
+    clearLandingRecoilState();
     setIsCharging(true);
     setDragDistance(0);
     setDragVector({ x: 0, y: 0 });
-  };
 
-  const updateDragVector = (event: PointerEvent<HTMLElement>) => {
-    if (!isCharging) {
-      return;
-    }
-    const dragPoint = getStageLocalPoint(event);
-    updateDragState(dragPoint.x, dragPoint.y);
+    const tick = () => {
+      const chargeStartedAt = chargeStartedAtRef.current;
+      if (chargeStartedAt == null) {
+        chargeFrameRef.current = null;
+        return;
+      }
+
+      const nextDragDistance = clamp(
+        Date.now() - chargeStartedAt,
+        0,
+        maxDragDistancePx,
+      );
+      setDragDistance(nextDragDistance);
+      if (nextDragDistance < maxDragDistancePx) {
+        chargeFrameRef.current = window.requestAnimationFrame(tick);
+        return;
+      }
+      chargeFrameRef.current = null;
+    };
+
+    chargeFrameRef.current = window.requestAnimationFrame(tick);
   };
 
   const finishCharge = async (event?: PointerEvent<HTMLElement>) => {
@@ -1253,56 +1969,54 @@ export function JumpHopRuntimeShell({
       return;
     }
     if (event) {
-      const dragPoint = getStageLocalPoint(event);
-      updateDragState(dragPoint.x, dragPoint.y);
+      event.currentTarget.releasePointerCapture?.(event.pointerId);
     }
 
-    const dragStart = dragStartRef.current;
-    const dragCurrent = dragCurrentRef.current ?? dragStart;
-    const dragVectorX =
-      dragStart && dragCurrent ? dragCurrent.x - dragStart.x : 0;
-    const dragVectorY =
-      dragStart && dragCurrent ? dragCurrent.y - dragStart.y : 0;
-    const nextDragDistance = Math.hypot(dragVectorX, dragVectorY);
-    const backendDragVector = getJumpHopBackendDragVector(
-      activeRun,
-      visiblePlatforms,
-      landingAssistStageSize,
-      dragVectorX,
-      dragVectorY,
-    );
+    const chargeStartedAt = chargeStartedAtRef.current;
+    const nextDragDistance =
+      chargeStartedAt == null
+        ? 0
+        : clamp(
+            Date.now() - chargeStartedAt,
+            0,
+            maxDragDistancePx,
+          );
+    const predictionRun = stageRun ?? activeRun;
     const predictedLandingPosition =
-      activeRun && characterPosition
+      predictionRun && characterPosition
         ? getJumpHopLandingAssistVisualPosition(
-            activeRun,
+            predictionRun,
             visiblePlatforms,
             characterPosition,
             landingAssistStageSize,
             nextDragDistance,
-            dragVectorX,
-            dragVectorY,
           )
         : null;
-    const fallbackLandingPosition = jumpTargetPlatform
-      ? buildJumpHopCharacterVisualPositionFromPlatform(jumpTargetPlatform)
-      : characterPosition;
-    if (characterPosition && (predictedLandingPosition || fallbackLandingPosition)) {
+    if (characterPosition) {
+      const predictionOrigin =
+        currentPlatformOriginPosition ?? characterPosition;
+      const visualDeltaX = predictedLandingPosition
+        ? predictedLandingPosition.screenX - predictionOrigin.screenX
+        : 0;
+      const visualDeltaY = predictedLandingPosition
+        ? predictedLandingPosition.screenY - predictionOrigin.screenY
+        : 0;
       setVisualJump({
         from: characterPosition,
         to: predictedLandingPosition
           ? {
               ...characterPosition,
-              screenX: predictedLandingPosition.screenX,
-              screenY: predictedLandingPosition.screenY,
-              isMiss: false,
+              screenX: clamp(characterPosition.screenX + visualDeltaX, 6, 94),
+              screenY: clamp(characterPosition.screenY + visualDeltaY, 10, 92),
+              isMiss: !predictedLandingPosition.isOnTargetPlatform,
             }
-          : fallbackLandingPosition!,
+          : characterPosition,
       });
     } else {
       setVisualJump(null);
     }
-    dragStartRef.current = null;
-    dragCurrentRef.current = null;
+    chargeStartedAtRef.current = null;
+    stopChargeFrame();
     clearLandingRecoilState();
     setIsCharging(false);
     setJumpAnimationProgress(0);
@@ -1310,27 +2024,23 @@ export function JumpHopRuntimeShell({
     setIsJumpAnimating(true);
     setDragDistance(nextDragDistance);
     setDragVector({
-      x: dragVectorX,
-      y: dragVectorY,
+      x: targetDirection ? -targetDirection.unitScreenX : 0,
+      y: targetDirection ? -targetDirection.unitScreenY : 0,
     });
-    setDragPointerPosition(null);
     await onJump({
       dragDistance: nextDragDistance,
-      dragVectorX: backendDragVector.dragVectorX,
-      dragVectorY: backendDragVector.dragVectorY,
     });
   };
 
   const cancelCharge = () => {
-    dragStartRef.current = null;
-    dragCurrentRef.current = null;
+    chargeStartedAtRef.current = null;
+    stopChargeFrame();
     clearLandingRecoilState();
     hasJumpAnimationReachedTargetRef.current = false;
     setVisualJump(null);
     setIsCharging(false);
     setDragDistance(0);
     setDragVector({ x: 0, y: 0 });
-    setDragPointerPosition(null);
   };
 
   return (
@@ -1353,7 +2063,6 @@ export function JumpHopRuntimeShell({
         data-platform-advancing={isPlatformAdvancing ? 'true' : 'false'}
         className="jump-hop-runtime__stage absolute inset-0 h-full w-full touch-none select-none overflow-hidden"
         onPointerDown={beginCharge}
-        onPointerMove={updateDragVector}
         onPointerUp={(event) => void finishCharge(event)}
         onPointerCancel={cancelCharge}
       >
@@ -1375,11 +2084,13 @@ export function JumpHopRuntimeShell({
         <div
           data-testid="jump-hop-camera-layer"
           data-platform-advancing={isPlatformAdvancing ? 'true' : 'false'}
+          data-three-platform-ready={shouldUseThreePlatformLayer ? 'true' : 'false'}
           className="jump-hop-runtime__camera-layer"
           style={
             {
               '--jump-hop-camera-shift-x': `${platformAdvanceCameraOffsetX}%`,
               '--jump-hop-camera-shift-y': `${-platformAdvanceCameraOffsetY}%`,
+              '--jump-hop-camera-zoom': JUMP_HOP_CAMERA_ZOOM,
             } as CSSProperties
           }
         >
@@ -1387,9 +2098,12 @@ export function JumpHopRuntimeShell({
             characterPosition={visualCharacterPosition}
             chargeRatio={chargeRatio}
             isJumpAnimating={isJumpAnimating}
+            platforms={platformRenderItems}
             platformCount={platformRenderItems.length}
             renderCharacter={false}
+            textureUrlsByRenderKey={platformTextureUrlsByRenderKey}
             onCharacterLayerReadyChange={setIsThreeCharacterLayerReady}
+            onPlatformLayerReadyChange={setIsThreePlatformLayerReady}
           />
 
           {platformRenderItems.map((item) => {
@@ -1424,6 +2138,8 @@ export function JumpHopRuntimeShell({
                 <JumpHopTileImage
                   asset={item.asset}
                   platform={item.platform}
+                  textureKey={item.renderKey}
+                  onResolvedTextureUrl={handleResolvedPlatformTextureUrl}
                 />
               </div>
             );
@@ -1431,10 +2147,12 @@ export function JumpHopRuntimeShell({
 
           {preloadTileAssets.length > 0 ? (
             <div className="jump-hop-runtime__tile-preload" aria-hidden="true">
-              {preloadTileAssets.map((asset) => (
+              {preloadTileAssets.map((item) => (
                 <JumpHopTilePreloadImage
-                  key={getJumpHopTileAssetRefreshKey(asset) ?? asset.imageSrc}
-                  asset={asset}
+                  key={item.textureKey}
+                  asset={item.asset}
+                  textureKey={item.textureKey}
+                  onResolvedTextureUrl={handleResolvedPlatformTextureUrl}
                 />
               ))}
             </div>
@@ -1477,34 +2195,42 @@ export function JumpHopRuntimeShell({
           ) : null}
         </div>
 
-        {isCharging && dragPointerPosition && characterPosition ? (
+        {isCharging && characterPosition ? (
           <div
             aria-hidden="true"
-            className="jump-hop-runtime__slingshot-guide"
+            className="jump-hop-runtime__charge-guide"
             style={
               (() => {
                 const anchorX =
                   stageSize.width * (characterPosition.screenX / 100);
                 const anchorY =
                   stageSize.height * (characterPosition.screenY / 100);
-                const deltaX = dragPointerPosition.x - anchorX;
-                const deltaY = dragPointerPosition.y - anchorY;
-                const distance = Math.max(48, Math.hypot(deltaX, deltaY));
-                const angle = (Math.atan2(deltaY, deltaX) * 180) / Math.PI;
+                const lineLength = 42 + chargeRatio * 84;
+                const ringSize = 56 + chargeRatio * 24;
+                const angle =
+                  targetDirection == null
+                    ? -90
+                    : (Math.atan2(
+                        targetDirection.screenY,
+                        targetDirection.screenX,
+                      ) *
+                        180) /
+                      Math.PI;
                 return {
                   '--jump-hop-anchor-x': `${anchorX}px`,
                   '--jump-hop-anchor-y': `${anchorY}px`,
-                  '--jump-hop-aim-x': `${dragPointerPosition.x}px`,
-                  '--jump-hop-aim-y': `${dragPointerPosition.y}px`,
-                  '--jump-hop-line-angle': `${angle}deg`,
-                  '--jump-hop-line-length': `${distance}px`,
+                  '--jump-hop-charge': chargeRatio,
+                  '--jump-hop-charge-ring-size': `${ringSize}px`,
+                  '--jump-hop-charge-turn': `${chargeRatio}turn`,
+                  '--jump-hop-guide-angle': `${angle}deg`,
+                  '--jump-hop-guide-length': `${lineLength}px`,
                 } as CSSProperties;
               })()
             }
           >
-            <div className="jump-hop-runtime__slingshot-line" />
-            <div className="jump-hop-runtime__slingshot-anchor" />
-            <div className="jump-hop-runtime__slingshot-aim" />
+            <div className="jump-hop-runtime__charge-ring" />
+            <div className="jump-hop-runtime__charge-line" />
+            <div className="jump-hop-runtime__charge-core" />
           </div>
         ) : null}
 
@@ -1728,8 +2454,8 @@ export function JumpHopRuntimeShell({
           inset: 0;
           z-index: 2;
           pointer-events: none;
-          transform: translate(0, 0);
-          transform-origin: 50% 50%;
+          transform: translate(0, 0) scale(var(--jump-hop-camera-zoom, 1));
+          transform-origin: 50% 56%;
         }
 
         .jump-hop-runtime__camera-layer[data-platform-advancing='true'] {
@@ -1739,10 +2465,16 @@ export function JumpHopRuntimeShell({
         .jump-hop-runtime__three-scene {
           position: absolute;
           inset: 0;
-          z-index: 100;
+          z-index: 42;
           pointer-events: none;
           overflow: hidden;
           background: transparent;
+          opacity: 1;
+          transition: opacity 120ms ease;
+        }
+
+        .jump-hop-runtime__camera-layer[data-three-platform-ready='false'] .jump-hop-runtime__three-scene {
+          opacity: 0;
         }
 
         .jump-hop-runtime__platform {
@@ -1786,6 +2518,11 @@ export function JumpHopRuntimeShell({
           filter: blur(7px);
         }
 
+        .jump-hop-runtime__camera-layer[data-three-platform-ready='true'] .jump-hop-runtime__platform-shadow,
+        .jump-hop-runtime__camera-layer[data-three-platform-ready='true'] .jump-hop-runtime__tile-image-stack {
+          opacity: 0;
+        }
+
         .jump-hop-runtime__tile-image {
           position: absolute;
           inset: 0;
@@ -1873,7 +2610,7 @@ export function JumpHopRuntimeShell({
           width: 4.7rem;
           height: 5.5rem;
           transform:
-            translate(-50%, -86%)
+            translate(-50%, -100%)
             var(--jump-hop-character-stretch-transform);
           transform-origin: 50% 78%;
           transition:
@@ -1898,7 +2635,7 @@ export function JumpHopRuntimeShell({
 
         .jump-hop-runtime__character[data-miss='true'] {
           opacity: 0.78;
-          transform: translate(-50%, -60%) rotate(18deg) scale(0.88);
+          transform: translate(-50%, -72%) rotate(18deg) scale(0.88);
         }
 
         .jump-hop-runtime__character-shadow {
@@ -1969,47 +2706,62 @@ export function JumpHopRuntimeShell({
           animation: jump-hop-feedback 900ms ease both;
         }
 
-        .jump-hop-runtime__slingshot-guide {
+        .jump-hop-runtime__charge-guide {
           position: absolute;
           inset: 0;
           z-index: 85;
           pointer-events: none;
         }
 
-        .jump-hop-runtime__slingshot-line {
+        .jump-hop-runtime__charge-ring {
           position: absolute;
           left: var(--jump-hop-anchor-x);
           top: var(--jump-hop-anchor-y);
-          width: var(--jump-hop-line-length);
-          height: 2px;
+          width: var(--jump-hop-charge-ring-size);
+          height: var(--jump-hop-charge-ring-size);
+          margin-left: calc(var(--jump-hop-charge-ring-size) / -2);
+          margin-top: calc(var(--jump-hop-charge-ring-size) / -2);
+          border-radius: 999px;
+          border: 2px solid rgba(250, 204, 21, 0.82);
+          background:
+            radial-gradient(circle, rgba(250, 204, 21, 0.2) 0 38%, transparent 39%),
+            conic-gradient(
+              from -90deg,
+              rgba(194, 101, 64, 0.88) var(--jump-hop-charge-turn),
+              rgba(255, 255, 255, 0.34) 0
+            );
+          box-shadow:
+            0 0 0 5px rgba(255, 255, 255, 0.36),
+            0 8px 18px rgba(194, 101, 64, 0.2);
+          opacity: 0.95;
+        }
+
+        .jump-hop-runtime__charge-line {
+          position: absolute;
+          left: var(--jump-hop-anchor-x);
+          top: var(--jump-hop-anchor-y);
+          width: var(--jump-hop-guide-length);
+          height: 3px;
           transform-origin: left center;
-          transform: translateY(-1px) rotate(var(--jump-hop-line-angle));
-          background: linear-gradient(90deg, rgba(250, 204, 21, 0.15), rgba(194, 101, 64, 0.9));
-          box-shadow: 0 0 10px rgba(194, 101, 64, 0.25);
+          transform: translateY(-1px) rotate(var(--jump-hop-guide-angle));
           border-radius: 999px;
+          background: linear-gradient(90deg, rgba(250, 204, 21, 0.12), rgba(194, 101, 64, 0.82));
+          box-shadow: 0 0 10px rgba(194, 101, 64, 0.2);
         }
 
-        .jump-hop-runtime__slingshot-anchor,
-        .jump-hop-runtime__slingshot-aim {
+        .jump-hop-runtime__charge-core {
           position: absolute;
-          width: 0.72rem;
-          height: 0.72rem;
-          margin-left: -0.36rem;
-          margin-top: -0.36rem;
-          border-radius: 999px;
-          box-shadow: 0 0 0 3px rgba(255, 255, 255, 0.72);
-        }
-
-        .jump-hop-runtime__slingshot-anchor {
           left: var(--jump-hop-anchor-x);
           top: var(--jump-hop-anchor-y);
+          width: 0.82rem;
+          height: 0.82rem;
+          margin-left: -0.41rem;
+          margin-top: -0.41rem;
+          border-radius: 999px;
           background: #c7653d;
-        }
-
-        .jump-hop-runtime__slingshot-aim {
-          left: var(--jump-hop-aim-x);
-          top: var(--jump-hop-aim-y);
-          background: #facc15;
+          box-shadow:
+            0 0 0 3px rgba(255, 255, 255, 0.72),
+            0 0 16px rgba(250, 204, 21, 0.48);
         }
 
         @keyframes jump-hop-feedback {
@@ -2042,7 +2794,7 @@ export function JumpHopRuntimeShell({
         @keyframes jump-hop-character-flight {
           0% {
             transform:
-              translate(-50%, -86%)
+              translate(-50%, -100%)
               translate(
                 var(--jump-hop-flight-from-x),
                 var(--jump-hop-flight-from-y)
@@ -2051,7 +2803,7 @@ export function JumpHopRuntimeShell({
           }
           42% {
             transform:
-              translate(-50%, -86%)
+              translate(-50%, -100%)
               translate(
                 calc(var(--jump-hop-flight-from-x) * 0.48),
                 calc(var(--jump-hop-flight-from-y) * 0.48 - 30px)
@@ -2060,7 +2812,7 @@ export function JumpHopRuntimeShell({
           }
           74% {
             transform:
-              translate(-50%, -86%)
+              translate(-50%, -100%)
               translate(
                 calc(var(--jump-hop-flight-from-x) * 0.14),
                 calc(var(--jump-hop-flight-from-y) * 0.14 - 10px)
@@ -2069,7 +2821,7 @@ export function JumpHopRuntimeShell({
           }
           100% {
             transform:
-              translate(-50%, -86%)
+              translate(-50%, -100%)
               translate(0, 0)
               scale(1);
           }
@@ -2115,13 +2867,15 @@ export function JumpHopRuntimeShell({
 
         @keyframes jump-hop-camera-advance {
           0% {
-            transform: translate(
-              var(--jump-hop-camera-shift-x),
-              var(--jump-hop-camera-shift-y)
-            );
+            transform:
+              translate(
+                var(--jump-hop-camera-shift-x),
+                var(--jump-hop-camera-shift-y)
+              )
+              scale(var(--jump-hop-camera-zoom, 1));
           }
           100% {
-            transform: translate(0, 0);
+            transform: translate(0, 0) scale(var(--jump-hop-camera-zoom, 1));
           }
         }
 
diff --git a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
index 90871704..2ebd27d1 100644
--- a/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
+++ b/src/components/platform-entry/PlatformEntryFlowShellImpl.tsx
@@ -1767,6 +1767,7 @@ export function PlatformEntryFlowShellImpl({
       shouldRestoreCustomWorldAgentUiState(),
   );
   const handledInitialPublicWorkCodeRef = useRef<string | null>(null);
+  const handledJumpHopRuntimeRestoreRef = useRef<string | null>(null);
   const selectionStageRef = useRef(selectionStage);
   const creationFlowReturnTargetRef =
     useRef<CreationFlowReturnTarget>('create');
@@ -7465,6 +7466,7 @@ export function PlatformEntryFlowShellImpl({
       profileId: string,
       options: {
         embedded?: boolean;
+        preloadedWork?: JumpHopWorkProfileResponse | null;
         returnStage?: 'work-detail' | 'platform';
       } = {},
     ) => {
@@ -7497,7 +7499,11 @@ export function PlatformEntryFlowShellImpl({
             : null,
         );
         const [detail, runResponse] = await Promise.all([
-          jumpHopClient.getWorkDetail(normalizedProfileId).catch(() => null),
+          options.preloadedWork
+            ? Promise.resolve({ item: options.preloadedWork })
+            : jumpHopClient
+                .getWorkDetail(normalizedProfileId)
+                .catch(() => null),
           jumpHopClient.startRun(normalizedProfileId, {
             ...runtimeGuestOptions,
             runtimeMode: 'published',
@@ -7529,6 +7535,78 @@ export function PlatformEntryFlowShellImpl({
     [authUi, setSelectionStage],
   );
 
+  useEffect(() => {
+    if (selectionStage !== 'jump-hop-runtime' || jumpHopRun) {
+      return;
+    }
+
+    const publicWorkCode = initialPublicWorkCode?.trim() ?? '';
+    const restoreKey = publicWorkCode || '__jump-hop-runtime-empty__';
+    if (handledJumpHopRuntimeRestoreRef.current === restoreKey) {
+      return;
+    }
+    handledJumpHopRuntimeRestoreRef.current = restoreKey;
+
+    if (!publicWorkCode) {
+      setJumpHopError(null);
+      setJumpHopRuntimeRequestOptions(null);
+      setJumpHopRuntimeReturnStage('platform');
+      setSelectionStage('platform');
+      pushAppHistoryPath('/');
+      return;
+    }
+
+    let cancelled = false;
+
+    const restoreJumpHopRuntime = async () => {
+      setIsJumpHopBusy(true);
+      setJumpHopError(null);
+      try {
+        const detail = await jumpHopClient.getGalleryDetail(publicWorkCode);
+        if (cancelled) {
+          return;
+        }
+        const profileId = detail.item.summary.profileId;
+        const started = await startJumpHopRunFromProfile(profileId, {
+          preloadedWork: detail.item,
+          returnStage: 'work-detail',
+        });
+        if (!started && !cancelled) {
+          setSelectionStage('platform');
+          pushAppHistoryPath('/');
+        }
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+        setJumpHopError(
+          resolveRpgCreationErrorMessage(error, '��跳一跳玩法失败。'),
+        );
+        setJumpHopRun(null);
+        setJumpHopRuntimeRequestOptions(null);
+        setJumpHopRuntimeReturnStage('platform');
+        setSelectionStage('platform');
+        pushAppHistoryPath('/');
+      } finally {
+        if (!cancelled) {
+          setIsJumpHopBusy(false);
+        }
+      }
+    };
+
+    void restoreJumpHopRuntime();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    initialPublicWorkCode,
+    jumpHopRun,
+    selectionStage,
+    setSelectionStage,
+    startJumpHopRunFromProfile,
+  ]);
+
   const restartJumpHopRuntimeRun = useCallback(async () => {
     const runId = jumpHopRun?.runId;
     if (!runId) {
@@ -13923,16 +14001,20 @@ export function PlatformEntryFlowShellImpl({
 
   useEffect(() => {
     const publicWorkCode = initialPublicWorkCode?.trim();
-    if (
-      !publicWorkCode ||
-      handledInitialPublicWorkCodeRef.current === publicWorkCode
-    ) {
+    if (!publicWorkCode) {
+      return;
+    }
+    if (selectionStage === 'jump-hop-runtime') {
+      handledInitialPublicWorkCodeRef.current = publicWorkCode;
+      return;
+    }
+    if (handledInitialPublicWorkCodeRef.current === publicWorkCode) {
       return;
     }
 
     handledInitialPublicWorkCodeRef.current = publicWorkCode;
     void handlePublicCodeSearch(publicWorkCode);
-  }, [handlePublicCodeSearch, initialPublicWorkCode]);
+  }, [handlePublicCodeSearch, initialPublicWorkCode, selectionStage]);
 
   useEffect(() => {
     if (selectionStage === 'platform') {
diff --git a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
index 71f288e4..d8fa7251 100644
--- a/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
+++ b/src/components/rpg-entry/RpgEntryFlowShell.agent.interaction.test.tsx
@@ -1695,6 +1695,28 @@ function buildMockJumpHopWork(
   };
 }
 
+function buildMockJumpHopRuntimeRun(
+  work: JumpHopWorkProfileResponse,
+  overrides: Partial<JumpHopRuntimeRunSnapshotResponse> = {},
+): JumpHopRuntimeRunSnapshotResponse {
+  return {
+    runId: 'jump-hop-run-1',
+    profileId: work.summary.profileId,
+    ownerUserId: work.summary.ownerUserId,
+    status: 'playing',
+    currentPlatformIndex: 0,
+    successfulJumpCount: 0,
+    durationMs: 0,
+    score: 0,
+    combo: 0,
+    path: work.path,
+    lastJump: null,
+    startedAtMs: 1_779_999_000_000,
+    finishedAtMs: null,
+    ...overrides,
+  };
+}
+
 function buildMockBarkBattleWork(
   overrides: Partial<BarkBattleWorkSummary> = {},
 ): BarkBattleWorkSummary {
@@ -6937,6 +6959,89 @@ test('logged out public jump-hop detail starts runtime without requireAuth', asy
   expect(requireAuth).not.toHaveBeenCalled();
 });
 
+test('direct jump hop runtime route without work code returns platform home', async () => {
+  window.history.replaceState(null, '', '/runtime/jump-hop');
+
+  render(<TestWrapper withAuth />);
+
+  await waitFor(() => {
+    expect(window.location.pathname).toBe('/');
+  });
+  expect(window.location.search).toBe('');
+  expect(jumpHopClient.getGalleryDetail).not.toHaveBeenCalled();
+  expect(jumpHopClient.startRun).not.toHaveBeenCalled();
+  expect(await screen.findByRole('button', { name: '创作' })).toBeTruthy();
+});
+
+test('direct jump hop runtime route with public work code starts published run', async () => {
+  const publishedJumpHopWork = buildMockJumpHopWork({
+    summary: {
+      runtimeKind: 'jump-hop',
+      workId: 'jump-hop-work-direct-1',
+      profileId: 'jump-hop-profile-direct-12345678',
+      ownerUserId: 'user-2',
+      sourceSessionId: 'jump-hop-session-direct-1',
+      themeText: '星星果园',
+      workTitle: '星星果园跳一跳',
+      workDescription: '沿�水果一路弹跳。',
+      themeTags: ['果园', '星星'],
+      difficulty: 'standard',
+      stylePreset: 'paper-toy',
+      coverImageSrc: null,
+      publicationStatus: 'published',
+      playCount: 8,
+      updatedAt: '2026-06-07T10:00:00.000Z',
+      publishedAt: '2026-06-07T10:00:00.000Z',
+      publishReady: true,
+      generationStatus: 'ready',
+    },
+  });
+  const publishedJumpHopRun = buildMockJumpHopRuntimeRun(publishedJumpHopWork, {
+    runId: 'jump-hop-run-direct-1',
+    ownerUserId: '',
+  });
+
+  window.history.replaceState(null, '', '/runtime/jump-hop?work=JH-12345678');
+  vi.mocked(jumpHopClient.getGalleryDetail).mockResolvedValue({
+    item: publishedJumpHopWork,
+  });
+  vi.mocked(jumpHopClient.startRun).mockResolvedValue({
+    run: publishedJumpHopRun,
+  });
+  vi.mocked(jumpHopClient.getLeaderboard).mockResolvedValue({
+    profileId: publishedJumpHopWork.summary.profileId,
+    items: [],
+    viewerBest: null,
+  });
+
+  render(
+    <TestWrapper
+      authValue={createAuthValue({
+        user: null,
+        canAccessProtectedData: false,
+        openLoginModal: () => {},
+        requireAuth: vi.fn(),
+      })}
+    />,
+  );
+
+  await waitFor(() => {
+    expect(jumpHopClient.getGalleryDetail).toHaveBeenCalledWith('JH-12345678');
+  });
+  await waitFor(() => {
+    expect(jumpHopClient.startRun).toHaveBeenCalledWith(
+      publishedJumpHopWork.summary.profileId,
+      expect.objectContaining({
+        runtimeGuestToken: 'runtime-guest-token',
+        runtimeMode: 'published',
+      }),
+    );
+  });
+  expect(jumpHopClient.getWorkDetail).not.toHaveBeenCalled();
+  expect(window.location.pathname).toBe('/runtime/jump-hop');
+  expect(window.location.search).toContain('work=JH-12345678');
+});
+
 test('owned public puzzle detail edits original draft instead of remixing', async () => {
   const user = userEvent.setup();
   const ownedPuzzleWork = {
diff --git a/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.test.tsx b/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.test.tsx
index b96baddc..ce24f6a5 100644
--- a/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.test.tsx
+++ b/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.test.tsx
@@ -65,7 +65,7 @@ test('jump hop workspace submits theme payload after required field is filled',
       difficulty: 'standard',
       stylePreset: 'minimal-blocks',
       characterPrompt: '内置默认 3D 角色',
-      tilePrompt: '云朵跳�主题的正�30度视角主题物体图集，物体本身作为跳跃�点',
+      tilePrompt: '云朵跳�主题的3D立方体主题身份方�包装图集',
       endMoodPrompt: null,
     });
   });
diff --git a/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.tsx b/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.tsx
index a07f7b12..83d18624 100644
--- a/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.tsx
+++ b/src/components/unified-creation/workspaces/JumpHopCreationWorkspace.tsx
@@ -40,7 +40,7 @@ function buildJumpHopWorkspacePayload(
     difficulty: 'standard',
     stylePreset: 'minimal-blocks',
     characterPrompt: '内置默认 3D 角色',
-    tilePrompt: `${themeText}主题的正�30度视角主题物体图集，物体本身作为跳跃�点`,
+    tilePrompt: `${themeText}主题的3D立方体主题身份方�包装图集`,
     endMoodPrompt: null,
   };
 }
diff --git a/src/services/jump-hop/jumpHopRuntimeModel.test.ts b/src/services/jump-hop/jumpHopRuntimeModel.test.ts
index 8a3e003d..66400f6b 100644
--- a/src/services/jump-hop/jumpHopRuntimeModel.test.ts
+++ b/src/services/jump-hop/jumpHopRuntimeModel.test.ts
@@ -6,28 +6,28 @@ import type {
 } from '../../../packages/shared/src/contracts/jumpHop';
 import {
   buildJumpHopVisiblePlatforms,
-  getJumpHopBackendDragVector,
   getJumpHopCharacterVisualPosition,
   getJumpHopJumpFeedbackLabel,
   getJumpHopLandingAssistVisualPosition,
   getJumpHopPlatformVisualSize,
   getJumpHopStatusLabel,
+  isJumpHopLandingInsidePlatformFootprint,
   resolveJumpHopCharacterCanvasPosition,
   selectJumpHopTileAsset,
 } from './jumpHopRuntimeModel';
 
-test('跳一跳地�池按平�编�从 25 个素�中抽�而�是按类型压�', () => {
-  const tileAssets = Array.from({ length: 25 }, (_, index) => ({
+test('跳一跳地�池按平�编�从 18 个素�中抽�而�是按类型压�', () => {
+  const tileAssets = Array.from({ length: 18 }, (_, index) => ({
     tileType: 'normal',
     tileId: `tile-${String(index + 1).padStart(2, '0')}`,
     imageSrc: `asset-${index + 1}`,
     imageObjectKey: `key-${index + 1}`,
     assetObjectId: `object-${index + 1}`,
-    sourceAtlasCell: `row-1-col-${index + 1}`,
-    atlasRow: 1,
-    atlasCol: index + 1,
+    sourceAtlasCell: `row-${Math.floor(index / 3) + 1}-col-${(index % 3) + 1}`,
+    atlasRow: Math.floor(index / 3) + 1,
+    atlasCol: (index % 3) + 1,
     visualWidth: 256,
-    visualHeight: 192,
+    visualHeight: 256,
     topSurfaceRadius: 42,
     landingRadius: 34,
   })) satisfies JumpHopTileAsset[];
@@ -59,15 +59,17 @@ test('跳一跳��平�窗�固定为 3 个并�带选中的地�素�',
       platform(0.8, 5.1, 'normal'),
     ],
   };
-  const tileAssets = Array.from({ length: 25 }, (_, index) => ({
+  const tileAssets = Array.from({ length: 18 }, (_, index) => ({
     tileType: 'normal',
     tileId: `tile-${String(index + 1).padStart(2, '0')}`,
     imageSrc: `asset-${index + 1}`,
     imageObjectKey: `key-${index + 1}`,
     assetObjectId: `object-${index + 1}`,
-    sourceAtlasCell: `row-1-col-${index + 1}`,
+    sourceAtlasCell: `row-${Math.floor(index / 3) + 1}-col-${(index % 3) + 1}`,
+    atlasRow: Math.floor(index / 3) + 1,
+    atlasCol: (index % 3) + 1,
     visualWidth: 256,
-    visualHeight: 192,
+    visualHeight: 256,
     topSurfaceRadius: 42,
     landingRadius: 34,
   })) satisfies JumpHopTileAsset[];
@@ -119,12 +121,12 @@ test('跳一跳三���地�按下方中部上方展开且角色�在当
     visible,
   );
 
-  expect(visible[0]?.screenY).toBeGreaterThanOrEqual(68);
-  expect(visible[0]?.screenY).toBeLessThanOrEqual(80);
+  expect(visible[0]?.screenY).toBeGreaterThanOrEqual(60);
+  expect(visible[0]?.screenY).toBeLessThanOrEqual(66);
   expect(visible[1]?.screenY).toBeGreaterThanOrEqual(40);
   expect(visible[1]?.screenY).toBeLessThan(visible[0]?.screenY ?? 0);
   expect(visible[2]?.screenY).toBeLessThan(visible[1]?.screenY ?? 0);
-  expect(visible[2]?.screenY).toBeLessThanOrEqual(26);
+  expect(visible[2]?.screenY).toBeLessThanOrEqual(32);
   expect(Math.abs((visible[1]?.screenX ?? 0) - (visible[0]?.screenX ?? 0))).toBeGreaterThan(5);
   expect(Math.abs((visible[2]?.screenX ?? 0) - (visible[1]?.screenX ?? 0))).toBeGreaterThan(5);
   expect(character?.screenX).toBeCloseTo(visible[0]?.screenX ?? 0, 1);
@@ -216,8 +218,8 @@ test('跳一跳三维角色画布�标与�幕�标��映射到下方起
 
   expect(canvasPosition?.x).toBeGreaterThan(140);
   expect(canvasPosition?.x).toBeLessThan(180);
-  expect(canvasPosition?.y).toBeGreaterThan(380);
-  expect(canvasPosition?.y).toBeLessThan(450);
+  expect(canvasPosition?.y).toBeGreaterThan(330);
+  expect(canvasPosition?.y).toBeLessThan(370);
 });
 
 test('跳一跳�行�当�地�视觉尺寸按原调�结果放大一�', () => {
@@ -227,7 +229,7 @@ test('跳一跳�行�当�地�视觉尺寸按原调�结果放大一�',
   expect(size.height).toBeCloseTo(103.68, 2);
 });
 
-test('跳一跳�点辅助标识按�端�点规则�拖拽方�和�离投影', () => {
+test('跳一跳�点预测按蓄力值沿下一地�中心方�投影', () => {
   const path: JumpHopPath = {
     seed: 'forest-tea',
     difficulty: 'standard',
@@ -265,22 +267,12 @@ test('跳一跳�点辅助标识按�端�点规则�拖拽方�和�离
   const current = visible[0]!;
   const target = visible[1]!;
   const stageSize = { width: 320, height: 568 };
-  const currentCanvasPosition = {
-    x: (current.screenX / 100) * stageSize.width,
-    y: (current.screenY / 100) * stageSize.height,
-  };
-  const targetCanvasPosition = {
-    x: (target.screenX / 100) * stageSize.width,
-    y: (target.screenY / 100) * stageSize.height,
-  };
   const targetWorldDistance = Math.hypot(
     target.platform.x - current.platform.x,
     target.platform.y - current.platform.y,
   );
   const fullDragDistance =
     targetWorldDistance / path.scoring.chargeToDistanceRatio;
-  const dragVectorX = -(targetCanvasPosition.x - currentCanvasPosition.x);
-  const dragVectorY = -(targetCanvasPosition.y - currentCanvasPosition.y);
 
   const fullAssist = getJumpHopLandingAssistVisualPosition(
     run,
@@ -288,8 +280,6 @@ test('跳一跳�点辅助标识按�端�点规则�拖拽方�和�离
     character,
     stageSize,
     fullDragDistance,
-    dragVectorX,
-    dragVectorY,
   );
   const halfAssist = getJumpHopLandingAssistVisualPosition(
     run,
@@ -297,23 +287,21 @@ test('跳一跳�点辅助标识按�端�点规则�拖拽方�和�离
     character,
     stageSize,
     fullDragDistance / 2,
-    dragVectorX,
-    dragVectorY,
   );
 
   expect(fullAssist?.screenX).toBeCloseTo(target.screenX, 1);
-  expect(fullAssist?.screenY).toBeCloseTo(target.screenY, 1);
+  expect(fullAssist?.screenY).toBeCloseTo(target.screenY - 3, 1);
   expect(halfAssist?.screenX).toBeCloseTo(
     current.screenX + (target.screenX - current.screenX) / 2,
     1,
   );
   expect(halfAssist?.screenY).toBeCloseTo(
-    current.screenY + (target.screenY - current.screenY) / 2,
+    current.screenY + (target.screenY - current.screenY) / 2 - 3,
     1,
   );
 });
 
-test('跳一跳�点辅助标识使用�幕�标��拖拽并投�上方目标地�', () => {
+test('跳一跳�点预测忽略旧客户端拖拽方�', () => {
   const path: JumpHopPath = {
     seed: 'forest-tea',
     difficulty: 'standard',
@@ -351,16 +339,6 @@ test('跳一跳�点辅助标识使用�幕�标��拖拽并投�上方
   const current = visible[0]!;
   const target = visible[1]!;
   const stageSize = { width: 320, height: 568 };
-  const currentCanvasPosition = {
-    x: (current.screenX / 100) * stageSize.width,
-    y: (current.screenY / 100) * stageSize.height,
-  };
-  const targetCanvasPosition = {
-    x: (target.screenX / 100) * stageSize.width,
-    y: (target.screenY / 100) * stageSize.height,
-  };
-  const dragVectorX = -(targetCanvasPosition.x - currentCanvasPosition.x);
-  const dragVectorY = currentCanvasPosition.y - targetCanvasPosition.y;
   const targetWorldDistance = Math.hypot(
     target.platform.x - current.platform.x,
     target.platform.y - current.platform.y,
@@ -374,16 +352,29 @@ test('跳一跳�点辅助标识使用�幕�标��拖拽并投�上方
     character,
     stageSize,
     fullDragDistance,
-    dragVectorX,
-    dragVectorY,
+    -999,
+    -999,
   );
 
-  expect(dragVectorY).toBeGreaterThan(0);
   expect(assist?.screenX).toBeCloseTo(target.screenX, 1);
-  expect(assist?.screenY).toBeCloseTo(target.screenY, 1);
+  expect(assist?.screenY).toBeCloseTo(target.screenY - 3, 1);
+  expect(assist?.isOnTargetPlatform).toBe(true);
 });
 
-test('跳一跳�端�点��会把�幕拖拽�算为世界尺度一致的��弹射', () => {
+test('跳一跳�点预测用收缩�的视觉顶� footprint 判断命中', () => {
+  const target = {
+    ...platform(1, 0, 'normal'),
+    width: 2,
+    height: 0.6,
+    landingRadius: 0.2,
+  };
+
+  expect(isJumpHopLandingInsidePlatformFootprint(target, 1.6, 0)).toBe(true);
+  expect(isJumpHopLandingInsidePlatformFootprint(target, 1.8, 0)).toBe(false);
+  expect(isJumpHopLandingInsidePlatformFootprint(target, 1, 0.18)).toBe(false);
+});
+
+test('跳一跳�功�地��留真实�点�移而�是�附到地�中心', () => {
   const path: JumpHopPath = {
     seed: 'forest-tea',
     difficulty: 'standard',
@@ -406,41 +397,34 @@ test('跳一跳�端�点��会把�幕拖拽�算为世界尺度一致
     profileId: 'profile-1',
     ownerUserId: 'user-1',
     status: 'playing',
-    currentPlatformIndex: 0,
-    successfulJumpCount: 0,
+    currentPlatformIndex: 1,
+    successfulJumpCount: 1,
     durationMs: 0,
-    score: 0,
+    score: 1,
     combo: 0,
     path,
-    lastJump: null,
+    lastJump: {
+      chargeMs: 300,
+      jumpDistance: 1.0,
+      targetPlatformIndex: 1,
+      landedX: 0.52,
+      landedY: 0.78,
+      result: 'hit',
+    },
     startedAtMs: 1000,
     finishedAtMs: null,
   } as const;
-  const visible = buildJumpHopVisiblePlatforms(path, 0, []);
-  const current = visible[0]!;
-  const target = visible[1]!;
-  const stageSize = { width: 320, height: 568 };
-  const currentCanvasPosition = {
-    x: (current.screenX / 100) * stageSize.width,
-    y: (current.screenY / 100) * stageSize.height,
-  };
-  const targetCanvasPosition = {
-    x: (target.screenX / 100) * stageSize.width,
-    y: (target.screenY / 100) * stageSize.height,
-  };
-  const dragVectorX = -(targetCanvasPosition.x - currentCanvasPosition.x);
-  const dragVectorY = currentCanvasPosition.y - targetCanvasPosition.y;
-  const backendVector = getJumpHopBackendDragVector(
-    run,
-    visible,
-    stageSize,
-    dragVectorX,
-    dragVectorY,
-  );
+  const visible = buildJumpHopVisiblePlatforms(path, 1, []);
+  const character = getJumpHopCharacterVisualPosition(run, visible, {
+    width: 320,
+    height: 568,
+  });
+  const currentCenter = visible[0]!;
 
-  expect(backendVector.dragVectorX).toBeLessThan(0);
-  expect(backendVector.dragVectorY).toBeGreaterThan(0);
-  expect(Math.abs(backendVector.dragVectorY)).toBeLessThan(Math.abs(dragVectorY));
+  expect(character?.screenX).not.toBeCloseTo(currentCenter.screenX, 1);
+  expect(character?.screenY).not.toBeCloseTo(currentCenter.screenY - 3, 1);
+  expect(character?.screenX).toBeLessThan(currentCenter.screenX);
+  expect(character?.screenY).toBeGreaterThan(currentCenter.screenY - 3);
 });
 
 test('跳一跳�行�公开�馈��展示旧 perfect 和通关语义', () => {
diff --git a/src/services/jump-hop/jumpHopRuntimeModel.ts b/src/services/jump-hop/jumpHopRuntimeModel.ts
index a65ca19e..b34e4655 100644
--- a/src/services/jump-hop/jumpHopRuntimeModel.ts
+++ b/src/services/jump-hop/jumpHopRuntimeModel.ts
@@ -42,6 +42,7 @@ export type JumpHopLandingAssistVisualPosition = {
   screenX: number;
   screenY: number;
   targetPlatformIndex: number;
+  isOnTargetPlatform: boolean;
 };
 
 export type JumpHopBackendDragVector = {
@@ -49,12 +50,19 @@ export type JumpHopBackendDragVector = {
   dragVectorY: number;
 };
 
+const JUMP_HOP_DEFAULT_CHARGE_TO_DISTANCE_RATIO = 0.004;
+const JUMP_HOP_DEFAULT_STAGE_SIZE: JumpHopCanvasSize = {
+  width: 320,
+  height: 568,
+};
 const VISIBLE_PLATFORM_COUNT = 3;
 const JUMP_HOP_STAGE_WORLD_SCALE = 4.2;
 const JUMP_HOP_STAGE_FORWARD_SCALE = 3;
-const JUMP_HOP_VISIBLE_PLATFORM_SCREEN_Y = [78, 50, 22] as const;
+const JUMP_HOP_VISIBLE_PLATFORM_SCREEN_Y = [64, 47, 30] as const;
 const JUMP_HOP_PLATFORM_VISUAL_SIZE_MULTIPLIER = 2;
-const JUMP_HOP_SCREEN_X_WORLD_PERCENT = 16 * 0.96;
+const JUMP_HOP_SCREEN_X_WORLD_PERCENT = 11.2;
+const JUMP_HOP_TOP_FACE_HITBOX_WIDTH_RATIO = 0.72;
+const JUMP_HOP_TOP_FACE_HITBOX_HEIGHT_RATIO = 0.52;
 
 const tileToneByType: Record<JumpHopTileType, string> = {
   accent: '#e0f2fe',
@@ -128,7 +136,7 @@ export function buildJumpHopVisiblePlatforms(
         : depth === 1
           ? JUMP_HOP_VISIBLE_PLATFORM_SCREEN_Y[1]
           : JUMP_HOP_VISIBLE_PLATFORM_SCREEN_Y[2];
-    const screenX = clamp(50 + dx * 16 * worldScale, 14, 86);
+    const screenX = clamp(50 + dx * JUMP_HOP_SCREEN_X_WORLD_PERCENT, 14, 86);
 
     return {
       platform,
@@ -198,6 +206,31 @@ function getJumpHopCanvasPosition(
   };
 }
 
+function getJumpHopCharacterVisualPositionFromPlatform(
+  platform: JumpHopVisiblePlatform,
+  isMiss = false,
+): JumpHopCharacterVisualPosition {
+  if (isMiss) {
+    return {
+      screenX: platform.screenX + 8,
+      screenY: platform.screenY - 2,
+      sceneX: platform.sceneX + 0.7,
+      sceneY: platform.sceneY + 0.48,
+      sceneZ: platform.sceneZ - 0.4,
+      isMiss: true,
+    };
+  }
+
+  return {
+    screenX: platform.screenX,
+    screenY: platform.screenY - 3,
+    sceneX: platform.sceneX,
+    sceneY: platform.sceneY + 0.84,
+    sceneZ: platform.sceneZ,
+    isMiss: false,
+  };
+}
+
 function getJumpHopScreenWorldScales(
   currentPlatform: JumpHopVisiblePlatform,
   targetPlatform: JumpHopVisiblePlatform,
@@ -257,6 +290,155 @@ function getJumpHopScreenWorldScales(
   };
 }
 
+export function getJumpHopWorldLandingVisualPosition(
+  originPlatform: JumpHopVisiblePlatform | null | undefined,
+  scalePlatform: JumpHopVisiblePlatform | null | undefined,
+  stageSize: JumpHopCanvasSize,
+  landedX: number,
+  landedY: number,
+  isMiss = false,
+): JumpHopCharacterVisualPosition | null {
+  if (
+    !originPlatform ||
+    !scalePlatform ||
+    stageSize.width <= 0 ||
+    stageSize.height <= 0 ||
+    !Number.isFinite(landedX) ||
+    !Number.isFinite(landedY)
+  ) {
+    return null;
+  }
+
+  const scales = getJumpHopScreenWorldScales(
+    originPlatform,
+    scalePlatform,
+    stageSize,
+  );
+  const worldDeltaX = landedX - originPlatform.platform.x;
+  const worldDeltaY = landedY - originPlatform.platform.y;
+  const landedPixelX =
+    scales.currentCanvasPosition.x +
+    worldDeltaX * scales.signedXScreenPerWorld;
+  const landedPixelY =
+    scales.currentCanvasPosition.y +
+    worldDeltaY * scales.signedYScreenPerWorld;
+  const sceneDeltaX =
+    (landedX - originPlatform.platform.x) * JUMP_HOP_STAGE_WORLD_SCALE;
+  const sceneDeltaZ =
+    (landedY - originPlatform.platform.y) * JUMP_HOP_STAGE_FORWARD_SCALE;
+
+  return {
+    screenX: clamp((landedPixelX / stageSize.width) * 100, 6, 94),
+    screenY: clamp((landedPixelY / stageSize.height) * 100 - 3, 10, 92),
+    sceneX: originPlatform.sceneX + sceneDeltaX,
+    sceneY: originPlatform.sceneY + (isMiss ? 0.48 : 0.84),
+    sceneZ: originPlatform.sceneZ + sceneDeltaZ,
+    isMiss,
+  };
+}
+
+export function isJumpHopLandingInsidePlatformFootprint(
+  platform: JumpHopPlatform | null | undefined,
+  landedX: number,
+  landedY: number,
+) {
+  if (
+    !platform ||
+    !Number.isFinite(landedX) ||
+    !Number.isFinite(landedY)
+  ) {
+    return false;
+  }
+
+  const halfWidth = Math.max(
+    0,
+    platform.width * 0.5 * JUMP_HOP_TOP_FACE_HITBOX_WIDTH_RATIO,
+  );
+  const halfHeight = Math.max(
+    0,
+    platform.height * 0.5 * JUMP_HOP_TOP_FACE_HITBOX_HEIGHT_RATIO,
+  );
+  return (
+    Math.abs(landedX - platform.x) <= halfWidth &&
+    Math.abs(landedY - platform.y) <= halfHeight
+  );
+}
+
+function getJumpHopSuccessfulLandingVisualPosition(
+  run: JumpHopRuntimeRunSnapshotResponse,
+  platforms: JumpHopVisiblePlatform[],
+  stageSize: JumpHopCanvasSize,
+) {
+  const lastJump = run.lastJump;
+  if (!lastJump) {
+    return null;
+  }
+
+  const landedPlatform =
+    platforms.find((item) => item.index === run.currentPlatformIndex) ??
+    platforms.find((item) => item.index === lastJump.targetPlatformIndex) ??
+    null;
+  if (!landedPlatform) {
+    return null;
+  }
+
+  const previousPlatformIndex = Math.max(0, lastJump.targetPlatformIndex - 1);
+  const previousWindowPlatforms = buildJumpHopVisiblePlatforms(
+    run.path,
+    previousPlatformIndex,
+    [],
+  );
+  const previousPlatform =
+    previousWindowPlatforms.find(
+      (item) => item.index === previousPlatformIndex,
+    ) ?? null;
+  const targetPlatformInPreviousWindow =
+    previousWindowPlatforms.find(
+      (item) => item.index === lastJump.targetPlatformIndex,
+    ) ?? null;
+  const landingInPreviousWindow = getJumpHopWorldLandingVisualPosition(
+    previousPlatform,
+    targetPlatformInPreviousWindow,
+    stageSize,
+    lastJump.landedX,
+    lastJump.landedY,
+    false,
+  );
+  if (!landingInPreviousWindow || !targetPlatformInPreviousWindow) {
+    return null;
+  }
+
+  const targetCenterInPreviousWindow =
+    getJumpHopCharacterVisualPositionFromPlatform(
+      targetPlatformInPreviousWindow,
+    );
+  const landedPlatformCenter =
+    getJumpHopCharacterVisualPositionFromPlatform(landedPlatform);
+  const worldDeltaX = lastJump.landedX - landedPlatform.platform.x;
+  const worldDeltaY = lastJump.landedY - landedPlatform.platform.y;
+
+  return {
+    screenX: clamp(
+      landedPlatformCenter.screenX +
+        landingInPreviousWindow.screenX -
+        targetCenterInPreviousWindow.screenX,
+      6,
+      94,
+    ),
+    screenY: clamp(
+      landedPlatformCenter.screenY +
+        landingInPreviousWindow.screenY -
+        targetCenterInPreviousWindow.screenY,
+      10,
+      92,
+    ),
+    sceneX: landedPlatform.sceneX + worldDeltaX * JUMP_HOP_STAGE_WORLD_SCALE,
+    sceneY: landedPlatform.sceneY + 0.84,
+    sceneZ: landedPlatform.sceneZ + worldDeltaY * JUMP_HOP_STAGE_FORWARD_SCALE,
+    isMiss: false,
+  };
+}
+
 export function getJumpHopBackendDragVector(
   run: JumpHopRuntimeRunSnapshotResponse | null,
   platforms: JumpHopVisiblePlatform[],
@@ -290,8 +472,8 @@ export function getJumpHopLandingAssistVisualPosition(
   characterPosition: JumpHopCharacterVisualPosition | null,
   stageSize: JumpHopCanvasSize,
   dragDistance: number,
-  dragVectorX: number | null,
-  dragVectorY: number | null,
+  _dragVectorX?: number | null,
+  _dragVectorY?: number | null,
 ) {
   if (
     !run ||
@@ -310,27 +492,13 @@ export function getJumpHopLandingAssistVisualPosition(
   }
   const { currentPlatform, targetPlatform } = pair;
 
-  const dragX = dragVectorX ?? 0;
-  const dragY = dragVectorY ?? 0;
-  const dragLength = Math.hypot(dragX, dragY);
-  if (dragLength < 0.0001) {
-    return null;
-  }
-
   const scales = getJumpHopScreenWorldScales(
     currentPlatform,
     targetPlatform,
     stageSize,
   );
-  const backendDragVector = getJumpHopBackendDragVector(
-    run,
-    platforms,
-    stageSize,
-    dragX,
-    dragY,
-  );
-  const jumpWorldX = -backendDragVector.dragVectorX;
-  const jumpWorldY = backendDragVector.dragVectorY;
+  const jumpWorldX = targetPlatform.platform.x - currentPlatform.platform.x;
+  const jumpWorldY = targetPlatform.platform.y - currentPlatform.platform.y;
   const jumpWorldLength = Math.hypot(jumpWorldX, jumpWorldY);
   if (jumpWorldLength < 0.0001) {
     return null;
@@ -341,13 +509,15 @@ export function getJumpHopLandingAssistVisualPosition(
   const chargeToDistanceRatio =
     run.path.scoring.chargeToDistanceRatio > 0
       ? run.path.scoring.chargeToDistanceRatio
-      : 0.008;
+      : JUMP_HOP_DEFAULT_CHARGE_TO_DISTANCE_RATIO;
   const projectedWorldDistance =
     clamp(dragDistance, 0, maxDragDistance) * chargeToDistanceRatio;
   const landedWorldDeltaX =
     (jumpWorldX / jumpWorldLength) * projectedWorldDistance;
   const landedWorldDeltaY =
     (jumpWorldY / jumpWorldLength) * projectedWorldDistance;
+  const landedWorldX = currentPlatform.platform.x + landedWorldDeltaX;
+  const landedWorldY = currentPlatform.platform.y + landedWorldDeltaY;
   const landedPixelX =
     scales.currentCanvasPosition.x +
     landedWorldDeltaX * scales.signedXScreenPerWorld;
@@ -357,8 +527,13 @@ export function getJumpHopLandingAssistVisualPosition(
 
   return {
     screenX: clamp((landedPixelX / stageSize.width) * 100, 6, 94),
-    screenY: clamp((landedPixelY / stageSize.height) * 100, 10, 92),
+    screenY: clamp((landedPixelY / stageSize.height) * 100 - 3, 10, 92),
     targetPlatformIndex: targetPlatform.index,
+    isOnTargetPlatform: isJumpHopLandingInsidePlatformFootprint(
+      targetPlatform.platform,
+      landedWorldX,
+      landedWorldY,
+    ),
   };
 }
 
@@ -379,39 +554,64 @@ export function resolveJumpHopCharacterCanvasPosition(
 export function getJumpHopCharacterVisualPosition(
   run: JumpHopRuntimeRunSnapshotResponse | null,
   platforms: JumpHopVisiblePlatform[],
+  stageSize: JumpHopCanvasSize = JUMP_HOP_DEFAULT_STAGE_SIZE,
 ) {
   if (!run) {
     return null;
   }
 
+  const lastJump = run.lastJump;
+  if (lastJump) {
+    const isMiss = lastJump.result === 'miss';
+    if (!isMiss) {
+      const landedPosition = getJumpHopSuccessfulLandingVisualPosition(
+        run,
+        platforms,
+        stageSize,
+      );
+      if (landedPosition) {
+        return landedPosition;
+      }
+    }
+
+    const originPlatform =
+      platforms.find((item) => item.index === run.currentPlatformIndex) ??
+      platforms[0] ??
+      null;
+    const scalePlatform =
+      platforms.find((item) =>
+        isMiss
+          ? item.index === lastJump.targetPlatformIndex
+          : item.index === run.currentPlatformIndex + 1,
+      ) ??
+      platforms.find((item) => item.index === lastJump.targetPlatformIndex) ??
+      originPlatform;
+    const landedPosition = getJumpHopWorldLandingVisualPosition(
+      originPlatform,
+      scalePlatform,
+      stageSize,
+      lastJump.landedX,
+      lastJump.landedY,
+      isMiss,
+    );
+    if (landedPosition) {
+      return landedPosition;
+    }
+  }
+
   const landedPlatform = platforms.find(
     (item) => item.index === run.currentPlatformIndex,
   );
   if (landedPlatform) {
-    return {
-      screenX: landedPlatform.screenX,
-      screenY: landedPlatform.screenY - 3,
-      sceneX: landedPlatform.sceneX,
-      sceneY: landedPlatform.sceneY + 0.84,
-      sceneZ: landedPlatform.sceneZ,
-      isMiss: false,
-    };
+    return getJumpHopCharacterVisualPositionFromPlatform(landedPlatform);
   }
 
-  const lastJump = run.lastJump;
   if (lastJump && run.status === 'failed') {
     const targetPlatform = platforms.find(
       (item) => item.index === lastJump.targetPlatformIndex,
     );
     if (targetPlatform) {
-      return {
-        screenX: targetPlatform.screenX + 8,
-        screenY: targetPlatform.screenY - 2,
-        sceneX: targetPlatform.sceneX + 0.7,
-        sceneY: targetPlatform.sceneY + 0.48,
-        sceneZ: targetPlatform.sceneZ - 0.4,
-        isMiss: true,
-      };
+      return getJumpHopCharacterVisualPositionFromPlatform(targetPlatform, true);
     }
   }
 
diff --git a/src/services/miniGameDraftGenerationProgress.test.ts b/src/services/miniGameDraftGenerationProgress.test.ts
index 1f7e4649..f5de30d6 100644
--- a/src/services/miniGameDraftGenerationProgress.test.ts
+++ b/src/services/miniGameDraftGenerationProgress.test.ts
@@ -505,7 +505,7 @@ describe('miniGameDraftGenerationProgress', () => {
       'jump-hop-write-draft',
     ]);
     expect(progress?.phaseId).toBe('jump-hop-tile-atlas');
-    expect(progress?.phaseLabel).toBe('生� 5x5 地�图集');
+    expect(progress?.phaseLabel).toBe('生� UV 贴图图集');
     expect(progress?.estimatedRemainingMs).toBe(265_000);
   });
 
@@ -513,7 +513,7 @@ describe('miniGameDraftGenerationProgress', () => {
     const entries = buildJumpHopGenerationAnchorEntries(null, {
       themeText: '云端糖果塔',
       templateId: 'jump-hop',
-      tilePrompt: '云端糖果塔主题的正�30度视角主题物体图集，物体本身作为跳跃�点',
+      tilePrompt: '云端糖果塔主题的3D立方体主题身份方�包装图集',
     });
 
     expect(entries).toEqual([
@@ -524,8 +524,8 @@ describe('miniGameDraftGenerationProgress', () => {
       },
       {
         id: 'jump-hop-tile-style',
-        label: '地�图集',
-        value: '云端糖果塔主题的正�30度视角主题物体图集，物体本身作为跳跃�点',
+        label: '地�贴图',
+        value: '云端糖果塔主题的3D立方体主题身份方�包装图集',
       },
     ]);
   });
diff --git a/src/services/miniGameDraftGenerationProgress.ts b/src/services/miniGameDraftGenerationProgress.ts
index a53d87e6..302b5d59 100644
--- a/src/services/miniGameDraftGenerationProgress.ts
+++ b/src/services/miniGameDraftGenerationProgress.ts
@@ -408,20 +408,20 @@ const JUMP_HOP_STEPS = [
   },
   {
     id: 'jump-hop-tile-atlas',
-    label: '生� 5x5 地�图集',
-    detail: '调用 image2 生� 25 个主题地�素�。',
+    label: '生� UV 贴图图集',
+    detail: '调用 image2 一次生� 18 个立方体六�展开包装。',
     weight: 54,
   },
   {
     id: 'jump-hop-slice-tiles',
-    label: '切分 25 个地�',
-    detail: '按 5 行 5 列切分�明地� PNG。',
+    label: '切分六�贴图',
+    detail: '按 3 列 6 行与 4x3 UV 网切分 108 张�贴图 PNG。',
     weight: 24,
   },
   {
     id: 'jump-hop-write-draft',
     label: '写入正��稿',
-    detail: '�存地�池�无�路径缓冲和�行��置。',
+    detail: '�存地�贴图池�无�路径缓冲和�行��置。',
     weight: 10,
   },
 ] as const satisfies ReadonlyArray<MiniGameStepDefinition>;
@@ -1183,7 +1183,7 @@ export function buildJumpHopGenerationAnchorEntries(
     },
     {
       key: 'jump-hop-tile-style',
-      label: '地�图集',
+      label: '地�贴图',
       value:
         formPayload?.tilePrompt?.trim() ||
         config?.tilePrompt?.trim() ||