汤锅功能实现 3 计时提示修改

2026-09-16 11:12:15 +08:00
1 parent df71a62d7c
commit 31bb44a409
@@ -80,6 +80,7 @@ class ChujuService(BlueFoxServerSystem):
        self.beaterBlockSet = set(BEATER_BLOCKS)

        # ---- 空手右键"丸子机计时源"(meatballmaker_3/4): 放在点燃炉灶上 -> 开始计时 ----
+        # 提示包含"总共多少秒": _3(加料完成) 半熟30秒+熟30秒=60秒; _4(半熟) 剩30秒
        self.timerSources = set()
        self.startTimerTips = {}
        for r in MEATBALL_TIMERS:
@@ -88,7 +89,10 @@ class ChujuService(BlueFoxServerSystem):
            self.featureBlocks.add(src)
            if src not in self.startTimerTips:
                sec = r.get("time", 60)
-                self.startTimerTips[src] = "§a开始烹制…等计时(%d秒)结束变成 下一形态" % sec
+                if src == "rtdd:meatballmaker_3":
+                    self.startTimerTips[src] = "§a开始烹制…共需计时60秒(半熟30秒+熟30秒); 计时结束变成 章鱼小丸子"
+                else:
+                    self.startTimerTips[src] = "§a开始烹制…共需计时%d秒; 计时结束变成 章鱼小丸子" % sec

        # ---- 右键冷却表 ----
        self.cooldown = {}
@@ -330,22 +330,22 @@ ITEM_USE_ON_RULES = [
     "replace": "rtdd:steamerdumplings_0", "consume": 4,
     "startTimer": "rtdd:steamerdumplings_0",
     "needBelow": LIT_STOVE, "belowTip": "§c蒸笼需要放在点燃的炉灶上",
-     "tip": "§a四个生饺子放进蒸笼, 开始蒸制"},
+     "tip": "§a四个生饺子放进蒸笼, 开始蒸制(共60秒); 计时结束变成 熟饺子"},
    {"item": "rtdd:roubaozi_3", "surface": STEAMER,
     "replace": "rtdd:baozilong_1", "consume": 3,
     "startTimer": "rtdd:baozilong_1",
     "needBelow": LIT_STOVE, "belowTip": "§c蒸笼需要放在点燃的炉灶上",
-     "tip": "§a三个生肉包子放进蒸笼, 开始蒸制"},
+     "tip": "§a三个生肉包子放进蒸笼, 开始蒸制(共60秒); 计时结束变成 熟包子"},
    {"item": "rtdd:bamboo_4", "surface": STEAMER,
     "replace": "rtdd:bamboo_6", "consume": 1,
     "startTimer": "rtdd:bamboo_6",
     "needBelow": LIT_STOVE, "belowTip": "§c蒸笼需要放在点燃的炉灶上",
-     "tip": "§a竹筒饭放进蒸笼, 开始蒸制"},
+     "tip": "§a竹筒饭放进蒸笼, 开始蒸制(共60秒); 计时结束变成 熟竹筒饭"},
    {"item": "rtdd:plate_34", "surface": STEAMER,
     "replace": "rtdd:steamermilkandegg", "consume": 1,
     "startTimer": "rtdd:steamermilkandegg",
     "needBelow": LIT_STOVE, "belowTip": "§c蒸笼需要放在点燃的炉灶上",
-     "tip": "§a蛋液半成品放进蒸笼, 开始蒸制"},
+     "tip": "§a蛋液半成品放进蒸笼, 开始蒸制(共60秒); 计时结束变成 蒸牛奶鸡蛋"},
 ]

 # ============================================================================
@@ -106,7 +106,7 @@ class MianshiService(BlueFoxServerSystem):
            if src not in self.startTimerTips:
                sec = r.get("time", 60)
                tgt = NAME_MAP.get(r["target"], r["target"])
-                self.startTimerTips[src] = "§a开始蒸制…等计时(%d秒)结束变成 %s" % (sec, tgt)
+                self.startTimerTips[src] = "§a开始蒸制…共需计时%d秒; 计时结束变成 %s" % (sec, tgt)

        # ---- 结果方块/物品 -> "下一步"可读提示(供转换/入笼提示追加) ----
        #   例子: 饺子皮 -> "加入 猪肉馅、青菜碎"; 可颂面胚 -> "放在烤炉上等计时(60秒)结束变成 可颂"
@@ -193,7 +193,7 @@ class MianshiService(BlueFoxServerSystem):
        if blockName in OVEN_FIX_BLOCKS and self._belowIs(dim, pos, OVEN):
            FeatureDispatcher.startTimerFor(blockName, dim, pos, playerId)
            if self.checkCooldown(key, 0.4):
-                tip = "§a开始烤制…(60秒)，等计时结束变成 " + \
+                tip = "§a开始烤制…共需计时60秒; 计时结束变成 " + \
                    self.timerTargetName.get(blockName, "成品")
                comp.CreateMsg(playerId).NotifyOneMessage(playerId, tip)
            return True
@@ -277,64 +277,64 @@ SWITCH_RULES = [
    # ---------------- 四、加肉/鱼/豆腐 -> 汤羹(生), 开始计时 ----------------
    {"block": CARROT_SOUP, "item": BEEF, "target": CARROT_BEEF_SOUP,
     "consume": 2, "startTimer": CARROT_BEEF_SOUP,
-     "tip": "§a胡萝卜汤加生牛肉x2, 开始计时熬制(30秒/级); 等计时结束变成 胡萝卜牛肉汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜汤加生牛肉x2, 开始熬制(共90秒, 3级×30秒); 等计时结束变成 胡萝卜牛肉汤(熟), 手持木碗出锅"},
    {"block": CARROT_SOUP, "item": MUTTON, "target": LAMB_SOUP_WITH_TURNIPS,
     "consume": 2, "startTimer": LAMB_SOUP_WITH_TURNIPS,
-     "tip": "§a胡萝卜汤加羊肉x2, 开始计时熬制(60秒/级); 等计时结束变成 胡萝卜羊肉汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜汤加羊肉x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 胡萝卜羊肉汤(熟), 手持木碗出锅"},
    {"block": CARROT_SOUP, "item": PORKRIB, "target": CARROT_RIBS,
     "consume": 2, "startTimer": CARROT_RIBS,
-     "tip": "§a胡萝卜汤加猪肋排x2, 开始计时熬制(60秒/级); 等计时结束变成 胡萝卜排骨汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜汤加猪肋排x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 胡萝卜排骨汤(熟), 手持木碗出锅"},
    {"block": VEGETABLE_SOUP, "item": MUTTON, "target": VEGETABLE_BEEF_SOUP,
     "consume": 2, "startTimer": VEGETABLE_BEEF_SOUP,
-     "tip": "§a蔬菜汤加羊肉x2, 开始计时熬制(60秒/级); 等计时结束变成 清汤羊肉(熟), 手持木碗出锅"},
+     "tip": "§a蔬菜汤加羊肉x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 清汤羊肉(熟), 手持木碗出锅"},
    {"block": VEGETABLE_SOUP, "item": BEEF, "target": VEGETABLE_LAMB_SOUP,
     "consume": 2, "startTimer": VEGETABLE_LAMB_SOUP,
-     "tip": "§a蔬菜汤加生牛肉x2, 开始计时熬制(60秒/级); 等计时结束变成 蔬菜牛肉汤(熟), 手持木碗出锅"},
+     "tip": "§a蔬菜汤加生牛肉x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 蔬菜牛肉汤(熟), 手持木碗出锅"},
    {"block": VEGETABLE_SOUP, "item": CRUSHED_MEAT, "target": VEGETABLE_LEAN_BROTH,
     "consume": 5, "startTimer": VEGETABLE_LEAN_BROTH,
-     "tip": "§a蔬菜汤加碎肉x5, 开始计时熬制(60秒/级); 等计时结束变成 蔬菜瘦肉汤(熟), 手持木碗出锅"},
+     "tip": "§a蔬菜汤加碎肉x5, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 蔬菜瘦肉汤(熟), 手持木碗出锅"},
    {"block": VEGETABLE_SOUP, "item": CARROT_POTATO_SOUP, "target": VEGETABLE_SSTEW,
     "consume": 1, "drop": POT_EMPTY, "startTimer": VEGETABLE_SSTEW,
-     "tip": "§a蔬菜汤加胡萝卜土豆汤, 变成 蔬菜乱炖(生), 掉落一个汤锅(空); 等计时结束变熟, 手持木碗出锅"},
+     "tip": "§a蔬菜汤加胡萝卜土豆汤, 变成 蔬菜乱炖(生), 掉落一个汤锅(空); 开始熬制(共180秒, 3级×60秒), 等计时结束变熟, 手持木碗出锅"},
    {"block": CARROT_POTATO_SOUP, "item": VEGETABLE, "target": VEGETABLE_SSTEW,
     "consume": 3, "startTimer": VEGETABLE_SSTEW,
-     "tip": "§a胡萝卜土豆汤加青菜碎x3, 变成 蔬菜乱炖(生); 等计时结束变熟, 手持木碗出锅"},
+     "tip": "§a胡萝卜土豆汤加青菜碎x3, 变成 蔬菜乱炖(生); 开始熬制(共180秒, 3级×60秒), 等计时结束变熟, 手持木碗出锅"},
    {"block": CARROT_POTATO_SOUP, "item": COW_RIBS, "target": BEEF_BONE_BROTH,
     "consume": 2, "startTimer": BEEF_BONE_BROTH,
-     "tip": "§a胡萝卜土豆汤加牛肋x2, 开始计时熬制(60秒/级); 等计时结束变成 胡萝卜土豆牛骨汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜土豆汤加牛肋x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 胡萝卜土豆牛骨汤(熟), 手持木碗出锅"},
    {"block": CARROT_POTATO_SOUP, "item": MUTTON, "target": LAMB_STEW,
     "consume": 2, "startTimer": LAMB_STEW,
-     "tip": "§a胡萝卜土豆汤加羊肉x2, 开始计时熬制(60秒/级); 等计时结束变成 土豆胡萝卜炖羊肉(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜土豆汤加羊肉x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 土豆胡萝卜炖羊肉(熟), 手持木碗出锅"},
    {"block": CARROT_POTATO_SOUP, "item": SHEEP_RACKS, "target": VEGETABLE_POTATOES_LAMBSTEAK,
     "consume": 2, "startTimer": VEGETABLE_POTATOES_LAMBSTEAK,
-     "tip": "§a胡萝卜土豆汤加羊小排x2, 开始计时熬制(60秒/级); 等计时结束变成 胡萝卜土豆羊排汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜土豆汤加羊小排x2, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 胡萝卜土豆羊排汤(熟), 手持木碗出锅"},
    {"block": CARROT_SOUP, "item": COD, "target": CARROT_COD_SOUP,
     "consume": 1, "startTimer": CARROT_COD_SOUP,
-     "tip": "§a胡萝卜汤加鳕鱼, 开始计时熬制(60秒/级); 等计时结束变成 胡萝卜鳕鱼汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜汤加鳕鱼, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 胡萝卜鳕鱼汤(熟), 手持木碗出锅"},
    {"block": CARROT_SOUP, "item": SALMON, "target": CARROT_FISH_SOUP,
     "consume": 1, "startTimer": CARROT_FISH_SOUP,
-     "tip": "§a胡萝卜汤加鲑鱼, 开始计时熬制(60秒/级); 等计时结束变成 胡萝卜鲑鱼汤(熟), 手持木碗出锅"},
+     "tip": "§a胡萝卜汤加鲑鱼, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 胡萝卜鲑鱼汤(熟), 手持木碗出锅"},
    {"block": COD_SOUP, "item": EGG, "target": EGG_COD_SOUP,
     "consume": 3, "startTimer": EGG_COD_SOUP,
-     "tip": "§a鳕鱼汤加鸡蛋x3, 开始计时熬制(60秒/级); 等计时结束变成 蛋花鳕鱼汤(熟), 手持木碗出锅"},
+     "tip": "§a鳕鱼汤加鸡蛋x3, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 蛋花鳕鱼汤(熟), 手持木碗出锅"},
    {"block": EGG_SOUP, "item": COD, "target": EGG_COD_SOUP,
     "consume": 1, "startTimer": EGG_COD_SOUP,
-     "tip": "§a蛋花汤加鳕鱼, 开始计时熬制(60秒/级); 等计时结束变成 蛋花鳕鱼汤(熟), 手持木碗出锅"},
+     "tip": "§a蛋花汤加鳕鱼, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 蛋花鳕鱼汤(熟), 手持木碗出锅"},
    {"block": EGG_SOUP, "item": CRUSHED_MEAT, "target": NORI_EGG_SOUP,
     "consume": 5, "startTimer": NORI_EGG_SOUP,
-     "tip": "§a蛋花汤加碎肉x5, 开始计时熬制(30秒/级); 等计时结束变成 瘦肉蛋花汤(熟), 手持木碗出锅"},
+     "tip": "§a蛋花汤加碎肉x5, 开始熬制(共120秒, 4级×30秒); 等计时结束变成 瘦肉蛋花汤(熟), 手持木碗出锅"},
    {"block": VEGETABLE_LEAN_BROTH, "item": EGG, "target": NORI_EGG_SOUP,
     "consume": 3, "startTimer": NORI_EGG_SOUP,
-     "tip": "§a蔬菜瘦肉汤加鸡蛋x3, 开始计时熬制(30秒/级); 等计时结束变成 瘦肉蛋花汤(熟), 手持木碗出锅"},
+     "tip": "§a蔬菜瘦肉汤加鸡蛋x3, 开始熬制(共120秒, 4级×30秒); 等计时结束变成 瘦肉蛋花汤(熟), 手持木碗出锅"},
    {"block": TOFU_SOUP, "item": SALMON, "target": TOFU_FISH_SOUP_RAW,
     "consume": 1, "startTimer": TOFU_FISH_SOUP_RAW,
-     "tip": "§a豆腐汤加鲑鱼, 开始计时熬制(60秒/级); 等计时结束变成 豆腐鲑鱼汤(熟), 手持木碗出锅"},
+     "tip": "§a豆腐汤加鲑鱼, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 豆腐鲑鱼汤(熟), 手持木碗出锅"},
    {"block": SALMON_SOUP, "item": BEANCURD, "target": TOFU_FISH_SOUP_RAW,
     "consume": 4, "startTimer": TOFU_FISH_SOUP_RAW,
-     "tip": "§a鲑鱼汤加豆腐x4, 开始计时熬制(60秒/级); 等计时结束变成 豆腐鲑鱼汤(熟), 手持木碗出锅"},
+     "tip": "§a鲑鱼汤加豆腐x4, 开始熬制(共180秒, 3级×60秒); 等计时结束变成 豆腐鲑鱼汤(熟), 手持木碗出锅"},
    {"block": MUSHROOM_SOUP, "item": CHICKEN, "target": CHICKEN_STEW_MUSHROOMS,
     "consume": 1, "startTimer": CHICKEN_STEW_MUSHROOMS,
-     "tip": "§a蘑菇汤加生鸡肉, 开始计时熬制(90秒/级); 等计时结束变成 蘑菇炖鸡(熟), 手持木碗出锅"},
+     "tip": "§a蘑菇汤加生鸡肉, 开始熬制(共270秒, 3级×90秒); 等计时结束变成 蘑菇炖鸡(熟), 手持木碗出锅"},
    {"block": VEGETABLE_SOUP, "item": SASHIMI, "target": VEGETABLE_FISH_SOUP_0,
     "consume": 10, "startTimer": VEGETABLE_FISH_SOUP_0,
     "tip": "§a蔬菜汤加生鱼片x10, 开始计时熬制(60秒/级); 等计时结束变成 蔬菜鱼片汤(熟), 手持木碗出锅"},
@@ -345,31 +345,31 @@ SWITCH_RULES = [
     "consume": 2, "tip": "§a放入猪蹄x2, 变成 猪蹄汤(生); 继续拿土豆块x3右键 加土豆"},
    {"block": RAW_PIG_FOOD_SOUP_0, "item": POTATO_WEDGES, "target": RAW_PIG_FOOD_SOUP_2,
     "consume": 3, "startTimer": RAW_PIG_FOOD_SOUP_2,
-     "tip": "§a猪蹄汤加土豆块x3, 开始计时熬制(30秒/级); 等计时结束变成 猪蹄汤(全熟), 手持木碗出锅"},
+     "tip": "§a猪蹄汤加土豆块x3, 开始熬制(共90秒, 3级×30秒); 等计时结束变成 猪蹄汤(全熟), 手持木碗出锅"},
    # 菜谱30 羊肉泡馍汤
    {"block": POT_WATER, "item": MO, "target": ROUJIAMO_SOUP_0,
     "consume": 1, "startTimer": ROUJIAMO_SOUP_0,
-     "tip": "§a放入馍, 开始计时熬制(30秒); 等计时结束变成 羊肉泡馍汤(熟), 手持木碗出锅"},
+     "tip": "§a放入馍, 开始熬制(共30秒); 等计时结束变成 羊肉泡馍汤(熟), 手持木碗出锅"},
    # 菜谱31 生面汤
    {"block": POT_WATER, "item": NOODLES, "target": RAW_NOODLE_SOUP,
     "consume": 1, "startTimer": RAW_NOODLE_SOUP,
-     "tip": "§a放入生面, 开始计时熬制(60秒); 等计时结束变成 熟面汤, 手持木碗盛出 熟面条"},
+     "tip": "§a放入生面, 开始熬制(共60秒); 等计时结束变成 熟面汤, 手持木碗盛出 熟面条"},
    # 菜谱32 饺子汤
    {"block": POT_WATER, "item": DUMPLINGS, "target": DUMPLINGS_SOUP_0,
     "consume": 1, "startTimer": DUMPLINGS_SOUP_0,
-     "tip": "§a放入生饺子, 开始计时熬制(60秒/级); 等计时结束变成 饺子汤(熟), 手持木碗盛出 饺子_碗装"},
+     "tip": "§a放入生饺子, 开始熬制(共120秒, 2级×60秒); 等计时结束变成 饺子汤(熟), 手持木碗盛出 饺子_碗装"},
    # 菜谱35 生米锅
    {"block": POT_WATER, "item": BROWN_RICE, "target": RAW_RICE_POT,
     "consume": 64, "startTimer": RAW_RICE_POT,
-     "tip": "§a放入大米x64, 变成 生米锅; 开始计时熬制(90秒)结束变成 熟米饭(形态随机)"},
+     "tip": "§a放入大米x64, 变成 生米锅; 开始煮饭(共90秒)结束变成 熟米饭(形态随机)"},
    # 菜谱39 煮鸡蛋(生)
    {"block": POT_WATER, "item": EGG_PILE, "target": RAW_EGG_SOUP,
     "consume": 1, "startTimer": RAW_EGG_SOUP,
-     "tip": "§a放入鸡蛋堆, 开始计时熬制(60秒); 等计时结束变成 煮鸡蛋(熟), 空手右键取出 水煮蛋x9"},
+     "tip": "§a放入鸡蛋堆, 开始熬制(共60秒); 等计时结束变成 煮鸡蛋(熟), 空手右键取出 水煮蛋x9"},
    # 菜谱42 煮豆腐(生)
    {"block": POT_WATER, "item": SOYMILK, "target": BEANCURD_SOUP_0,
     "consume": 1, "startTimer": BEANCURD_SOUP_0,
-     "tip": "§a倒入豆浆, 开始计时熬制(60秒); 等计时结束变成 煮豆腐(熟), 拿菜刀右键切成 豆腐x16"},
+     "tip": "§a倒入豆浆, 开始熬制(共60秒); 等计时结束变成 煮豆腐(熟), 拿菜刀右键切成 豆腐x16"},

    # ---------------- 六、出锅(熟汤羹+木碗 -> 碗装成品, 锅变回汤锅(空)) ----------------
    {"block": CARROT_BEEF_SOUP_3, "item": BOWL, "action": "take_out",
@@ -64,18 +64,55 @@ class TangguoService(BlueFoxServerSystem):
            self.itemUseOnRecipes[(r["item"], r["surface"])] = r

        # ---- 空手右键"计时源方块"(生汤羹/生米锅等): 放在点燃炉灶上 -> 开始计时 ----
+        # 提示包含"总共多少秒": 从当前级沿计时链累加, 直到终点(总秒数/级数/成品名)
+        self._timerBySrc = {r["source"]: r for r in TIMER_RULES}
+        self._timerTotal = {}       # source -> (总秒数, 每级秒数列表)
+        for src, r in self._timerBySrc.items():
+            total, stages, cur, seen = 0, [], src, set()
+            while cur in self._timerBySrc and cur not in seen:
+                seen.add(cur)
+                curR = self._timerBySrc[cur]
+                sec = curR.get("time", 60)
+                total += sec
+                stages.append(sec)
+                if curR.get("randomTargets"):
+                    break
+                nxt = curR.get("target")
+                if nxt not in self._timerBySrc:
+                    break
+                cur = nxt
+            self._timerTotal[src] = (total, stages)
+
+        # 终点方块 -> 成品名(从 take_out 规则 tip 的"盛出 XX"提取, 用于计时提示)
+        self._finalNames = {}
+        for r in SWITCH_RULES:
+            if r.get("action") == "take_out":
+                tip = (r.get("tip") or "").replace("§a", "").replace("§e", "").replace("§c", "")
+                if "盛出" in tip:
+                    nm = tip.split("盛出", 1)[1].split(",", 1)[0].strip()
+                    if nm:
+                        self._finalNames[r["block"]] = nm
+
        self.timerSources = set()
        self.startTimerTips = {}
-        for r in TIMER_RULES:
-            src = r["source"]
+        for src, r in self._timerBySrc.items():
            self.timerSources.add(src)
            self.featureBlocks.add(src)   # 登记右键路由, 空手右键才分发到这里
-            if src not in self.startTimerTips:
-                sec = r.get("time", 60)
-                if r.get("randomTargets"):
-                    self.startTimerTips[src] = "§a开始煮饭…等计时(%d秒)结束变成 熟米饭(形态随机)" % sec
-                else:
-                    self.startTimerTips[src] = "§a开始熬制…等计时(%d秒)结束变成 下一形态" % sec
+            total, stages = self._timerTotal[src]
+            if len(stages) == 1:
+                stage = ""
+            elif len(set(stages)) == 1:
+                stage = "(%d级×%d秒)" % (len(stages), stages[0])
+            else:
+                stage = "(%d级: %s)" % (len(stages), "→".join("%d秒" % s for s in stages))
+            if r.get("randomTargets"):
+                tip = "§a开始煮饭…共需计时%d秒%s; 计时结束变成 熟米饭(形态随机)" % (total, stage)
+            else:
+                tip = "§a开始熬制…共需计时%d秒%s" % (total, stage)
+                end = self._timerTerminalName(src)
+                if end:
+                    tip += "; 计时结束变成 %s" % end
+            self.startTimerTips[src] = tip

        # ---- 右键冷却表 ----
        self.cooldown = {}
@@ -140,6 +177,17 @@ class TangguoService(BlueFoxServerSystem):
            comp.CreateMsg(playerId).NotifyOneMessage(
                playerId, "§c汤锅需要放在点燃的炉灶上才能开始计时")

+    def _timerTerminalName(self, src):
+        """沿计时链走到终点方块, 返回成品名(未取到则返回空串)"""
+        cur, seen = src, set()
+        while cur in self._timerBySrc and cur not in seen:
+            seen.add(cur)
+            r = self._timerBySrc[cur]
+            if r.get("randomTargets"):
+                return ""
+            cur = r["target"]
+        return self._finalNames.get(cur, "")
+
    def handleItemUseOn(self, args):
        """由 FeatureDispatcher 转发的"手持物品右键方块表面"入口(锅态汤面)。
        手持 蘑菇汤/蔬菜汤/蛋花汤 右键 熟面条表面 -> 汤面, 转换与取消放置同一事件完成"""
@@ -197,7 +245,7 @@ class TangguoService(BlueFoxServerSystem):
                recipe["startTimer"], dim, pos, playerId)
            if not started:
                comp.CreateMsg(playerId).NotifyOneMessage(
-                    playerId, "§e熬制需要下方是 点燃的炉灶; 放上炉灶后会自动开始计时")
+                    playerId, "§c熬制需要下方是 点燃的炉灶; 放好炉灶后空手右键即可开始计时")

        # 给背包物品(加水给空桶)
        if recipe.get("give"):
@@ -84,27 +84,27 @@ SWITCH_RULES = [
    {"block": OILPOT_1, "item": BREADED_CHICKEN, "target": CHICKEN_0,
     "consume": 1, "startTimer": CHICKEN_0,
     "needBelow": LIT_STOVE, "belowTip": "§c油锅需要放在点燃的炉灶上",
-     "tip": "§a放入裹粉鸡块, 等计时(60秒)结束变成 炸鸡块(半熟), 再等(30秒)结束变成 炸鸡块(熟)"},
+     "tip": "§a放入裹粉鸡块, 开始炸制(共90秒: 先60秒半熟, 再30秒熟); 计时结束变成 炸鸡块(熟)"},
    {"block": OILPOT_1, "item": BREADED_PORK, "target": PORK_0,
     "consume": 1, "startTimer": PORK_0,
     "needBelow": LIT_STOVE, "belowTip": "§c油锅需要放在点燃的炉灶上",
-     "tip": "§a放入裹粉猪肉, 等计时(60秒)结束变成 炸猪排(半熟), 再等(30秒)结束变成 炸猪排(熟)"},
+     "tip": "§a放入裹粉猪肉, 开始炸制(共90秒: 先60秒半熟, 再30秒熟); 计时结束变成 炸猪排(熟)"},
    {"block": OILPOT_1, "item": BREADED_FRIES, "target": FRIES_0,
     "consume": 3, "startTimer": FRIES_0,
     "needBelow": LIT_STOVE, "belowTip": "§c油锅需要放在点燃的炉灶上",
-     "tip": "§a放入裹粉薯条x3, 等计时(60秒)结束变成 炸薯条(半熟), 再等(30秒)结束变成 炸薯条(熟)"},
+     "tip": "§a放入裹粉薯条x3, 开始炸制(共90秒: 先60秒半熟, 再30秒熟); 计时结束变成 炸薯条(熟)"},
    {"block": OILPOT_1, "item": BREADED_FISH, "target": FISH_0,
     "consume": 1, "startTimer": FISH_0,
     "needBelow": LIT_STOVE, "belowTip": "§c油锅需要放在点燃的炉灶上",
-     "tip": "§a放入裹粉鱼, 等计时(60秒)结束变成 炸鱼块(半熟), 再等(30秒)结束变成 炸鱼块(熟)"},
+     "tip": "§a放入裹粉鱼, 开始炸制(共90秒: 先60秒半熟, 再30秒熟); 计时结束变成 炸鱼块(熟)"},
    {"block": OILPOT_1, "item": BREADED_TEMPURA, "target": TEMPURA_1,
     "consume": 4, "startTimer": TEMPURA_1,
     "needBelow": LIT_STOVE, "belowTip": "§c油锅需要放在点燃的炉灶上",
-     "tip": "§a放入裹粉天妇罗x4, 等计时(60秒)结束变成 炸天妇罗(熟)"},
+     "tip": "§a放入裹粉天妇罗x4, 开始炸制(共60秒); 计时结束变成 炸天妇罗(熟)"},
    {"block": OILPOT_1, "item": DUMPLINGS, "target": DUMPLING_1,
     "consume": 3, "startTimer": DUMPLING_1,
     "needBelow": LIT_STOVE, "belowTip": "§c油锅需要放在点燃的炉灶上",
-     "tip": "§a放入生饺子x3, 等计时(60秒)结束变成 炸饺子(熟)"},
+     "tip": "§a放入生饺子x3, 开始炸制(共60秒); 计时结束变成 炸饺子(熟)"},

    # ---- 三、出锅(熟炸物 + 盘子 -> 掉落盘装成品) ----
    {"block": CHICKEN_2, "item": PLATE, "action": "take_out",
@@ -58,15 +58,48 @@ class YouguoService(BlueFoxServerSystem):
            self.featureBlocks.add(r["block"])

        # ---- 空手右键"炸物计时源方块"(炸物生/半熟): 放在点燃炉灶上 -> 开始计时 ----
+        # 提示包含"总共多少秒": 从当前级沿计时链累加(生60秒+熟30秒 / 单级60秒)
+        self._timerBySrc = {r["source"]: r for r in TIMER_RULES}
+        self._timerTotal = {}       # source -> (总秒数, 每级秒数列表)
+        for src, r in self._timerBySrc.items():
+            total, stages, cur, seen = 0, [], src, set()
+            while cur in self._timerBySrc and cur not in seen:
+                seen.add(cur)
+                curR = self._timerBySrc[cur]
+                sec = curR.get("time", 60)
+                total += sec
+                stages.append(sec)
+                nxt = curR.get("target")
+                if nxt not in self._timerBySrc:
+                    break
+                cur = nxt
+            self._timerTotal[src] = (total, stages)
+
+        # 终点方块 -> 成品名(从出锅规则 tip 的"取出 XX"提取, 用于计时提示)
+        self._finalNames = {}
+        for r in SWITCH_RULES:
+            if r.get("action") == "take_out":
+                tip = (r.get("tip") or "").replace("§a", "").replace("§e", "").replace("§c", "")
+                if "取出" in tip:
+                    nm = tip.split("取出", 1)[1].split(",", 1)[0].strip()
+                    if nm:
+                        self._finalNames[r["block"]] = nm
+
        self.timerSources = set()
        self.startTimerTips = {}
-        for r in TIMER_RULES:
-            src = r["source"]
+        for src, r in self._timerBySrc.items():
            self.timerSources.add(src)
            self.featureBlocks.add(src)
-            if src not in self.startTimerTips:
-                sec = r.get("time", 60)
-                self.startTimerTips[src] = "§a开始炸制…等计时(%d秒)结束变成 下一形态" % sec
+            total, stages = self._timerTotal[src]
+            if len(stages) == 1:
+                stage = ""
+            else:
+                stage = "(%d级: %s)" % (len(stages), "→".join("%d秒" % s for s in stages))
+            tip = "§a开始炸制…共需计时%d秒%s" % (total, stage)
+            end = self._oilTerminalName(src)
+            if end:
+                tip += "; 计时结束变成 %s" % end
+            self.startTimerTips[src] = tip

        # ---- 右键冷却表 ----
        self.cooldown = {}
@@ -130,6 +163,14 @@ class YouguoService(BlueFoxServerSystem):
            comp.CreateMsg(playerId).NotifyOneMessage(
                playerId, "§c油锅需要放在点燃的炉灶上才能开始计时")

+    def _oilTerminalName(self, src):
+        """沿计时链走到终点方块, 返回成品名(未取到则返回空串)"""
+        cur, seen = src, set()
+        while cur in self._timerBySrc and cur not in seen:
+            seen.add(cur)
+            cur = self._timerBySrc[cur]["target"]
+        return self._finalNames.get(cur, "")
+
    # ============================================================================
    # 二、通用转换执行
    # ============================================================================
@@ -95,6 +95,10 @@
  提示"已经在计时中"; 实现于 汤锅/油锅/丸子机(ChujuService)/面食蒸笼(MianshiService)
  的 handleBlockUse + 各自 _handleStartTimer, 经 FeatureDispatcher.startTimerFor 转发,
  计时服务 startTimer 内做下方判定(丸子机 ChujuTimerService 已补下方检查) [已实现]
+- 计时提示含"总共多少秒"(2026-09-16): 放料/入笼开始计时 与 空手右键开始计时 的提示,
+  均按计时链累加算出总时长(如 胡萝卜牛肉汤 共90秒/3级×30秒、油锅炸物 共90秒
+  (60秒半熟+30秒熟)、蘑菇炖鸡 共270秒/3级×90秒、生米锅 共90秒/单级);
+  汤锅/油锅 右键提示还会带出成品名(从"盛出/取出"规则提取) [已实现]
 - 原版放置(手持原版生鸡肉/鲑鱼/鳕鱼右键方块表面放置对应方块)已拆到独立目录
  xiangyemod/yuanbanfangzhi (YuanbanData/YuanbanService), 从烧烤/死亡生物中剔除 [已重构]
 - 原版食物成品盘转换(乡野食物·原版食物): 手持原版食物右键 空盘子(rtdd:plate_0) →
@@ -541,7 +541,7 @@ todo 成品 右键吃 (吃的操作后续由总食用功能实现)
 - 瘦肉蛋花汤 (brown_norieggsoup)
 - 豆腐鲑鱼汤 (bowlatufufish)
 - 蘑菇炖鸡 (bowlofmushroomsoup)
- 猪蹄汤 (brownpigfootsoup)
+- 猪蹄汤 (brownpigfootso0-=up)
 - 羊肉泡馍汤 (bowla_roujiamo)
 - 蔬菜鱼片汤 (brownvegetablefishsoup)
 - 饺子_碗装 (dumplingssoup)
@@ -37,7 +37,7 @@
 ========================================
 菜谱 1 — 辣椒锅底
 ========================================
-步骤1：添油锅(rtdd:oilpan) + 拿辣椒(rtdd:pepper)右键, 消耗1个
+步骤1：添油锅(rtdd:oilpan) + 拿辣椒(rtdd:pepper)右键, 消耗2个
       → 变身 辣椒锅底(rtdd:cooking_pepper)

 ========================================