炒锅功能实现 3

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/modMain.py

@@ -24,6 +24,8 @@ from xiangyemod.youguo.service.YouguoService import YouguoService
 from xiangyemod.youguo.service.YouguoTimerService import YouguoTimerService
 from xiangyemod.tangguo.service.TangguoService import TangguoService
 from xiangyemod.tangguo.service.TangguoTimerService import TangguoTimerService
+from xiangyemod.chaoguo.service.ChaoguoService import ChaoguoService
+from xiangyemod.chaoguo.service.ChaoguoTimerService import ChaoguoTimerService
 
 if not serverApi.IsInServer():
     pass

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/xiangyemod/chaoguo/ChaoguoData.py

@@ -0,0 +1,679 @@
+# -*- coding: utf-8 -*-
+"""
+================================================================================
+炒锅(xy_chaoguo)转化规则数据
+================================================================================
+统一管理"炒锅"分类下的转化规则常量。只被
+ChaoguoService / ChaoguoTimerService 读取, FeatureDispatcher 通过
+方块名路由到对应服务。
+
+【实现范围(对应 炒锅转化关系.txt)】
+  一、炒锅基础  : 炒锅(空)<->(盖锅)、辣椒锅底、葱花锅底
+  二、放料      : 炒锅(添油)+食材(右键) -> 各菜生态
+  三、翻炒      : 生态 + 锅铲(右键)x3 -> 熟/下一态(需下方点燃炉灶)
+  四、计时      : 煎蛋30秒门控 / 煎葱油饼_生60秒 / 煎馍_生60秒 / 煎面饼_生60秒
+  五、出锅      : 熟态 + 盘子(右键) -> 掉落盘装成品, 锅变回炒锅(空)
+  六、空手出锅  : 煎葱油饼_熟/煎馍_熟/煎面饼_熟/煎酱香饼 空手右键 -> 掉落成品
+  七、盖饭      : 手持成品菜 右键 米饭(三形态任一) <-> 反向, 见 ITEM_USE_ON_RULES
+
+【计时(见 ChaoguoTimerService)】
+  所有计时判定【正下方】是 点燃的炉灶(stove_2), 计时数据在方块本身;
+  炉灶移走/熄灭则暂停, 回来继续。煎蛋为"门控"计时(方块不变, 标记 rtdd_cg=1)。
+
+【不实现】: 各盘装成品/盖饭 右键吃 (吃的操作后续由总食用功能实现)
+================================================================================
+"""
+
+# ============================================================================
+# 一、基础方块/工具
+# ============================================================================
+WOK = "rtdd:wok"                     # 炒锅(空)
+COVER_THE_PAN = "rtdd:coverthepan"   # 炒锅(盖锅)
+OIL_PAN = "rtdd:oilpan"              # 炒锅(添油)
+LIT_STOVE = "rtdd:stove_2"           # 点燃的炉灶(厨具)
+SPATULA = "rtdd:spatula"             # 锅铲(厨具)
+PLATE = "rtdd:plate_0"               # 盘子(厨具)
+
+# ============================================================================
+# 二、锅底/调料中间态
+# ============================================================================
+CARROT_POT_BASE = "rtdd:carrotpotbase"        # 炒锅_15(辣椒锅底)
+VEGETABLE_POT_BASE = "rtdd:vegetablespotbase" # 炒锅_94(葱花锅底)
+COOKING_GARLIC = "rtdd:cookinggarlic"         # 炒锅_43(加大蒜)
+COOKING_SCALLIONS = "rtdd:cookingscallions"   # 炒锅_51(加葱)
+COOKED_EGG = "rtdd:cookedegg"                 # 炒锅_17(煎蛋)
+
+# ============================================================================
+# 三、炒胡萝卜三级(基底)
+# ============================================================================
+COOKING_CARROT = "rtdd:cookingcarrot"   # 炒锅_25(炒胡萝卜_生)
+WOKCARROT_1 = "rtdd:wokcarrot_1"        # 炒锅_95(炒胡萝卜_半熟)
+COOKING_PEPPER = "rtdd:cooking_pepper"  # 炒锅_19(炒胡萝卜_熟, 胡萝卜系基底)
+
+# ============================================================================
+# 四、食材(乡野食材/原版)
+# ============================================================================
+CRUSHED_CARROTS = "rtdd:crushed_carrots"    # 胡萝卜碎
+CRUSHED_SCALLIONS = "rtdd:crushed_scallions"  # 葱花碎
+CRUSHED_GARLIC = "rtdd:crushedgarlic"       # 蒜末
+POTATO_WEDGES = "rtdd:potato_wedges"        # 土豆块
+CRUSHED_MEAT = "rtdd:crushedmeat"           # 碎肉
+RAW_SQUID_WHISKERS = "rtdd:rawsquidwhiskersr"  # 鱿鱼须
+DEAD_SQUID = "rtdd:dead_squid_1"            # 死鱿鱼(切掉鱿鱼须)
+CRAB = "rtdd:crab"                          # 螃蟹
+LEGCOW = "rtdd:legcow"                      # 牛腿肉
+PORKLOINS = "rtdd:porkloins"                # 五花肉
+PORKRIB = "rtdd:porkrib"                    # 猪肋排
+SHEEPLOINS = "rtdd:sheeploins"              # 羊里脊
+SHEEPRACKS = "rtdd:sheepracks"              # 羊小排
+BEEF_TENDERLOIN = "rtdd:beef_tenderloin"    # 牛里脊
+COSTILLAVACAES = "rtdd:costillavacaes"      # 牛肋
+LEGSLEEP = "rtdd:legsleep"                  # 羊腿
+PEPPER = "rtdd:pepper"                      # 辣椒
+VEGETABLE = "rtdd:vegetable"                # 青菜碎
+NOODLES = "rtdd:noodles"                    # 生面
+DOUGH_0 = "rtdd:dough_0"                    # 生面团(发酵后)
+DOUGHT_7 = "rtdd:dought_7"                  # 生面饼
+BEANCURD = "rtdd:beancurd"                  # 豆腐
+BROWN_MUSHROOM = "minecraft:brown_mushroom" # 棕蘑菇(原版, 香菇)
+RED_MUSHROOM = "minecraft:red_mushroom"     # 红蘑菇(原版)
+PORKCHOP = "minecraft:porkchop"             # 生猪肉(原版)
+CHICKEN = "minecraft:chicken"               # 生鸡肉(原版)
+BEEF = "minecraft:beef"                     # 生牛肉(原版)
+MUTTON = "minecraft:mutton"                 # 生羊肉(原版)
+RABBIT = "minecraft:rabbit"                 # 兔肉(原版)
+COD = "minecraft:cod"                       # 鳕鱼(原版)
+SALMON = "minecraft:salmon"                 # 鲑鱼(原版)
+CARROT = "minecraft:carrot"                 # 胡萝卜(原版)
+EGG = "minecraft:egg"                       # 鸡蛋(原版)
+COOKED_BEEF = "minecraft:cooked_beef"       # 熟牛肉(原版)
+
+# ============================================================================
+# 五、菜系方块(生态/中间态/熟态)
+# ============================================================================
+FRIED_PORK = "rtdd:fried_pork"                       # 炒锅_62(炒猪肉_生)
+COOKING_POTATO = "rtdd:cookingpotato"                # 炒锅_47(炒土豆_生)
+COOKING_POTATO_1 = "rtdd:cookingpotato_1"            # 炒锅_48(炒土豆_熟)
+COOKING_MEAT = "rtdd:cookingmeat"                    # 炒锅_44(炒碎肉_生)
+COOKING_MEAT_1 = "rtdd:cookingmeat_1"                # 炒锅_45(炒碎肉_熟)
+SQUID_WHISKERS_0 = "rtdd:squidwhiskersincooking_0"   # 炒锅_92(炒鱿鱼须_生)
+SQUID_WHISKERS_1 = "rtdd:squidwhiskersincooking_1"   # 炒锅_93(炒鱿鱼须_熟)
+COOKING_CRAB_1 = "rtdd:cookingcrab_1"                # 炒锅_34(炒蟹_生)
+COOKING_CRAB_2 = "rtdd:cookingcrab_2"                # 炒锅_35(炒蟹_熟)
+COOKING_FISH = "rtdd:cookingfish"                    # 炒锅_41(煎鲑鱼_生)
+COOKING_FISH_1 = "rtdd:cookingfish_1"                # 炒锅_42(煎鲑鱼_熟)
+COOKING_SQUID = "rtdd:cookingsquid"                  # 炒锅_56(炒鱿鱼_生)
+COOKING_SQUID_1 = "rtdd:cookingsquid_1"              # 炒锅_57(炒鱿鱼_半熟)
+COOKING_SQUID_2 = "rtdd:cookingsquid_2"              # 炒锅_58(炒鱿鱼_熟)
+CARROT_AND_BEEF = "rtdd:carrotandbeef"               # 炒锅_1(黑椒牛排_生)
+CARROT_AND_BEEF_1 = "rtdd:carrotandbeef_1"           # 炒锅_2(黑椒牛排_熟)
+CARROT_AND_BEEFRIBS = "rtdd:carrotandbeefribs"       # 炒锅_3(胡萝卜牛排骨_生)
+CARROT_AND_BEEFRIBS_1 = "rtdd:carrotandbeefribs_1"   # 炒锅_4(胡萝卜牛排骨_熟)
+CARROT_AND_LEGCOW = "rtdd:carrotandlegcow"           # 炒锅_5(黑椒牛腿_生)
+CARROT_AND_LEGCOW_1 = "rtdd:carrotandlegcow_1"       # 炒锅_6(黑椒牛腿_熟)
+CARROT_AND_MUTTON = "rtdd:carrotandmutton"           # 炒锅_7(清炒羊肉_生)
+CARROT_AND_MUTTON_1 = "rtdd:carrotandmutton_1"       # 炒锅_8(清炒羊肉_熟)
+CARROT_AND_PORKCHOP = "rtdd:carrotandporkchop"       # 炒锅_9(清炒猪排_生)
+CARROT_AND_PORKCHOP_1 = "rtdd:carrotandporkchop_1"   # 炒锅_10(清炒猪排_熟)
+CARROT_AND_SALMON = "rtdd:carrotandsalmon"           # 炒锅_11(胡萝卜鲑鱼_生)
+CARROT_AND_SALMON_1 = "rtdd:carrotandsalmon_1"       # 炒锅_12(胡萝卜鲑鱼_熟)
+CARROT_LEG_OF_LAMB = "rtdd:carrotlegoflamb"          # 炒锅_13(胡萝卜羊腿_生)
+CARROT_LEG_OF_LAMB_1 = "rtdd:carrotlegoflamb_1"      # 炒锅_14(胡萝卜羊腿_熟)
+COOKING_COD = "rtdd:cookingcod"                      # 炒锅_28(胡萝卜炒鳕鱼_生)
+COOKING_COD_1 = "rtdd:cookingcod_1"                  # 炒锅_29(胡萝卜炒鳕鱼_熟)
+COOKING_BEEF_TENDERLOIN = "rtdd:cookingbeeftenderloin"    # 炒锅_23(胡萝卜牛里脊_生)
+COOKING_BEEF_TENDERLOIN_1 = "rtdd:cookingbeeftenderloin1" # 炒锅_24(胡萝卜牛里脊_熟)
+COOKING_COOKED_PORKLOIN = "rtdd:cookingcookedporkloin"    # 炒锅_30(小炒五花肉_生)
+COOKING_COOKED_PORKLOIN_1 = "rtdd:cookingcookedporkloin_1" # 炒锅_31(小炒五花肉_熟)
+COOKING_COOKED_PORKRIBS = "rtdd:cookingcookedporkribs"    # 炒锅_32(胡萝卜炒猪排骨_生)
+COOKING_COOKED_PORKRIBS_1 = "rtdd:cookingcookedporkribs_1" # 炒锅_33(胡萝卜炒猪排骨_熟)
+COOKING_SHEEPLOIN = "rtdd:cookingsheeploin"          # 炒锅_52(胡萝卜炒羊里脊_生)
+COOKING_SHEEPLOIN_1 = "rtdd:cookingsheeploin_1"      # 炒锅_53(胡萝卜炒羊里脊_熟)
+COOKING_SHEEPRACK = "rtdd:cookingsheeprack"          # 炒锅_54(胡萝卜炒羊排_生)
+COOKING_SHEEPRACK_1 = "rtdd:cookingsheeprack_1"      # 炒锅_55(胡萝卜炒羊排_熟)
+COOKING_CHILI_CHICKEN = "rtdd:cookingchilipepperandchicken"    # 炒锅_26(辣子鸡丁_生)
+COOKING_CHILI_CHICKEN_2 = "rtdd:cookingchilipepperandchicken_2" # 炒锅_27(辣子鸡丁_熟)
+COOKING_RABBIT = "rtdd:cookingrabbit"                # 炒锅_49(辣炒兔肉_生)
+COOKING_RABBIT_1 = "rtdd:cookingrabbit_1"            # 炒锅_50(辣炒兔肉_熟)
+SPICY_FISH_0 = "rtdd:spicy_fish_0"                   # 炒锅_90(辣炒鲑鱼_生)
+SPICY_FISH_1 = "rtdd:spicy_fish_1"                   # 炒锅_91(辣炒鲑鱼_熟)
+OILPAN_CHILI_BEEF_1 = "rtdd:oilpanchilipepperbeef_1"      # 炒锅_71(辣椒炒牛肉_生)
+OILPAN_CHILI_BEEF_2 = "rtdd:oilpanchilipepperbeef_2"      # 炒锅_72(辣椒炒牛肉_熟)
+OILPAN_CHILI_BEEF_BEANCURD = "rtdd:oilpanchilipepperbeefbeancurd"    # 炒锅_73(麻婆豆腐_生)
+OILPAN_CHILI_BEEF_BEANCURD_2 = "rtdd:oilpanchilipepperbeefbeancurd_2" # 炒锅_74(麻婆豆腐_熟)
+MUSHROOM_FRIED_CHICKEN_1 = "rtdd:mushroom_fried_chicken_1"  # 炒锅_68(香菇滑鸡_生)
+MUSHROOM_FRIED_CHICKEN_2 = "rtdd:mushroomfriedchicken_2"    # 炒锅_69(香菇滑鸡_熟)
+FRIED_PORK_WITH_POTATOES = "rtdd:fried_porkwith_potatoes"    # 炒锅_64(土豆炒猪肉_生)
+FRIED_PORK_WITH_POTATOES_1 = "rtdd:fried_porkwith_potatoes_1" # 炒锅_65(土豆炒猪肉_熟)
+FRIED_PORK_WITH_CARROTS = "rtdd:fried_porkwith_carrots"      # 炒锅_63(胡萝卜炒猪肉_生)
+FRIED_PORK_WITH_CARROTS_1 = "rtdd:friedporkwithcarrots_1"    # 炒锅_67(胡萝卜炒猪肉_熟)
+COOKING_VEGETABLES = "rtdd:cookingvegetables"        # 炒锅_59(炒时蔬_加蔬菜_生)
+COOKING_VEGETABLES_1 = "rtdd:cookingvegetables_1"    # 炒锅_60(炒时蔬_加蔬菜_熟)
+SEASONAL_VEGETABLES = "rtdd:seasonalvegetables"      # 炒锅_88(炒时蔬_加胡萝卜_生)
+SEASONAL_VEGETABLES_1 = "rtdd:seasonalvegetables_1"  # 炒锅_89(炒时蔬_加胡萝卜_熟)
+COOKING_ANY_MEAT = "rtdd:cookinganymeat"             # 炒锅_22(小炒鸡肉_生)
+FRIED_CHICKEN = "rtdd:friedchicken"                  # 炒锅_66(小炒鸡肉_半熟)
+COOKED_ANY_MEAT = "rtdd:cookedanymeat"               # 炒锅_16(小炒鸡肉_熟)
+
+# ---- 面/饼/饭 ----
+PASTA_POT_0 = "rtdd:pastapot_0"   # 炒锅_75(意面_生)
+PASTA_POT_1 = "rtdd:pastapot_1"   # 炒锅_76(意面_熟, 意面系基底)
+PASTA_POT_2 = "rtdd:pastapot_2"   # 炒锅_77(牛肉意面_生)
+PASTA_POT_3 = "rtdd:pastapot_3"   # 炒锅_78(牛肉意面_熟)
+PASTA_POT_4 = "rtdd:pastapot_4"   # 炒锅_79(香菇意面_生)
+PASTA_POT_5 = "rtdd:pastapot_5"   # 炒锅_80(香菇意面_熟)
+PASTA_POT_6 = "rtdd:pastapot_6"   # 炒锅_81(胡萝卜意面_生)
+PASTA_POT_7 = "rtdd:pastapot_7"   # 炒锅_82(胡萝卜意面_熟)
+PASTA_POT_8 = "rtdd:pastapot_8"   # 炒锅_83(鸡肉番茄意面_生)
+PASTA_POT_9 = "rtdd:pastapot_9"   # 炒锅_84(鸡肉番茄意面_熟)
+RICE_EGG_1 = "rtdd:riceegg_1"      # 炒锅_85(蛋炒饭_加胡萝卜_生)
+RICE_EGG_2 = "rtdd:riceegg_2"      # 炒锅_86(蛋炒饭_加胡萝卜_熟)
+RICE_EGG_3 = "rtdd:riceegg_3"      # 炒锅_87(蛋炒饭_加米饭_熟)
+COOKING_DOUGHT_0 = "rtdd:cookingdought_0"   # 炒锅_39(煎面饼_生)
+COOKING_DOUGHT_1 = "rtdd:cookingdought_1"   # 炒锅_40(煎面饼_熟)
+COOKING_SCALLION_PANCAKE_0 = "rtdd:cooking_scallion_pancake_0"  # 炒锅_20(煎葱油饼_生)
+COOKING_SCALLION_PANCAKE_1 = "rtdd:cooking_scallion_pancake_1"  # 炒锅_21(煎葱油饼_熟)
+COOKING_DOUGH_0 = "rtdd:cookingdough_0"     # 炒锅_36(煎馍_生)
+COOKING_DOUGH_1 = "rtdd:cookingdough_1"     # 炒锅_37(煎馍_熟)
+COOKING_PANCAKE_2 = "rtdd:cookingpancake_2" # 炒锅_46(煎酱香饼)
+
+# ============================================================================
+# 六、成品(出锅掉落物)
+# ============================================================================
+PLATE_1 = "rtdd:plate_1"    # 清炒猪排
+PLATE_2 = "rtdd:plate_2"    # 黑椒牛排
+PLATE_3 = "rtdd:plate_3"    # 清炒羊肉
+PLATE_5 = "rtdd:plate_5"    # 胡萝卜鲑鱼
+PLATE_6 = "rtdd:plate_6"    # 胡萝卜牛排骨
+PLATE_7 = "rtdd:plate_7"    # 黑椒牛腿
+PLATE_8 = "rtdd:plate_8"    # 胡萝卜牛里脊
+PLATE_9 = "rtdd:plate_9"    # 胡萝卜羊腿
+PLATE_10 = "rtdd:plate_10"  # 胡萝卜炒羊里脊
+PLATE_11 = "rtdd:plate_11"  # 胡萝卜炒羊排
+PLATE_12 = "rtdd:plate_12"  # 小炒五花肉
+PLATE_13 = "rtdd:plate_13"  # 胡萝卜炒猪排骨
+PLATE_14 = "rtdd:plate_14"  # 炒土豆
+PLATE_15 = "rtdd:plate_15"  # 胡萝卜炒鳕鱼
+PLATE_19 = "rtdd:plate_19"  # 辣炒兔肉
+PLATE_22 = "rtdd:plate_22"  # 元气煎蛋
+PLATE_23 = "rtdd:plate_23"  # 炒时蔬
+PLATE_24 = "rtdd:plate_24"  # 炒碎肉
+PLATE_25 = "rtdd:plate_25"  # 煎鲑鱼
+PLATE_26 = "rtdd:plate_26"  # 炒鱿鱼(全份)
+PLATE_26D = "rtdd:plate_26d"  # 炒鱿鱼须(全份)
+PLATE_31 = "rtdd:plate_31"  # 小炒鸡肉
+PLATE_32 = "rtdd:plate_32"  # 麻婆豆腐(全份)
+PLATE_33 = "rtdd:plate_33"  # 炒蟹
+PLATE_41 = "rtdd:plate_41"  # 辣炒鲑鱼
+PLATE_43 = "rtdd:plate_43"  # 牛肉意面
+PLATE_44 = "rtdd:plate_44"  # 香菇意面
+PLATE_45 = "rtdd:plate_45"  # 胡萝卜意面
+PLATE_46 = "rtdd:plate_46"  # 鸡肉番茄意面
+PLATE_47 = "rtdd:plate_47"  # 辣子鸡丁
+PLATE_47A = "rtdd:plate_47a"  # 辣椒炒牛肉
+PLATE_52 = "rtdd:plate_52"  # 土豆炒猪肉
+PLATE_53 = "rtdd:plate_53"  # 胡萝卜炒猪肉
+PLATE_54 = "rtdd:plate_54"  # 香菇滑鸡
+BOWL_OF_RICE_EGG = "rtdd:bowlofriceegg"  # 蛋炒饭
+SCALLION_PANCAKE_0 = "rtdd:scallion_pancake_0"  # 葱油饼
+COOKED_PANCAKE = "rtdd:cookedpancake"           # 酱香饼
+ROUJIAMO_0 = "rtdd:roujiamo_0"                  # 馍
+COOKED_DOUGHT = "rtdd:cooked_dought"            # 煎饼
+
+# ---- 米饭三形态(均来自 汤锅 大米煮饭木碗盛出) ----
+BOWL_OF_RICE = "rtdd:bowlofrice"       # 米饭_1(熟米饭_形态1)
+BOWL_OF_RICE_2 = "rtdd:bowlofrice_2"   # 米饭_2(形态2)
+BOWL_OF_RICE_3 = "rtdd:bowlofrice_3"   # 米饭_3(形态3)
+RICE_FORMS = [BOWL_OF_RICE, BOWL_OF_RICE_2, BOWL_OF_RICE_3]
+
+# ---- 盖饭方块(归 food_11_rice_meal) ----
+PLATE_48 = "rtdd:plate_48"  # 辣子鸡丁盖饭(全份)
+PLATE_55 = "rtdd:plate_55"  # 香菇滑鸡盖饭(全份)
+PLATE_56 = "rtdd:plate_56"  # 麻婆豆腐盖饭
+PLATE_50 = "rtdd:plate_50"  # 鳕鱼盖饭
+
+# ============================================================================
+# 七、右键规则 (方块, 手持物品) -> 规则
+#    item=None 表示空手右键
+#    target=替换方块; consume=消耗手持; action=take_out(出锅: 锅变回炒锅(空)+掉落)
+#    action=stir(翻炒: 锅铲右键计数3次, 满3次变 target, 冷却1.5秒)
+#    needBelow=下方须是点燃炉灶(翻炒用); needFlag=(键, 阈值, 提示)(出锅门控)
+#    dropItem=出锅掉落物; startTimer=转换后启动计时(本分类计时由 autoStart 接管)
+# ============================================================================
+SWITCH_RULES = [
+    # ---------------- 一、炒锅基础 ----------------
+    # 炒锅(空) <-> 炒锅(盖锅) (双向, 空手)
+    {"block": WOK, "item": None, "target": COVER_THE_PAN,
+     "tip": "§a盖上锅盖, 炒锅变(盖锅); 空手右键可再掀开"},
+    {"block": COVER_THE_PAN, "item": None, "target": WOK,
+     "tip": "§a掀开锅盖, 炒锅变回(空)"},
+    # 菜谱1 辣椒锅底 (炒锅(空) + 辣椒x2)
+    {"block": WOK, "item": PEPPER, "target": CARROT_POT_BASE, "consume": 2,
+     "tip": "§a放入辣椒x2, 变成 炒锅_15(辣椒锅底); 可加肉做辣系菜"},
+    # 菜谱2 葱花锅底 (炒锅(空) + 葱花碎x3)
+    {"block": WOK, "item": CRUSHED_SCALLIONS, "target": VEGETABLE_POT_BASE, "consume": 3,
+     "tip": "§a放入葱花碎x3, 变成 炒锅_94(葱花锅底); 可加羊肉/猪肉清炒"},
+
+    # ---------------- 二、放料(炒锅(添油) + 食材 -> 生态) ----------------
+    # 菜谱3 炒猪肉
+    {"block": OIL_PAN, "item": PORKCHOP, "target": FRIED_PORK, "consume": 1,
+     "tip": "§a放入生猪肉, 变成 炒锅_62(炒猪肉_生); 可加土豆块/胡萝卜碎做炒猪肉"},
+    # 菜谱5 炒土豆
+    {"block": OIL_PAN, "item": POTATO_WEDGES, "target": COOKING_POTATO, "consume": 1,
+     "tip": "§a放入土豆块, 变成 炒锅_47(炒土豆_生); 拿锅铲翻炒3次"},
+    # 菜谱6 加葱
+    {"block": OIL_PAN, "item": CRUSHED_SCALLIONS, "target": COOKING_SCALLIONS, "consume": 3,
+     "tip": "§a放入葱花碎x3, 变成 炒锅_51(加葱)"},
+    # 菜谱7 加大蒜
+    {"block": OIL_PAN, "item": CRUSHED_GARLIC, "target": COOKING_GARLIC, "consume": 3,
+     "tip": "§a放入蒜末x3, 变成 炒锅_43(加大蒜); 可加螃蟹做炒蟹"},
+    # 菜谱8 炒胡萝卜 (基底, 两级翻炒)
+    {"block": OIL_PAN, "item": CARROT, "target": COOKING_CARROT, "consume": 2,
+     "tip": "§a放入胡萝卜x2, 变成 炒锅_25(炒胡萝卜_生); 拿锅铲翻炒3次"},
+    # 菜谱9 意面 (基底)
+    {"block": OIL_PAN, "item": NOODLES, "target": PASTA_POT_0, "consume": 2,
+     "tip": "§a放入生面x2, 变成 炒锅_75(意面_生); 拿锅铲翻炒3次"},
+    # 菜谱10 炒碎肉
+    {"block": OIL_PAN, "item": CRUSHED_MEAT, "target": COOKING_MEAT, "consume": 4,
+     "tip": "§a放入碎肉x4, 变成 炒锅_44(炒碎肉_生); 拿锅铲翻炒3次"},
+    # 菜谱11 炒鱿鱼须
+    {"block": OIL_PAN, "item": RAW_SQUID_WHISKERS, "target": SQUID_WHISKERS_0, "consume": 3,
+     "tip": "§a放入鱿鱼须x3, 变成 炒锅_92(炒鱿鱼须_生); 拿锅铲翻炒3次"},
+    # 菜谱13 煎鲑鱼
+    {"block": OIL_PAN, "item": SALMON, "target": COOKING_FISH, "consume": 1,
+     "tip": "§a放入鲑鱼, 变成 炒锅_41(煎鲑鱼_生); 拿锅铲翻炒3次"},
+    # 菜谱14 炒鱿鱼 (两级翻炒)
+    {"block": OIL_PAN, "item": DEAD_SQUID, "target": COOKING_SQUID, "consume": 1,
+     "tip": "§a放入死鱿鱼(切掉鱿鱼须), 变成 炒锅_56(炒鱿鱼_生); 拿锅铲翻炒3次"},
+    # 菜谱15 煎蛋
+    {"block": OIL_PAN, "item": EGG, "target": COOKED_EGG, "consume": 1,
+     "tip": "§a打入鸡蛋, 变成 炒锅_17(煎蛋); 放在点燃炉灶上30秒煎熟"},
+    # 菜谱16 黑椒牛排
+    {"block": OIL_PAN, "item": BEEF, "target": CARROT_AND_BEEF, "consume": 1,
+     "tip": "§a放入生牛肉, 变成 炒锅_1(黑椒牛排_生); 拿锅铲翻炒3次"},
+    # 菜谱18 黑椒牛腿
+    {"block": OIL_PAN, "item": LEGCOW, "target": CARROT_AND_LEGCOW, "consume": 1,
+     "tip": "§a放入牛腿肉, 变成 炒锅_5(黑椒牛腿_生); 拿锅铲翻炒3次"},
+    # 菜谱25 小炒五花肉
+    {"block": OIL_PAN, "item": PORKLOINS, "target": COOKING_COOKED_PORKLOIN, "consume": 1,
+     "tip": "§a放入五花肉, 变成 炒锅_30(小炒五花肉_生); 拿锅铲翻炒3次"},
+    # 菜谱38 炒时蔬(加蔬菜)
+    {"block": OIL_PAN, "item": VEGETABLE, "target": COOKING_VEGETABLES, "consume": 4,
+     "tip": "§a放入青菜碎x4, 变成 炒锅_59(炒时蔬_加蔬菜_生); 拿锅铲翻炒3次"},
+    # 菜谱41 煎馍
+    {"block": OIL_PAN, "item": DOUGH_0, "target": COOKING_DOUGH_0, "consume": 1,
+     "tip": "§a放入生面团(发酵后), 变成 炒锅_36(煎馍_生); 放在点燃炉灶上计时60秒"},
+    # 菜谱42 煎面饼
+    {"block": OIL_PAN, "item": DOUGHT_7, "target": COOKING_DOUGHT_0, "consume": 1,
+     "tip": "§a放入生面饼, 变成 炒锅_39(煎面饼_生); 放在点燃炉灶上计时60秒"},
+    # 菜谱44 小炒鸡肉
+    {"block": OIL_PAN, "item": CHICKEN, "target": COOKING_ANY_MEAT, "consume": 1,
+     "tip": "§a放入生鸡肉, 变成 炒锅_22(小炒鸡肉_生); 拿锅铲翻炒3次"},
+
+    # ---------------- 三、基底/中间态 + 主料 -> 菜生态 ----------------
+    # 菜谱12 炒蟹 (加大蒜 + 螃蟹)
+    {"block": COOKING_GARLIC, "item": CRAB, "target": COOKING_CRAB_1, "consume": 1,
+     "tip": "§a加大蒜炒螃蟹, 变成 炒锅_34(炒蟹_生); 拿锅铲翻炒3次"},
+    # 菜谱17 胡萝卜牛排骨 (炒胡萝卜_熟 + 牛肋x2)
+    {"block": COOKING_PEPPER, "item": COSTILLAVACAES, "target": CARROT_AND_BEEFRIBS, "consume": 2,
+     "tip": "§a炒胡萝卜加牛肋x2, 变成 炒锅_3(胡萝卜牛排骨_生); 拿锅铲翻炒3次"},
+    # 菜谱19 清炒羊肉 (葱花锅底 + 羊肉)
+    {"block": VEGETABLE_POT_BASE, "item": MUTTON, "target": CARROT_AND_MUTTON, "consume": 1,
+     "tip": "§a葱花锅底加羊肉, 变成 炒锅_7(清炒羊肉_生); 拿锅铲翻炒3次"},
+    # 菜谱20 清炒猪排 (葱花锅底 + 猪肉)
+    {"block": VEGETABLE_POT_BASE, "item": PORKCHOP, "target": CARROT_AND_PORKCHOP, "consume": 1,
+     "tip": "§a葱花锅底加猪肉, 变成 炒锅_9(清炒猪排_生); 拿锅铲翻炒3次"},
+    # 菜谱21 胡萝卜鲑鱼 (炒胡萝卜_熟 + 鲑鱼)
+    {"block": COOKING_PEPPER, "item": SALMON, "target": CARROT_AND_SALMON, "consume": 1,
+     "tip": "§a炒胡萝卜加鲑鱼, 变成 炒锅_11(胡萝卜鲑鱼_生); 拿锅铲翻炒3次"},
+    # 菜谱22 胡萝卜羊腿 (炒胡萝卜_熟 + 羊腿)
+    {"block": COOKING_PEPPER, "item": LEGSLEEP, "target": CARROT_LEG_OF_LAMB, "consume": 1,
+     "tip": "§a炒胡萝卜加羊腿, 变成 炒锅_13(胡萝卜羊腿_生); 拿锅铲翻炒3次"},
+    # 菜谱23 胡萝卜炒鳕鱼 (炒胡萝卜_熟 + 鳕鱼)
+    {"block": COOKING_PEPPER, "item": COD, "target": COOKING_COD, "consume": 1,
+     "tip": "§a炒胡萝卜加鳕鱼, 变成 炒锅_28(胡萝卜炒鳕鱼_生); 拿锅铲翻炒3次"},
+    # 菜谱24 胡萝卜牛里脊 (炒胡萝卜_熟 + 牛里脊)
+    {"block": COOKING_PEPPER, "item": BEEF_TENDERLOIN, "target": COOKING_BEEF_TENDERLOIN, "consume": 1,
+     "tip": "§a炒胡萝卜加牛里脊, 变成 炒锅_23(胡萝卜牛里脊_生); 拿锅铲翻炒3次"},
+    # 菜谱26 胡萝卜炒猪排骨 (炒胡萝卜_熟 + 猪肋排x2)
+    {"block": COOKING_PEPPER, "item": PORKRIB, "target": COOKING_COOKED_PORKRIBS, "consume": 2,
+     "tip": "§a炒胡萝卜加猪肋排x2, 变成 炒锅_32(胡萝卜炒猪排骨_生); 拿锅铲翻炒3次"},
+    # 菜谱27 胡萝卜炒羊里脊 (炒胡萝卜_熟 + 羊里脊x2)
+    {"block": COOKING_PEPPER, "item": SHEEPLOINS, "target": COOKING_SHEEPLOIN, "consume": 2,
+     "tip": "§a炒胡萝卜加羊里脊x2, 变成 炒锅_52(胡萝卜炒羊里脊_生); 拿锅铲翻炒3次"},
+    # 菜谱28 胡萝卜炒羊排 (炒胡萝卜_熟 + 羊小排x2)
+    {"block": COOKING_PEPPER, "item": SHEEPRACKS, "target": COOKING_SHEEPRACK, "consume": 2,
+     "tip": "§a炒胡萝卜加羊小排x2, 变成 炒锅_54(胡萝卜炒羊排_生); 拿锅铲翻炒3次"},
+    # 菜谱29 辣子鸡丁 (辣椒锅底 + 鸡肉)
+    {"block": CARROT_POT_BASE, "item": CHICKEN, "target": COOKING_CHILI_CHICKEN, "consume": 1,
+     "tip": "§a辣椒锅底加鸡肉, 变成 炒锅_26(辣子鸡丁_生); 拿锅铲翻炒3次"},
+    # 菜谱30 辣炒兔肉 (辣椒锅底 + 兔肉x2)
+    {"block": CARROT_POT_BASE, "item": RABBIT, "target": COOKING_RABBIT, "consume": 2,
+     "tip": "§a辣椒锅底加兔肉x2, 变成 炒锅_49(辣炒兔肉_生); 拿锅铲翻炒3次"},
+    # 菜谱31 辣炒鲑鱼 (辣椒锅底 + 鲑鱼)
+    {"block": CARROT_POT_BASE, "item": SALMON, "target": SPICY_FISH_0, "consume": 1,
+     "tip": "§a辣椒锅底加鲑鱼, 变成 炒锅_90(辣炒鲑鱼_生); 拿锅铲翻炒3次"},
+    # 菜谱32 辣椒炒牛肉 (辣椒锅底 + 牛肉)
+    {"block": CARROT_POT_BASE, "item": BEEF, "target": OILPAN_CHILI_BEEF_1, "consume": 1,
+     "tip": "§a辣椒锅底加牛肉, 变成 炒锅_71(辣椒炒牛肉_生); 拿锅铲翻炒3次 或 加豆腐做麻婆豆腐"},
+    # 菜谱33 麻婆豆腐 (辣椒炒牛肉_生 + 豆腐)
+    {"block": OILPAN_CHILI_BEEF_1, "item": BEANCURD, "target": OILPAN_CHILI_BEEF_BEANCURD, "consume": 1,
+     "tip": "§a辣椒炒牛肉加豆腐, 变成 炒锅_73(麻婆豆腐_生); 拿锅铲翻炒3次"},
+    # 菜谱34 香菇滑鸡 (小炒鸡肉_半熟 + 香菇x8)
+    {"block": FRIED_CHICKEN, "item": BROWN_MUSHROOM, "target": MUSHROOM_FRIED_CHICKEN_1, "consume": 8,
+     "tip": "§a小炒鸡肉加香菇x8, 变成 炒锅_68(香菇滑鸡_生); 拿锅铲翻炒3次"},
+    {"block": FRIED_CHICKEN, "item": RED_MUSHROOM, "target": MUSHROOM_FRIED_CHICKEN_1, "consume": 8,
+     "tip": "§a小炒鸡肉加香菇x8, 变成 炒锅_68(香菇滑鸡_生); 拿锅铲翻炒3次"},
+    # 菜谱35 土豆炒猪肉 (组合A: 炒猪肉_生 + 土豆块x3; 组合B: 炒土豆_熟 + 猪肉)
+    {"block": FRIED_PORK, "item": POTATO_WEDGES, "target": FRIED_PORK_WITH_POTATOES, "consume": 3,
+     "tip": "§a炒猪肉加土豆块x3, 变成 炒锅_64(土豆炒猪肉_生); 拿锅铲翻炒3次"},
+    {"block": COOKING_POTATO_1, "item": PORKCHOP, "target": FRIED_PORK_WITH_POTATOES, "consume": 1,
+     "tip": "§a炒土豆加生猪肉, 变成 炒锅_64(土豆炒猪肉_生); 拿锅铲翻炒3次"},
+    # 菜谱36 胡萝卜炒猪肉 (组合A: 炒猪肉_生 + 胡萝卜碎x3; 组合B: 炒胡萝卜_熟 + 猪肉)
+    {"block": FRIED_PORK, "item": CRUSHED_CARROTS, "target": FRIED_PORK_WITH_CARROTS, "consume": 3,
+     "tip": "§a炒猪肉加胡萝卜碎x3, 变成 炒锅_63(胡萝卜炒猪肉_生); 拿锅铲翻炒3次"},
+    {"block": COOKING_PEPPER, "item": PORKCHOP, "target": FRIED_PORK_WITH_CARROTS, "consume": 1,
+     "tip": "§a炒胡萝卜加生猪肉, 变成 炒锅_63(胡萝卜炒猪肉_生); 拿锅铲翻炒3次"},
+    # 菜谱38 炒时蔬(加胡萝卜) (炒时蔬_加蔬菜_熟 + 胡萝卜碎)
+    {"block": COOKING_VEGETABLES_1, "item": CRUSHED_CARROTS, "target": SEASONAL_VEGETABLES, "consume": 1,
+     "tip": "§a炒时蔬加胡萝卜碎, 变成 炒锅_88(炒时蔬_加胡萝卜_生); 拿锅铲翻炒3次"},
+    # 菜谱39 煎葱油饼 (煎面饼_生 + 葱花碎x3)
+    {"block": COOKING_DOUGHT_0, "item": CRUSHED_SCALLIONS, "target": COOKING_SCALLION_PANCAKE_0, "consume": 3,
+     "tip": "§a煎面饼加葱花碎x3, 变成 炒锅_20(煎葱油饼_生); 放在点燃炉灶上计时60秒"},
+    # 菜谱40 煎酱香饼 (煎面饼_熟 + 辣椒x3)
+    {"block": COOKING_DOUGHT_1, "item": PEPPER, "target": COOKING_PANCAKE_2, "consume": 3,
+     "tip": "§a煎面饼加辣椒x3, 变成 炒锅_46(煎酱香饼); 拿锅铲翻炒3次"},
+    # 菜谱45~48 意面系 (意面_熟 + 主料)
+    {"block": PASTA_POT_1, "item": COOKED_BEEF, "target": PASTA_POT_2, "consume": 1,
+     "tip": "§a意面加熟牛肉, 变成 炒锅_77(牛肉意面_生); 拿锅铲翻炒3次"},
+    {"block": PASTA_POT_1, "item": BROWN_MUSHROOM, "target": PASTA_POT_4, "consume": 5,
+     "tip": "§a意面加香菇x5, 变成 炒锅_79(香菇意面_生); 拿锅铲翻炒3次"},
+    {"block": PASTA_POT_1, "item": CRUSHED_CARROTS, "target": PASTA_POT_6, "consume": 3,
+     "tip": "§a意面加胡萝卜碎x3, 变成 炒锅_81(胡萝卜意面_生); 拿锅铲翻炒3次"},
+    {"block": PASTA_POT_1, "item": CHICKEN, "target": PASTA_POT_8, "consume": 1,
+     "tip": "§a意面加鸡肉, 变成 炒锅_83(鸡肉番茄意面_生); 拿锅铲翻炒3次"},
+    # 菜谱49 蛋炒饭 (煎蛋 + 胡萝卜碎x3)
+    {"block": COOKED_EGG, "item": CRUSHED_CARROTS, "target": RICE_EGG_1, "consume": 3,
+     "tip": "§a煎蛋加胡萝卜碎x3, 变成 炒锅_85(蛋炒饭_加胡萝卜_生); 拿锅铲翻炒3次"},
+
+    # ---------------- 四、翻炒(锅铲右键3次, 需下方点燃炉灶, 冷却1.5秒) ----------------
+    {"block": COOKING_CARROT, "item": SPATULA, "action": "stir", "target": WOKCARROT_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_95(炒胡萝卜_半熟); 再翻炒3次可熟"},
+    {"block": WOKCARROT_1, "item": SPATULA, "action": "stir", "target": COOKING_PEPPER, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_19(炒胡萝卜_熟); 可作胡萝卜系菜基底"},
+    {"block": PASTA_POT_0, "item": SPATULA, "action": "stir", "target": PASTA_POT_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_76(意面_熟); 可加牛肉/香菇/胡萝卜碎/鸡肉"},
+    {"block": COOKING_POTATO, "item": SPATULA, "action": "stir", "target": COOKING_POTATO_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_48(炒土豆_熟); 可手持盘子出锅 或 加猪肉做土豆炒猪肉"},
+    {"block": COOKING_MEAT, "item": SPATULA, "action": "stir", "target": COOKING_MEAT_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_45(炒碎肉_熟); 可手持盘子出锅"},
+    {"block": SQUID_WHISKERS_0, "item": SPATULA, "action": "stir", "target": SQUID_WHISKERS_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_93(炒鱿鱼须_熟); 可手持盘子出锅"},
+    {"block": COOKING_CRAB_1, "item": SPATULA, "action": "stir", "target": COOKING_CRAB_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_35(炒蟹_熟); 可手持盘子出锅"},
+    {"block": COOKING_FISH, "item": SPATULA, "action": "stir", "target": COOKING_FISH_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_42(煎鲑鱼_熟); 可手持盘子出锅"},
+    {"block": COOKING_SQUID, "item": SPATULA, "action": "stir", "target": COOKING_SQUID_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_57(炒鱿鱼_半熟); 再翻炒3次可熟"},
+    {"block": COOKING_SQUID_1, "item": SPATULA, "action": "stir", "target": COOKING_SQUID_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_58(炒鱿鱼_熟); 可手持盘子出锅"},
+    {"block": CARROT_AND_BEEF, "item": SPATULA, "action": "stir", "target": CARROT_AND_BEEF_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_2(黑椒牛排_熟); 可手持盘子出锅"},
+    {"block": CARROT_AND_BEEFRIBS, "item": SPATULA, "action": "stir", "target": CARROT_AND_BEEFRIBS_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_4(胡萝卜牛排骨_熟); 可手持盘子出锅"},
+    {"block": CARROT_AND_LEGCOW, "item": SPATULA, "action": "stir", "target": CARROT_AND_LEGCOW_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_6(黑椒牛腿_熟); 可手持盘子出锅"},
+    {"block": CARROT_AND_MUTTON, "item": SPATULA, "action": "stir", "target": CARROT_AND_MUTTON_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_8(清炒羊肉_熟); 可手持盘子出锅"},
+    {"block": CARROT_AND_PORKCHOP, "item": SPATULA, "action": "stir", "target": CARROT_AND_PORKCHOP_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_10(清炒猪排_熟); 可手持盘子出锅"},
+    {"block": CARROT_AND_SALMON, "item": SPATULA, "action": "stir", "target": CARROT_AND_SALMON_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_12(胡萝卜鲑鱼_熟); 可手持盘子出锅"},
+    {"block": CARROT_LEG_OF_LAMB, "item": SPATULA, "action": "stir", "target": CARROT_LEG_OF_LAMB_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_14(胡萝卜羊腿_熟); 可手持盘子出锅"},
+    {"block": COOKING_COD, "item": SPATULA, "action": "stir", "target": COOKING_COD_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_29(胡萝卜炒鳕鱼_熟); 可手持盘子出锅"},
+    {"block": COOKING_BEEF_TENDERLOIN, "item": SPATULA, "action": "stir", "target": COOKING_BEEF_TENDERLOIN_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_24(胡萝卜牛里脊_熟); 可手持盘子出锅"},
+    {"block": COOKING_COOKED_PORKLOIN, "item": SPATULA, "action": "stir", "target": COOKING_COOKED_PORKLOIN_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_31(小炒五花肉_熟); 可手持盘子出锅"},
+    {"block": COOKING_COOKED_PORKRIBS, "item": SPATULA, "action": "stir", "target": COOKING_COOKED_PORKRIBS_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_33(胡萝卜炒猪排骨_熟); 可手持盘子出锅"},
+    {"block": COOKING_SHEEPLOIN, "item": SPATULA, "action": "stir", "target": COOKING_SHEEPLOIN_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_53(胡萝卜炒羊里脊_熟); 可手持盘子出锅"},
+    {"block": COOKING_SHEEPRACK, "item": SPATULA, "action": "stir", "target": COOKING_SHEEPRACK_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_55(胡萝卜炒羊排_熟); 可手持盘子出锅"},
+    {"block": COOKING_CHILI_CHICKEN, "item": SPATULA, "action": "stir", "target": COOKING_CHILI_CHICKEN_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_27(辣子鸡丁_熟); 可手持盘子出锅"},
+    {"block": COOKING_RABBIT, "item": SPATULA, "action": "stir", "target": COOKING_RABBIT_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_50(辣炒兔肉_熟); 可手持盘子出锅"},
+    {"block": SPICY_FISH_0, "item": SPATULA, "action": "stir", "target": SPICY_FISH_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_91(辣炒鲑鱼_熟); 可手持盘子出锅"},
+    {"block": OILPAN_CHILI_BEEF_1, "item": SPATULA, "action": "stir", "target": OILPAN_CHILI_BEEF_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_72(辣椒炒牛肉_熟); 可手持盘子出锅"},
+    {"block": OILPAN_CHILI_BEEF_BEANCURD, "item": SPATULA, "action": "stir", "target": OILPAN_CHILI_BEEF_BEANCURD_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_74(麻婆豆腐_熟); 可手持盘子出锅"},
+    {"block": MUSHROOM_FRIED_CHICKEN_1, "item": SPATULA, "action": "stir", "target": MUSHROOM_FRIED_CHICKEN_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_69(香菇滑鸡_熟); 可手持盘子出锅"},
+    {"block": FRIED_PORK_WITH_POTATOES, "item": SPATULA, "action": "stir", "target": FRIED_PORK_WITH_POTATOES_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_65(土豆炒猪肉_熟); 可手持盘子出锅"},
+    {"block": FRIED_PORK_WITH_CARROTS, "item": SPATULA, "action": "stir", "target": FRIED_PORK_WITH_CARROTS_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_67(胡萝卜炒猪肉_熟); 可手持盘子出锅"},
+    {"block": COOKING_VEGETABLES, "item": SPATULA, "action": "stir", "target": COOKING_VEGETABLES_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_60(炒时蔬_加蔬菜_熟); 可加胡萝卜碎做炒时蔬"},
+    {"block": SEASONAL_VEGETABLES, "item": SPATULA, "action": "stir", "target": SEASONAL_VEGETABLES_1, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_89(炒时蔬_加胡萝卜_熟); 可手持盘子出锅"},
+    {"block": COOKING_ANY_MEAT, "item": SPATULA, "action": "stir", "target": FRIED_CHICKEN, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_66(小炒鸡肉_半熟); 再翻炒3次变熟 或 加香菇x8做香菇滑鸡"},
+    {"block": FRIED_CHICKEN, "item": SPATULA, "action": "stir", "target": COOKED_ANY_MEAT, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_16(小炒鸡肉_熟); 可手持盘子出锅"},
+    {"block": PASTA_POT_2, "item": SPATULA, "action": "stir", "target": PASTA_POT_3, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_78(牛肉意面_熟); 可手持盘子出锅"},
+    {"block": PASTA_POT_4, "item": SPATULA, "action": "stir", "target": PASTA_POT_5, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_80(香菇意面_熟); 可手持盘子出锅"},
+    {"block": PASTA_POT_6, "item": SPATULA, "action": "stir", "target": PASTA_POT_7, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_82(胡萝卜意面_熟); 可手持盘子出锅"},
+    {"block": PASTA_POT_8, "item": SPATULA, "action": "stir", "target": PASTA_POT_9, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_84(鸡肉番茄意面_熟); 可手持盘子出锅"},
+    {"block": RICE_EGG_1, "item": SPATULA, "action": "stir", "target": RICE_EGG_2, "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成, 变成 炒锅_86(蛋炒饭_加胡萝卜_熟); 再加米饭做蛋炒饭"},
+    # 菜谱40 煎酱香饼: 翻炒3次(方块不变, 门控 rtdd_cf=3), 满3次可空手出锅
+    {"block": COOKING_PANCAKE_2, "item": SPATULA, "action": "stir", "times": 3,
+     "needBelow": LIT_STOVE, "belowTip": "§c炒锅需要放在点燃的炉灶上才能翻炒",
+     "tip": "§a翻炒完成(3/3); 空手右键出锅 酱香饼"},
+
+    # ---------------- 五、出锅(熟态 + 盘子 -> 掉落盘装成品, 锅变回炒锅(空)) ----------------
+    {"block": COOKING_POTATO_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_14, "consume": 1, "tip": "§a取出 炒土豆, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_MEAT_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_24, "consume": 1, "tip": "§a取出 炒碎肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": SQUID_WHISKERS_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_26D, "consume": 1, "tip": "§a取出 炒鱿鱼须, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_CRAB_2, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_33, "consume": 1, "tip": "§a取出 炒蟹, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_FISH_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_25, "consume": 1, "tip": "§a取出 煎鲑鱼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_SQUID_2, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_26, "consume": 1, "tip": "§a取出 炒鱿鱼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    # 菜谱15 煎蛋(熟): 需计时门控 rtdd_cg=1
+    {"block": COOKED_EGG, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_22, "consume": 1, "needFlag": ["rtdd_cg", 1, "§e煎蛋还没煎熟, 再等30秒"],
+     "tip": "§a取出 元气煎蛋, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_AND_BEEF_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_2, "consume": 1, "tip": "§a取出 黑椒牛排, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_AND_BEEFRIBS_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_6, "consume": 1, "tip": "§a取出 胡萝卜牛排骨, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_AND_LEGCOW_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_7, "consume": 1, "tip": "§a取出 黑椒牛腿, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_AND_MUTTON_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_3, "consume": 1, "tip": "§a取出 清炒羊肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_AND_PORKCHOP_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_1, "consume": 1, "tip": "§a取出 清炒猪排, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_AND_SALMON_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_5, "consume": 1, "tip": "§a取出 胡萝卜鲑鱼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": CARROT_LEG_OF_LAMB_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_9, "consume": 1, "tip": "§a取出 胡萝卜羊腿, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_COD_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_15, "consume": 1, "tip": "§a取出 胡萝卜炒鳕鱼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_BEEF_TENDERLOIN_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_8, "consume": 1, "tip": "§a取出 胡萝卜牛里脊, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_COOKED_PORKLOIN_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_12, "consume": 1, "tip": "§a取出 小炒五花肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_COOKED_PORKRIBS_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_13, "consume": 1, "tip": "§a取出 胡萝卜炒猪排骨, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_SHEEPLOIN_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_10, "consume": 1, "tip": "§a取出 胡萝卜炒羊里脊, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_SHEEPRACK_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_11, "consume": 1, "tip": "§a取出 胡萝卜炒羊排, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_CHILI_CHICKEN_2, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_47, "consume": 1, "tip": "§a取出 辣子鸡丁, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKING_RABBIT_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_19, "consume": 1, "tip": "§a取出 辣炒兔肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": SPICY_FISH_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_41, "consume": 1, "tip": "§a取出 辣炒鲑鱼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": OILPAN_CHILI_BEEF_2, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_47A, "consume": 1, "tip": "§a取出 辣椒炒牛肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": OILPAN_CHILI_BEEF_BEANCURD_2, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_32, "consume": 1, "tip": "§a取出 麻婆豆腐, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": MUSHROOM_FRIED_CHICKEN_2, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_54, "consume": 1, "tip": "§a取出 香菇滑鸡, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": FRIED_PORK_WITH_POTATOES_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_52, "consume": 1, "tip": "§a取出 土豆炒猪肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": FRIED_PORK_WITH_CARROTS_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_53, "consume": 1, "tip": "§a取出 胡萝卜炒猪肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": SEASONAL_VEGETABLES_1, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_23, "consume": 1, "tip": "§a取出 炒时蔬, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": COOKED_ANY_MEAT, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_31, "consume": 1, "tip": "§a取出 小炒鸡肉, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": PASTA_POT_3, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_43, "consume": 1, "tip": "§a取出 牛肉意面, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": PASTA_POT_5, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_44, "consume": 1, "tip": "§a取出 香菇意面, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": PASTA_POT_7, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_45, "consume": 1, "tip": "§a取出 胡萝卜意面, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": PASTA_POT_9, "item": PLATE, "action": "take_out",
+     "dropItem": PLATE_46, "consume": 1, "tip": "§a取出 鸡肉番茄意面, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    {"block": RICE_EGG_3, "item": PLATE, "action": "take_out",
+     "dropItem": BOWL_OF_RICE_EGG, "consume": 1, "tip": "§a取出 蛋炒饭, 锅变回 炒锅(空); 成品【吃】右键食用"},
+
+    # ---------------- 六、空手出锅(熟饼/馍/煎饼/酱香饼, 空手右键) ----------------
+    # 菜谱39 煎葱油饼_熟 空手出锅 -> 葱油饼
+    {"block": COOKING_SCALLION_PANCAKE_1, "item": None, "action": "take_out",
+     "dropItem": SCALLION_PANCAKE_0, "tip": "§a取出 葱油饼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+    # 菜谱41 煎馍_熟 空手出锅 -> 馍
+    {"block": COOKING_DOUGH_1, "item": None, "action": "take_out",
+     "dropItem": ROUJIAMO_0, "tip": "§a取出 馍, 锅变回 炒锅(空); 馍可做羊肉泡馍汤/肉夹馍"},
+    # 菜谱42 煎面饼_熟 空手出锅 -> 煎饼
+    {"block": COOKING_DOUGHT_1, "item": None, "action": "take_out",
+     "dropItem": COOKED_DOUGHT, "tip": "§a取出 煎饼, 锅变回 炒锅(空); 煎饼可卷菜"},
+    # 菜谱40 煎酱香饼(需翻炒3次门控 rtdd_cf=3) 空手出锅 -> 酱香饼
+    {"block": COOKING_PANCAKE_2, "item": None, "action": "take_out",
+     "dropItem": COOKED_PANCAKE, "needFlag": ["rtdd_cf", 3, "§c请先用锅铲翻炒3次"],
+     "tip": "§a取出 酱香饼, 锅变回 炒锅(空); 成品【吃】右键食用"},
+]
+
+# ============================================================================
+# 八、手持物品右键方块表面规则(供 ChaoguoService handleItemUseOn)
+#    盖饭双向转换 + 蛋炒饭加米饭:
+#      - 正向: 手持 成品菜(plate_47/54/32/15) 右键 米饭(三形态任一) -> 米饭变盖饭
+#      - 反向: 手持 米饭(三形态任一) 右键 成品菜 -> 菜品变盖饭
+#      - 蛋炒饭: 手持 米饭(任一形态) 右键 炒锅_86(蛋炒饭_加胡萝卜_熟) -> 蛋炒饭_加米饭_熟
+# ============================================================================
+
+# 盖饭转换清单(正向+反向共用): dish=成品菜, target=盖饭
+GAI_FAN_ITEMS = [
+    {"dish": PLATE_47, "target": PLATE_48,
+     "name": "辣子鸡丁", "gaiName": "辣子鸡丁盖饭(全份)"},
+    {"dish": PLATE_54, "target": PLATE_55,
+     "name": "香菇滑鸡", "gaiName": "香菇滑鸡盖饭(全份)"},
+    {"dish": PLATE_32, "target": PLATE_56,
+     "name": "麻婆豆腐(全份)", "gaiName": "麻婆豆腐盖饭"},
+    {"dish": PLATE_15, "target": PLATE_50,
+     "name": "胡萝卜炒鳕鱼", "gaiName": "鳕鱼盖饭"},
+]
+
+ITEM_USE_ON_RULES = []
+for _g in GAI_FAN_ITEMS:
+    _dish = _g["dish"]
+    _target = _g["target"]
+    _name = _g["name"]
+    _gai = _g["gaiName"]
+    # 正向: 手持成品菜 右键 米饭(三形态任一) -> 米饭变盖饭
+    for _rice in RICE_FORMS:
+        ITEM_USE_ON_RULES.append({
+            "item": _dish, "surface": _rice, "target": _target, "consume": 1,
+            "tip": "§a%s 盖在米饭上, 变成 %s; 成品【吃】右键食用" % (_name, _gai)})
+    # 反向: 手持 米饭(三形态任一) 右键 成品菜 -> 菜品变盖饭
+    for _rice in RICE_FORMS:
+        ITEM_USE_ON_RULES.append({
+            "item": _rice, "surface": _dish, "target": _target, "consume": 1,
+            "tip": "§a米饭 压进 %s, 变成 %s; 成品【吃】右键食用" % (_name, _gai)})
+# 蛋炒饭 加米饭(形态1/2/3都行) -> 炒锅_87(蛋炒饭_加米饭_熟)
+for _rice in RICE_FORMS:
+    ITEM_USE_ON_RULES.append({
+        "item": _rice, "surface": RICE_EGG_2, "target": RICE_EGG_3, "consume": 1,
+        "tip": "§a加入米饭, 变成 炒锅_87(蛋炒饭_加米饭_熟); 可手持盘子出锅 蛋炒饭"})
+
+# ============================================================================
+# 九、计时规则(供 ChaoguoTimerService)
+#    below: 方块正下方须是 点燃的炉灶(stove_2) 才计时
+#    mark:  门控计时(煎蛋: 方块不变, 到点标记 rtdd_cg=1)
+# ============================================================================
+TIMER_RULES = [
+    # 菜谱15 煎蛋: 30秒煎熟, 方块不变(门控标记 rtdd_cg=1)
+    {"source": COOKED_EGG, "time": 30, "below": [LIT_STOVE],
+     "autoStart": True, "mark": "rtdd_cg",
+     "doneTip": "§e煎蛋煎熟了, 手持盘子右键取出"},
+    # 菜谱39 煎葱油饼_生 -> 60秒 -> 煎葱油饼_熟
+    {"source": COOKING_SCALLION_PANCAKE_0, "target": COOKING_SCALLION_PANCAKE_1,
+     "time": 60, "below": [LIT_STOVE], "autoStart": True,
+     "doneTip": "§e煎葱油饼煎好了, 空手右键取出"},
+    # 菜谱41 煎馍_生 -> 60秒 -> 煎馍_熟
+    {"source": COOKING_DOUGH_0, "target": COOKING_DOUGH_1,
+     "time": 60, "below": [LIT_STOVE], "autoStart": True,
+     "doneTip": "§e煎馍煎好了, 空手右键取出"},
+    # 菜谱42 煎面饼_生 -> 60秒 -> 煎面饼_熟
+    {"source": COOKING_DOUGHT_0, "target": COOKING_DOUGHT_1,
+     "time": 60, "below": [LIT_STOVE], "autoStart": True,
+     "doneTip": "§e煎面饼煎好了, 空手右键取出"},
+]

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/xiangyemod/chaoguo/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/xiangyemod/chaoguo/service/ChaoguoService.py

@@ -0,0 +1,383 @@
+# -*- coding: utf-8 -*-
+"""
+================================================================================
+炒锅·右键转换引擎（服务端）
+================================================================================
+处理"炒锅"(xy_chaoguo) 分类下的右键转换:
+  炒锅(空)<->(盖锅)、辣椒锅底、葱花锅底、放料(添油+食材 -> 菜生态)、
+  翻炒(锅铲右键3次, 需下方点燃炉灶)、出锅(熟态+盘子 -> 掉落盘装成品)、
+  空手出锅(煎葱油饼_熟/煎馍_熟/煎面饼_熟/煎酱香饼)、
+  盖饭双向(手持成品菜右键米饭 <-> 手持米饭右键成品菜, itemUseOn)。
+
+【事件监听在哪？】
+  本类【不】监听任何事件！
+  所有事件由 FeatureDispatcher 统一监听, 按 blockOwner / itemUseOnOwner
+  路由到本类 handleBlockUse / handleItemUseOn。
+
+【计时在?】
+  煎蛋/煎葱油饼/煎馍/煎面饼 的计时在 ChaoguoTimerService,
+  本类只负责"空手右键计时源方块"转发启动(FeatureDispatcher.startTimerFor)。
+
+【门控数据(存方块实体)】
+  rtdd_cf: 翻炒计数(满3次后按规则变方块; 煎酱香饼门控=3)
+  rtdd_cg: 煎蛋门控(计时30秒后由计时服务置1, 之后才允许盘子出锅)
+================================================================================
+"""
+import time
+import mod.server.extraServerApi as serverApi
+
+# ---- 网易API基础对象 ----
+ServerSystem = serverApi.GetServerSystemCls()   # 服务端系统基类
+comp = serverApi.GetEngineCompFactory()          # 组件工厂
+
+# ---- 继承 BlueFox 框架的系统基类（提供 CreateEngineItemEntity 等方法） ----
+from ....BlueFoxTools.SpecialFunciton.BlueFoxSystem import BlueFoxServerSystem
+from ....BlueFoxTools.ToolsConfig import LevelId
+
+# ---- 方块实体数据组件（翻炒计数/门控持久化） ----
+blockEntityDataComp = comp.CreateBlockEntityData(LevelId)
+
+# ---- 只导入炒锅自己的数据库 ----
+from ..ChaoguoData import (
+    SWITCH_RULES, ITEM_USE_ON_RULES, TIMER_RULES,
+    WOK,
+    COOKED_EGG, COOKING_SCALLION_PANCAKE_0, COOKING_DOUGH_0, COOKING_DOUGHT_0,
+)
+
+# ---- 统一分发器 ----
+from ...service.FeatureDispatcher import FeatureDispatcher
+
+
+class ChaoguoService(BlueFoxServerSystem):
+    """
+    炒锅·右键转换引擎
+    """
+
+    def __init__(self, namespace, systemName):
+        super(ChaoguoService, self).__init__(namespace, systemName)
+        print "===== ChaoguoService init ====="
+
+        # ---- (方块, 手持物品) -> 规则: O(1) 查找 (item=None 表示空手右键) ----
+        self.recipes = {}
+        self.featureBlocks = set()
+        for r in SWITCH_RULES:
+            self.recipes[(r["block"], r.get("item"))] = r
+            self.featureBlocks.add(r["block"])
+
+        # ---- 手持物品右键方块表面 -> 规则: (物品, 表面方块) -> 规则 ----
+        self.itemUseOnRecipes = {}
+        for r in ITEM_USE_ON_RULES:
+            self.itemUseOnRecipes[(r["item"], r["surface"])] = r
+
+        # ---- 空手右键"计时源方块"(煎蛋/煎葱油饼_生/煎馍_生/煎面饼_生): ----
+        # 放在点燃炉灶上 -> 开始计时(提示包含总共多少秒与结果)
+        self.timerSources = set()
+        self.startTimerTips = {}     # 空手右键启动计时 -> 提示
+        self.timingTips = {}         # 空手右键"已在计时中" -> 提示
+        for src, r in {t["source"]: t for t in TIMER_RULES}.items():
+            self.timerSources.add(src)
+            self.featureBlocks.add(src)   # 登记右键路由, 空手右键才分发到这里
+        self.startTimerTips = {
+            COOKED_EGG: "§a开始计时: 还需30秒, 计时结束 煎蛋煎熟, 手持盘子出锅",
+            COOKING_SCALLION_PANCAKE_0: "§a开始计时: 还需60秒, 计时结束变成 煎葱油饼_熟, 空手出锅 葱油饼",
+            COOKING_DOUGH_0: "§a开始计时: 还需60秒, 计时结束变成 煎馍_熟, 空手出锅 馍",
+            COOKING_DOUGHT_0: "§a开始计时: 还需60秒, 计时结束变成 煎面饼_熟, 空手出锅 煎饼",
+        }
+        self.timingTips = {
+            COOKED_EGG: "§e正在计时中: 还需30秒, 计时结束 煎蛋煎熟, 手持盘子出锅",
+            COOKING_SCALLION_PANCAKE_0: "§e正在计时中: 还需60秒, 计时结束变成 煎葱油饼_熟, 空手出锅 葱油饼",
+            COOKING_DOUGH_0: "§e正在计时中: 还需60秒, 计时结束变成 煎馍_熟, 空手出锅 馍",
+            COOKING_DOUGHT_0: "§e正在计时中: 还需60秒, 计时结束变成 煎面饼_熟, 空手出锅 煎饼",
+        }
+
+        # ---- 右键冷却表 ----
+        self.cooldown = {}
+
+        # ---- 注册到统一分发器 ----
+        FeatureDispatcher.register(self)
+
+    # ============================================================================
+    # 一、给 FeatureDispatcher 的接口
+    # ============================================================================
+
+    def getFeatureBlocks(self):
+        """返回本功能管辖的所有右键方块名集合"""
+        return self.featureBlocks
+
+    def getItemUseOnRules(self):
+        """手持物品右键方块表面路由: 盖饭成品菜 + 米饭三形态(盖饭/蛋炒饭)"""
+        return {r["item"]: True for r in ITEM_USE_ON_RULES}
+
+    def handleBlockUse(self, args):
+        """由 FeatureDispatcher 转发的右键方块入口"""
+        blockName = args.get("blockName")
+        playerId = args.get("playerId")
+        x, y, z = args.get("x"), args.get("y"), args.get("z")
+        pos = (x, y, z)
+        dim = comp.CreateDimension(playerId).GetEntityDimensionId()
+        key = (dim, x, y, z)
+
+        itemDict = self.getCarriedItem(playerId)
+        itemName = itemDict.get("newItemName") if itemDict else None
+        if itemName == "minecraft:air":
+            itemName = None
+        recipe = self.recipes.get((blockName, itemName))
+        if not recipe:
+            # 空手右键"计时源方块"(煎蛋/煎葱油饼_生/煎馍_生/煎面饼_生):
+            # 下方是点燃炉灶 -> 开始计时
+            if itemName is None and blockName in self.timerSources:
+                if not self.checkCooldown(key, 0.4):
+                    return True
+                self._handleStartTimer(blockName, playerId, pos, dim)
+                return True
+            return False
+        # 翻炒用 1.5 秒冷却(防连点刷计数), 其余 0.4 秒
+        cd = 1.5 if recipe.get("action") == "stir" else 0.4
+        if not self.checkCooldown(key, cd):
+            return True
+        self.handleSwitch(recipe, playerId, pos, dim, itemDict)
+        return True
+
+    def _handleStartTimer(self, blockName, playerId, pos, dim):
+        """空手右键计时源: 已在计时中 -> 提示总时长; 否则转发计时服务开始(下方需点燃炉灶)"""
+        try:
+            data = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if data and data["rtdd_tid"] == blockName:
+                comp.CreateMsg(playerId).NotifyOneMessage(
+                    playerId, self.timingTips.get(blockName, "§e已经在计时中"))
+                return
+        except Exception:
+            pass
+        started = FeatureDispatcher.startTimerFor(blockName, dim, pos, playerId)
+        if started:
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, self.startTimerTips.get(blockName, "§a已启动计时"))
+        else:
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, "§c炒锅需要放在点燃的炉灶上才能开始计时")
+
+    def handleItemUseOn(self, args):
+        """由 FeatureDispatcher 转发的"手持物品右键方块表面"入口(盖饭/蛋炒饭)。
+        正向: 手持成品菜 右键 米饭 -> 米饭变盖饭; 反向: 手持米饭 右键 成品菜 -> 菜品变盖饭;
+        蛋炒饭: 手持米饭 右键 炒锅_86 -> 炒锅_87。转换与取消放置同一事件完成"""
+        itemName = args.get("itemName")
+        playerId = args.get("playerId") or args.get("entityId")
+        x, y, z = args.get("x"), args.get("y"), args.get("z")
+        pos = (x, y, z)
+        dim = comp.CreateDimension(playerId).GetEntityDimensionId()
+        key = (dim, x, y, z)
+        try:
+            b = comp.CreateBlockInfo(LevelId).GetBlockNew(pos, dim)
+            clickedName = b.get("name") if b else None
+        except Exception:
+            clickedName = None
+        recipe = self.itemUseOnRecipes.get((itemName, clickedName))
+        if not recipe:
+            # 手持 成品菜/米饭 右键 本分类功能方块(炒锅态等) 无对应转换 ->
+            # 直接取消默认放置, 避免"先放置方块再消失"的视觉问题
+            # (米饭/成品菜右键非功能方块仍可正常放置/堆叠)
+            if clickedName and clickedName in self.featureBlocks:
+                return True
+            return False
+        if not self.checkCooldown(key, 0.4):
+            return True
+        itemDict = self.getCarriedItem(playerId)
+
+        # 消耗物品(数量不足则拦截, 不转换)
+        consume = recipe.get("consume", 1)
+        if consume > 1 and itemDict is not None and (itemDict.get("count") or 0) < consume:
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, "§c数量不足, 需要 %d 个" % consume)
+            return True
+        if consume > 0:
+            self.consumeItem(playerId, itemDict, consume)
+
+        # 替换被右键的表面方块(米饭变盖饭 / 菜品变盖饭 / 蛋炒饭变熟)
+        self.replaceBlock(pos, dim, recipe["target"], playerId)
+        self._clearWokData(dim, pos)
+
+        if recipe.get("tip"):
+            comp.CreateMsg(playerId).NotifyOneMessage(playerId, recipe["tip"])
+        return True
+
+    # ============================================================================
+    # 二、通用转换执行
+    # ============================================================================
+
+    def handleSwitch(self, recipe, playerId, pos, dim, itemDict):
+        # 需要下方方块(翻炒: 炒锅下须是点燃的炉灶): 不满足则提示并拦截
+        needBelow = recipe.get("needBelow")
+        if needBelow and not self._belowIs(dim, pos, needBelow):
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, recipe.get("belowTip", "§c下方方块不符合"))
+            return
+
+        # 出锅门控(煎蛋需煎熟 rtdd_cg=1; 煎酱香饼需翻炒3次 rtdd_cf=3)
+        needFlag = recipe.get("needFlag")
+        if needFlag:
+            flagKey, flagVal, flagTip = needFlag[0], needFlag[1], needFlag[2]
+            if self._readFlag(dim, pos, flagKey) < flagVal:
+                comp.CreateMsg(playerId).NotifyOneMessage(playerId, flagTip)
+                return
+
+        # 消耗物品(数量不足则拦截, 不转换)
+        consume = recipe.get("consume", 0)
+        if consume > 1 and itemDict is not None and (itemDict.get("count") or 0) < consume:
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, "§c数量不足, 需要 %d 个" % consume)
+            return
+        if consume > 0:
+            self.consumeItem(playerId, itemDict, consume)
+
+        action = recipe.get("action")
+        if action == "stir":
+            self._handleStir(recipe, playerId, pos, dim)
+        elif action == "take_out":
+            # 出锅: 锅变回 炒锅(空) + 掉落盘装成品(掉落物形式)
+            self.replaceBlock(pos, dim, WOK, playerId)
+            self.dropItem(dim, pos, recipe["dropItem"])
+            self._clearWokData(dim, pos)
+        # 普通替换方块(盖锅/锅底/放料/加料)
+        if recipe.get("target") and action != "take_out":
+            self.replaceBlock(pos, dim, recipe["target"], playerId)
+            self._clearWokData(dim, pos)
+
+        # 提示
+        if recipe.get("tip"):
+            comp.CreateMsg(playerId).NotifyOneMessage(playerId, recipe["tip"])
+
+    def _handleStir(self, recipe, playerId, pos, dim):
+        """翻炒: 锅铲右键计1次(rtdd_cf), 满 times 次后变 target;
+        煎酱香饼无 target, 满3次后门控(空手出锅用)"""
+        times = recipe.get("times", 3)
+        cf = self._readFlag(dim, pos, "rtdd_cf") + 1
+        if cf >= times:
+            target = recipe.get("target")
+            if target:
+                self.replaceBlock(pos, dim, target, playerId)
+                self._clearWokData(dim, pos)   # 新方块重置翻炒计数
+            else:
+                self._writeFlag(dim, pos, "rtdd_cf", times)   # 门控: 保持3
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, recipe.get("tip", "§a翻炒完成"))
+        else:
+            self._writeFlag(dim, pos, "rtdd_cf", cf)
+            comp.CreateMsg(playerId).NotifyOneMessage(
+                playerId, "§a翻炒中 (%d/%d)" % (cf, times))
+
+    # ============================================================================
+    # 三、方块实体门控数据 读/写(rtdd_cf 翻炒计数 / rtdd_cg 煎蛋门控)
+    # ============================================================================
+
+    def _readFlag(self, dim, pos, key):
+        try:
+            data = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if data is None:
+                return 0
+            v = data[key]
+            return int(v) if v else 0
+        except Exception:
+            return 0
+
+    def _writeFlag(self, dim, pos, key, val):
+        try:
+            data = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if data is not None:
+                data[key] = int(val)
+        except Exception:
+            pass
+
+    def _clearWokData(self, dim, pos):
+        """替换方块后清掉上一态的计时/门控数据(新方块从0开始)"""
+        try:
+            data = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if data is None:
+                return
+            data["rtdd_tid"] = ""
+            data["rtdd_tstart"] = 0
+            data["rtdd_tdur"] = 0
+            data["rtdd_tp"] = ""
+            data["rtdd_cf"] = 0
+            data["rtdd_cg"] = 0
+        except Exception:
+            pass
+
+    # ============================================================================
+    # 四、工具方法，判断正下方是否指定方块(点燃炉灶)
+    # ============================================================================
+
+    def _belowIs(self, dim, pos, blockName):
+        try:
+            b = comp.CreateBlockInfo(LevelId).GetBlockNew((pos[0], pos[1] - 1, pos[2]), dim)
+            return bool(b) and b.get("name") == blockName
+        except Exception:
+            return False
+
+    # ============================================================================
+    # 五、工具方法，获取玩家主手物品
+    # ============================================================================
+
+    def getCarriedItem(self, playerId):
+        itemComp = comp.CreateItem(playerId)
+        return itemComp.GetPlayerItem(
+            serverApi.GetMinecraftEnum().ItemPosType.CARRIED, 0, True)
+
+    # ============================================================================
+    # 六、工具方法，消耗物品
+    # ============================================================================
+
+    def consumeItem(self, playerId, itemDict, amount=1):
+        if itemDict is None:
+            return
+        count = itemDict.get("count", 0)
+        if count <= amount:
+            comp.CreateItem(playerId).SetEntityItem(
+                serverApi.GetMinecraftEnum().ItemPosType.CARRIED,
+                {"itemName": "minecraft:air", "count": 0, "auxValue": 0})
+        else:
+            itemDict["count"] = count - amount
+            comp.CreateItem(playerId).SetEntityItem(
+                serverApi.GetMinecraftEnum().ItemPosType.CARRIED,
+                {"itemName": itemDict["newItemName"],
+                 "count": itemDict["count"],
+                 "auxValue": itemDict.get("newAuxValue", 0),
+                 "userData": itemDict.get("userData", {})})
+
+    # ============================================================================
+    # 七、工具方法，以掉落物形式生成物品
+    # ============================================================================
+
+    def dropItem(self, dim, pos, itemName, count=1, aux=0):
+        try:
+            itemDict = {"itemName": itemName, "count": count, "auxValue": aux}
+            self.CreateEngineItemEntity(itemDict, dim, (pos[0], pos[1] + 0.5, pos[2]))
+        except Exception:
+            pass
+
+    # ============================================================================
+    # 八、工具方法，替换方块
+    # ============================================================================
+
+    def replaceBlock(self, pos, dim, newBlockName, playerId=None):
+        creator = playerId if playerId is not None else LevelId
+        aux = 0
+        try:
+            oldBlock = comp.CreateBlockInfo(creator).GetBlockNew(pos, dim)
+            aux = oldBlock.get("aux", 0)
+        except Exception:
+            aux = 0
+        comp.CreateBlockInfo(creator).SetBlockNew(
+            pos, blockDict={"name": newBlockName, "aux": aux},
+            oldBlockHandling=0, dimensionId=dim)
+
+    # ============================================================================
+    # 九、工具方法，冷却检查
+    # ============================================================================
+
+    def checkCooldown(self, key, cd=0.4):
+        now = time.time()
+        last = self.cooldown.get(key, 0)
+        if now - last < cd:
+            return False
+        self.cooldown[key] = now
+        return True

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/xiangyemod/chaoguo/service/ChaoguoTimerService.py

@@ -0,0 +1,237 @@
+# -*- coding: utf-8 -*-
+"""
+================================================================================
+炒锅·计时引擎（服务端）
+================================================================================
+只处理"炒锅"(xy_chaoguo) 分类下的【计时自动转换】:
+  煎蛋        : 30秒煎熟(方块不变, 门控标记 rtdd_cg=1, 之后才可盘子出锅)
+  煎葱油饼_生 : 60秒 -> 煎葱油饼_熟
+  煎馍_生     : 60秒 -> 煎馍_熟
+  煎面饼_生   : 60秒 -> 煎面饼_熟
+
+【计时判定(用户指定, 与油锅/汤锅一致)】
+  - 计时方块【正下方】必须是 点燃的炉灶(stove_2) 才开始计时
+  - 计时数据在【方块本身】上(方块 tick 时判定下方炉灶)
+  - 炉灶被移走/熄灭 -> 暂停计时(数据保留, 炉灶回来继续) + 提示发起玩家
+
+【事件监听在哪？】
+  本类【不】监听任何事件！
+  ServerBlockEntityTickEvent 由 FeatureDispatcher 统一监听, 再按 timerOwner
+  路由到本类的 handleBlockEntityTick。计时用绝对时间戳写方块实体数据,
+  退出重进继续计时。
+================================================================================
+"""
+import time
+import mod.server.extraServerApi as serverApi
+
+# ---- 网易API基础对象 ----
+ServerSystem = serverApi.GetServerSystemCls()   # 服务端系统基类
+comp = serverApi.GetEngineCompFactory()          # 组件工厂
+
+# ---- 继承 BlueFox 框架的系统基类 ----
+from ....BlueFoxTools.SpecialFunciton.BlueFoxSystem import BlueFoxServerSystem
+from ....BlueFoxTools.ToolsConfig import LevelId
+
+# ---- 方块实体数据组件（计时持久化: 开始时间戳+时长写进方块） ----
+blockEntityDataComp = comp.CreateBlockEntityData(LevelId)
+
+# ---- 只导入炒锅自己的数据库 ----
+from ..ChaoguoData import TIMER_RULES
+
+# ---- 统一分发器 ----
+from ...service.FeatureDispatcher import FeatureDispatcher
+
+
+class ChaoguoTimerService(BlueFoxServerSystem):
+    """
+    炒锅·计时引擎
+    """
+
+    def __init__(self, namespace, systemName):
+        super(ChaoguoTimerService, self).__init__(namespace, systemName)
+        print "===== ChaoguoTimerService init ====="
+
+        # ---- 计时规则: source -> [规则...] ----
+        self.timerMap = {}
+        for t in TIMER_RULES:
+            self.timerMap.setdefault(t["source"], []).append(t)
+
+        # ---- 注册到分发器的计时路由表 ----
+        FeatureDispatcher.registerTimer(self)
+
+    # ============================================================================
+    # 一、给 FeatureDispatcher 的接口
+    # ============================================================================
+
+    def getTimerBlocks(self):
+        """返回本功能的所有"计时源方块"集合（tick 路由用）"""
+        return set(self.timerMap.keys())
+
+    def handleBlockEntityTick(self, args):
+        """由 FeatureDispatcher 转发的计时方块 tick 入口"""
+        dim = args.get("dimension")
+        pos = (args.get("posX"), args.get("posY"), args.get("posZ"))
+        blockName = args.get("blockName", "")
+        self._tickProcess(dim, pos, blockName)
+
+    # ============================================================================
+    # 二、启动计时（空手右键计时源方块后由 ChaoguoService 通过 startTimerFor 转发）
+    # ============================================================================
+
+    def startTimer(self, dim, pos, blockName, playerId=None):
+        rules = self.timerMap.get(blockName)
+        if not rules:
+            return False
+        rule = self._pickRule(rules, dim, pos)
+        if not rule:
+            return False
+        try:
+            data = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if data and data["rtdd_tid"] == blockName:
+                return False
+        except Exception:
+            pass
+        self._writeTimerData(dim, pos, rule, playerId)
+        return True
+
+    # ============================================================================
+    # 三、tick 检查与到点转换
+    # ============================================================================
+
+    def _pickRule(self, rules, dim, pos):
+        """按"下方方块"匹配规则(点燃炉灶), 返回命中的规则; 无命中返回 None"""
+        belowPos = (pos[0], pos[1] - 1, pos[2])
+        try:
+            b = comp.CreateBlockInfo(LevelId).GetBlockNew(belowPos, dim)
+            belowName = b.get("name") if b else ""
+        except Exception:
+            belowName = ""
+        for rule in rules:
+            if belowName in rule.get("below", [belowName]):
+                return rule
+        return None
+
+    def _tickProcess(self, dim, pos, blockName):
+        try:
+            rules = self.timerMap.get(blockName)
+            if not rules:
+                return
+
+            blockData = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if blockData is None:
+                return
+
+            try:
+                tid = blockData["rtdd_tid"]
+            except Exception:
+                tid = ""
+            if tid != blockName:
+                # autoStart: 计时源方块无计时数据且下方点燃炉灶时自动启动
+                if any(r.get("autoStart", True) for r in rules):
+                    rule = self._pickRule(rules, dim, pos)
+                    if rule:
+                        self._writeTimerData(dim, pos, rule, None)
+                return
+
+            # 计时中: 下方点燃炉灶被移走/熄灭 -> 暂停 + 提示
+            rule = self._pickRule(rules, dim, pos)
+            if rule is None:
+                self._handleBelowBroken(dim, pos, blockName, blockData, rules)
+                return
+
+            tstart = blockData["rtdd_tstart"]
+            tdur = blockData["rtdd_tdur"]
+
+            if time.time() - tstart >= tdur:
+                self._finishTimer(dim, pos, rule)
+        except Exception:
+            pass
+
+    def _handleBelowBroken(self, dim, pos, blockName, data, rules):
+        """下方点燃炉灶被移走/熄灭: 暂停计时(数据保留, 炉灶回来继续) + 提示发起玩家"""
+        tp = ""
+        try:
+            tp = data["rtdd_tp"] or ""
+        except Exception:
+            tp = ""
+        self._notifyIfOnline(tp, "§c炒锅下的炉灶移走了, 暂停计时")
+
+    def _finishTimer(self, dim, pos, rule):
+        """到点转换; 煎蛋为门控(mark): 方块不变, 标记 rtdd_cg=1"""
+        try:
+            cur = comp.CreateBlockInfo(LevelId).GetBlockNew(pos, dim)
+            if cur and cur.get("name") != rule["source"]:
+                self._clearTimerData(dim, pos)
+                return
+            mark = rule.get("mark")
+            if mark:
+                # 门控计时: 方块不变, 标记煎熟(rtdd_cg=1)
+                blockData = blockEntityDataComp.GetBlockEntityData(dim, pos)
+                if blockData is not None:
+                    blockData[mark] = 1
+                self._clearTimerData(dim, pos)
+                return
+            # 到点转换
+            self.replaceBlock(pos, dim, rule["target"], None)
+            self._clearTimerData(dim, pos)
+        except Exception:
+            pass
+
+    # ============================================================================
+    # 四、计时数据读写（存在方块实体数据里，重启不丢）
+    # ============================================================================
+
+    def _writeTimerData(self, dim, pos, recipe, playerId=None):
+        try:
+            blockData = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if blockData is None:
+                return
+            now = time.time()
+            blockData["rtdd_tid"] = recipe["source"]
+            blockData["rtdd_tstart"] = now
+            blockData["rtdd_tdur"] = recipe.get("time", 60)
+            blockData["rtdd_tp"] = playerId if playerId else ""
+        except Exception:
+            pass
+
+    def _clearTimerData(self, dim, pos):
+        try:
+            blockData = blockEntityDataComp.GetBlockEntityData(dim, pos)
+            if blockData is None:
+                return
+            blockData["rtdd_tid"] = ""
+            blockData["rtdd_tstart"] = 0
+            blockData["rtdd_tdur"] = 0
+            blockData["rtdd_tp"] = ""
+        except Exception:
+            pass
+
+    # ============================================================================
+    # 五、提示工具
+    # ============================================================================
+
+    def _notifyIfOnline(self, playerId, tip):
+        if not tip or not playerId:
+            return
+        try:
+            ids = comp.CreateGame(LevelId).GetAllPlayerIds()
+            if playerId in ids:
+                comp.CreateMsg(playerId).NotifyOneMessage(playerId, tip)
+        except Exception:
+            pass
+
+    # ============================================================================
+    # 六、工具方法：替换方块
+    # ============================================================================
+
+    def replaceBlock(self, pos, dim, newBlockName, playerId=None):
+        creator = playerId if playerId is not None else LevelId
+        aux = 0
+        try:
+            oldBlock = comp.CreateBlockInfo(creator).GetBlockNew(pos, dim)
+            aux = oldBlock.get("aux", 0)
+        except Exception:
+            aux = 0
+        comp.CreateBlockInfo(creator).SetBlockNew(
+            pos, blockDict={"name": newBlockName, "aux": aux},
+            oldBlockHandling=0, dimensionId=dim)

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/xiangyemod/chaoguo/service/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/xiangyemod/chuju/service/ChujuService.py

@@ -76,6 +76,11 @@ class ChujuService(BlueFoxServerSystem):
         for b in BEATER_BLOCKS:
             self.featureBlocks.add(b)
         self.featureBlocks.add("rtdd:stonemill")
+        # 炒锅(wok) 必须登记为本功能管辖方块: 带油锅铲右键炒锅上油走 handleItemUseOn,
+        # 分发器要求"被点方块的右键归属里含本服务"才会调用本服务的 handleItemUseOn;
+        # 炒锅分类(ChaoguoService) 也登记了 wok, 若本服务不登记则上油会被跳过失效。
+        # (wok 的空手盖锅/锅底/放料右键由 ChaoguoService.handleBlockUse 处理)
+        self.featureBlocks.add(WOK)
 
         # ---- 搅拌器方块集合（专用 handler） ----
         self.beaterBlockSet = set(BEATER_BLOCKS)

behavior_pack_v8jz0zSR/netease_blocks/cookedegg.json

@@ -48,7 +48,7 @@
       "netease:block_entity": {
         "client_tick": false,
         "movable": false,
-        "tick": false
+        "tick": true
       }
     }
   }

behavior_pack_v8jz0zSR/netease_blocks/cooking_scallion_pancake_0.json

@@ -48,7 +48,7 @@
       "netease:block_entity": {
         "client_tick": false,
         "movable": false,
-        "tick": false
+        "tick": true
       }
     }
   }

behavior_pack_v8jz0zSR/netease_blocks/cookingdough_0.json

@@ -48,7 +48,7 @@
       "netease:block_entity": {
         "client_tick": false,
         "movable": false,
-        "tick": false
+        "tick": true
       }
     }
   }

behavior_pack_v8jz0zSR/netease_blocks/cookingdought_0.json

@@ -48,7 +48,7 @@
       "netease:block_entity": {
         "client_tick": false,
         "movable": false,
-        "tick": false
+        "tick": true
       }
     }
   }

tuilun/全部功能做了什么.txt

@@ -787,3 +787,99 @@ FurnitureData+FurnitureService 实现, 注册到 FeatureDispatcher）
 汤锅类功能方块取消默认放置(全局) [已实现]
 【留后】各碗装成品/汤面 右键吃(总食用功能后续实现)
 
+
+########################################
+【炒锅】(xy_chaoguo) 2026-09-18
+########################################
+实现于 xiangyemod/chaoguo (ChaoguoData + ChaoguoService + ChaoguoTimerService, 注册到 FeatureDispatcher)
+(4个计时方块 netease:block_entity tick 已改 true: cookedegg / cooking_scallion_pancake_0 /
+ cookingdough_0 / cookingdought_0; 全部方块/食材 id 见 炒锅转化关系.txt 与 ChaoguoData.py)
+
+一、炒锅基础
+- 炒锅(空)<->炒锅(盖锅): 空手右键双向切换 [已实现]
+- 辣椒锅底: 炒锅(空) + 辣椒(rtdd:pepper)x2 -> 炒锅_15(辣椒锅底) [已实现]
+- 葱花锅底: 炒锅(空) + 葱花碎x3 -> 炒锅_94(葱花锅底) [已实现]
+- 炒锅(空)->炒锅(添油): 带油锅铲右键, 已实现于 ChujuService(不重复注册);
+  为保持该 itemUseOn 可达, ChujuService 已把 wok 同时登记为管辖方块
+  (否则分发器会因"被点方块归属不含本服务"跳过上油) [已实现]
+
+二、放料(炒锅(添油) + 食材右键 -> 菜生态, 消耗数量按txt)
+- 生猪肉x1->炒猪肉_生 / 土豆块x1->炒土豆_生 / 葱花碎x3->加葱 / 蒜末x3->加大蒜 /
+  胡萝卜(原版)x2->炒胡萝卜_生 / 生面x2->意面_生 / 碎肉x4->炒碎肉_生 /
+  鱿鱼须x3->炒鱿鱼须_生 / 鲑鱼x1->煎鲑鱼_生 / 死鱿鱼(切掉鱿鱼须)x1->炒鱿鱼_生 /
+  鸡蛋x1->煎蛋 / 生牛肉x1->黑椒牛排_生 / 牛腿肉x1->黑椒牛腿_生 / 五花肉x1->小炒五花肉_生 /
+  青菜碎x4->炒时蔬_加蔬菜_生 / 生面团(发酵后)x1->煎馍_生 / 生面饼x1->煎面饼_生 /
+  生鸡肉x1->小炒鸡肉_生 [已实现]
+
+三、基底/中间态 + 主料 -> 菜生态
+- 加大蒜+螃蟹x1->炒蟹_生; 炒胡萝卜_熟(基底) + 牛肋x2->胡萝卜牛排骨_生 / +鲑鱼->胡萝卜鲑鱼_生 /
+  +羊腿->胡萝卜羊腿_生 / +鳕鱼->胡萝卜炒鳕鱼_生 / +牛里脊->胡萝卜牛里脊_生 /
+  +猪肋排x2->胡萝卜炒猪排骨_生 / +羊里脊x2->胡萝卜炒羊里脊_生 / +羊小排x2->胡萝卜炒羊排_生 /
+  +生猪肉->胡萝卜炒猪肉_生(组合B) [已实现]
+- 葱花锅底+羊肉->清炒羊肉_生 / +生猪肉->清炒猪排_生 [已实现]
+- 辣椒锅底+鸡肉->辣子鸡丁_生 / +兔肉x2->辣炒兔肉_生 / +鲑鱼->辣炒鲑鱼_生 /
+  +牛肉->辣椒炒牛肉_生 [已实现]
+- 辣椒炒牛肉_生+豆腐x1->麻婆豆腐_生 [已实现]
+- 小炒鸡肉_半熟+香菇(原版棕/红蘑菇)x8->香菇滑鸡_生 [已实现]
+- 炒猪肉_生+土豆块x3->土豆炒猪肉_生(组合A); 炒土豆_熟+生猪肉x1->土豆炒猪肉_生(组合B) [已实现]
+- 炒猪肉_生+胡萝卜碎x3->胡萝卜炒猪肉_生(组合A); 炒胡萝卜_熟+生猪肉x1->胡萝卜炒猪肉_生(组合B) [已实现]
+- 炒时蔬_加蔬菜_熟+胡萝卜碎x1->炒时蔬_加胡萝卜_生 [已实现]
+- 煎面饼_生+葱花碎x3->煎葱油饼_生; 煎面饼_熟+辣椒x3->煎酱香饼 [已实现]
+- 意面_熟(基底)+熟牛肉->牛肉意面_生 / +棕蘑菇x5->香菇意面_生 / +胡萝卜碎x3->胡萝卜意面_生 /
+  +鸡肉->鸡肉番茄意面_生 [已实现]
+- 煎蛋+胡萝卜碎x3->蛋炒饭_加胡萝卜_生 [已实现]
+
+四、翻炒(手持锅铲右键, 需下方点燃炉灶 stove_2, 冷却1.5秒, 计3次满后变下一态;
+   计数存方块实体数据 rtdd_cf, 换方块自动清零)
+- 炒胡萝卜_生->半熟->熟(两级) / 意面_生->熟 / 炒土豆_生->熟 / 炒碎肉_生->熟 /
+  炒鱿鱼须_生->熟 / 炒蟹_生->熟 / 煎鲑鱼_生->熟 / 炒鱿鱼_生->半熟->熟(两级) /
+  黑椒牛排_生->熟 / 胡萝卜牛排骨_生->熟 / 黑椒牛腿_生->熟 / 清炒羊肉_生->熟 /
+  清炒猪排_生->熟 / 胡萝卜鲑鱼_生->熟 / 胡萝卜羊腿_生->熟 / 胡萝卜炒鳕鱼_生->熟 /
+  胡萝卜牛里脊_生->熟 / 小炒五花肉_生->熟 / 胡萝卜炒猪排骨_生->熟 /
+  胡萝卜炒羊里脊_生->熟 / 胡萝卜炒羊排_生->熟 / 辣子鸡丁_生->熟 / 辣炒兔肉_生->熟 /
+  辣炒鲑鱼_生->熟 / 辣椒炒牛肉_生->熟 / 麻婆豆腐_生->熟 / 香菇滑鸡_生->熟 /
+  土豆炒猪肉_生->熟 / 胡萝卜炒猪肉_生->熟 / 炒时蔬_加蔬菜_生->熟 / 炒时蔬_加胡萝卜_生->熟 /
+  小炒鸡肉_生->半熟->熟(两级) / 牛肉意面_生->熟 / 香菇意面_生->熟 / 胡萝卜意面_生->熟 /
+  鸡肉番茄意面_生->熟 / 蛋炒饭_加胡萝卜_生->熟 [已实现]
+- 煎酱香饼: 翻炒3次(方块不变, 门控 rtdd_cf=3), 满3次才可空手出锅 [已实现]
+- 下方无点燃炉灶 -> 提示"炒锅需要放在点燃的炉灶上才能翻炒"并拦截 [已实现]
+
+五、计时(计时方块正下方是点燃炉灶 stove_2 才计时; 计时数据在方块本身; 炉灶移走暂停+提示;
+   放置后 autoStart 自动启动; 未启动时 空手右键计时源方块可手动启动)
+- 煎蛋: 30秒煎熟(方块不变, 门控标记 rtdd_cg=1, 之后才可盘子出锅) [已实现]
+- 煎葱油饼_生: 60秒 -> 煎葱油饼_熟 [已实现]
+- 煎馍_生: 60秒 -> 煎馍_熟 [已实现]
+- 煎面饼_生: 60秒 -> 煎面饼_熟 [已实现]
+
+六、出锅(手持盘子右键熟态, 消耗1盘子, 锅变回 炒锅(空), 盘装成品以掉落物形式出现)
+- 炒土豆->plate_14 / 炒碎肉->plate_24 / 炒鱿鱼须->plate_26d / 炒蟹->plate_33 /
+  煎鲑鱼->plate_25 / 炒鱿鱼->plate_26 / 元气煎蛋->plate_22(需 rtdd_cg=1 门控) /
+  黑椒牛排->plate_2 / 胡萝卜牛排骨->plate_6 / 黑椒牛腿->plate_7 / 清炒羊肉->plate_3 /
+  清炒猪排->plate_1 / 胡萝卜鲑鱼->plate_5 / 胡萝卜羊腿->plate_9 / 胡萝卜炒鳕鱼->plate_15 /
+  胡萝卜牛里脊->plate_8 / 小炒五花肉->plate_12 / 胡萝卜炒猪排骨->plate_13 /
+  胡萝卜炒羊里脊->plate_10 / 胡萝卜炒羊排->plate_11 / 辣子鸡丁->plate_47 /
+  辣炒兔肉->plate_19 / 辣炒鲑鱼->plate_41 / 辣椒炒牛肉->plate_47a / 麻婆豆腐->plate_32 /
+  香菇滑鸡->plate_54 / 土豆炒猪肉->plate_52 / 胡萝卜炒猪肉->plate_53 / 炒时蔬->plate_23 /
+  小炒鸡肉->plate_31 / 牛肉意面->plate_43 / 香菇意面->plate_44 / 胡萝卜意面->plate_45 /
+  鸡肉番茄意面->plate_46 / 蛋炒饭->bowlofriceegg [已实现]
+
+七、空手出锅(空手右键, 锅变回 炒锅(空), 成品掉落物形式)
+- 煎葱油饼_熟 空手出锅 -> 葱油饼(scallion_pancake_0) [已实现]
+- 煎馍_熟 空手出锅 -> 馍(roujiamo_0) [已实现]
+- 煎面饼_熟 空手出锅 -> 煎饼(cooked_dought) [已实现]
+- 煎酱香饼(需翻炒3次门控 rtdd_cf=3) 空手出锅 -> 酱香饼(cookedpancake) [已实现]
+
+八、盖饭(food_11_rice_meal, 走 itemUseOn 路径, 转换与取消默认放置同一事件完成)
+- 正向: 手持 辣子鸡丁(plate_47)/香菇滑鸡(plate_54)/麻婆豆腐(全份)(plate_32)/胡萝卜炒鳕鱼(plate_15)
+  右键 米饭(形态1/2/3任一), 消耗1个成品菜, 米饭原地变对应盖饭:
+  辣子鸡丁盖饭(全份)(plate_48) / 香菇滑鸡盖饭(全份)(plate_55) / 麻婆豆腐盖饭(plate_56) /
+  鳕鱼盖饭(plate_50) [已实现]
+- 反向: 手持 米饭(形态1/2/3任一) 右键 上述成品菜方块, 消耗1个米饭, 菜品原地变对应盖饭 [已实现]
+- 蛋炒饭加米饭: 手持米饭(任一形态)右键 炒锅_86(蛋炒饭_加胡萝卜_熟) -> 炒锅_87(蛋炒饭_加米饭_熟) [已实现]
+- 手持成品菜/米饭 右键 本分类功能方块 无对应转换时直接取消默认放置(不"先放再消失") [已实现]
+
+【提示/体验】所有转换有提示(含消耗数量与下一步指引); 数量不足/翻炒无下方点燃炉灶/
+出锅门控未达成(煎蛋未熟/酱香饼未翻炒) 有提示并拦截; 翻炒冷却1.5秒, 其余右键冷却0.4秒;
+手持方块物品右键炒锅类功能方块取消默认放置(全局) [已实现]
+【留后】各盘装成品/盖饭 右键吃(总食用功能后续实现)、半份/部分份变体出锅(见 全部功能没做什么.txt)
+

tuilun/全部功能没做什么.txt

@@ -244,3 +244,35 @@ todo 需要 对油罐 进行一个 打碎 后 在右键依然是多少的使用
     包括油罐右键 油锅(空)的时候 做剩余次数判断
     带油锅铲 右键玻璃罐 会变成 油罐 次数+1 是从0 加1 (不确定是否实现)
     蛋糕 蜂蜜瓶 可可豆 后续全部实现了再加
+
+
+########################################
+【炒锅】(xy_chaoguo) 2026-09-18
+########################################
+(炒锅转换 已整体实现于 xiangyemod/chaoguo 2026-09-18, 见 全部功能做了什么.txt)
+
+一、吃 (各盘装成品 / 盖饭 右键食用)
+- 盘装成品: 黑椒牛排/清炒猪排/清炒羊肉/熟鸡肉盘/胡萝卜鲑鱼/胡萝卜牛排骨/黑椒牛腿/
+  胡萝卜牛里脊/胡萝卜羊腿/胡萝卜炒羊里脊/胡萝卜炒羊排/小炒五花肉/胡萝卜炒猪排骨/
+  炒土豆/胡萝卜炒鳕鱼/辣炒兔肉/元气煎蛋/炒时蔬/炒碎肉/煎鲑鱼/炒鱿鱼/炒鱿鱼须/
+  小炒鸡肉/麻婆豆腐/炒蟹/辣炒鲑鱼/牛肉意面/香菇意面/胡萝卜意面/鸡肉番茄意面/
+  辣子鸡丁/辣椒炒牛肉/土豆炒猪肉/胡萝卜炒猪肉/香菇滑鸡/蛋炒饭/葱油饼/酱香饼/馍/煎饼
+- 盖饭: 辣子鸡丁盖饭(全份/半份)/香菇滑鸡盖饭(全份/半份)/麻婆豆腐盖饭/鳕鱼盖饭
+- 未做原因: 食用部分由统一的"总食用功能"汇总实现, 本次不实现 (炒锅转化关系.txt 已标注)
+
+二、半份/部分份变体 (出锅递减链路)
+- 黑椒牛排(半份)(plate_2a)/清炒猪排(半份)(plate_1a)/胡萝卜鲑鱼(半份)(plate_5a)/
+  胡萝卜羊腿(半份)(plate_9a)/胡萝卜炒羊里脊(半份)(plate_10a)/小炒五花肉(半份)(plate_12a)/
+  胡萝卜炒猪排骨(半份)(plate_13a)/辣炒兔肉(半份)(plate_19a)/炒鱿鱼(三分之二份)(plate_26a)/
+  炒鱿鱼(三分之一份)(plate_26b)/炒鱿鱼须(半份)(plate_26c)/小炒鸡肉(半份)(plate_31a)/
+  麻婆豆腐(半份)(plate_32a)/炒蟹(半份)(plate_33a)/牛肉意面(半份)(plate_43a)/
+  香菇意面(半份)(plate_44a)/胡萝卜意面(半份)(plate_45a)/鸡肉番茄意面(半份)(plate_46a)/
+  辣子鸡丁盖饭(半份)(plate_48a)/香菇滑鸡盖饭(半份)(plate_55a)
+- 未做原因: 各半份/部分份变体均属"吃"的递减链路, 由统一的"总食用功能"汇总实现
+
+三、香菇滑鸡前置基底 原文存疑 (待用户确认)
+- 炒锅转化关系.txt 菜谱34 写"炒锅_62(小炒鸡肉_生) + 香菇x8",
+  但 lang 中 炒锅_62 = 炒猪肉_生(rtdd:fried_pork), 与菜谱产物(香菇滑鸡=鸡肉)矛盾;
+  本次按同名"小炒鸡肉"最近态实现为 炒锅_66(小炒鸡肉_半熟)(rtdd:friedchicken) + 香菇x8
+- 若确认应改用 炒锅_22(小炒鸡肉_生)(rtdd:cookinganymeat), 只需改 ChaoguoData.py
+  菜谱34 两条规则的 block 字段即可

tuilun/炒锅转化关系.txt

@@ -407,9 +407,11 @@
 ========================================
 菜谱 35 — 土豆炒猪肉 (前置: 炒猪肉, 见 菜谱3)
 ========================================
-步骤1：炒猪肉(炒锅_62(炒猪肉_生) 翻炒后) + 拿土豆块(rtdd:potato_wedges)右键, 消耗3个
+组合A：炒猪肉(炒锅_62(炒猪肉_生) 翻炒后) + 拿土豆块(rtdd:potato_wedges)右键, 消耗3个
        -> 变身 炒锅_64(土豆炒猪肉_生)(rtdd:fried_porkwith_potatoes)
-       todo 或者 炒土豆_熟 拿生猪肉 右键 消耗一个 变成 土豆炒猪肉_生 注意组合!
+组合B：炒锅_48(炒土豆_熟)(rtdd:cookingpotato_1) + 拿生猪肉(minecraft:porkchop)右键, 消耗1个
+       -> 变身 炒锅_64(土豆炒猪肉_生)(rtdd:fried_porkwith_potatoes)
+(两种组合都出 土豆炒猪肉_生, 注意组合!)
 步骤2：炒锅_64(土豆炒猪肉_生)(rtdd:fried_porkwith_potatoes) + 拿锅铲(rtdd:spatula)右键翻炒3次, 冷却1.5秒
        -> 变身 炒锅_65(土豆炒猪肉_熟)(rtdd:fried_porkwith_potatoes_1)
 步骤3：炒锅_65(土豆炒猪肉_熟)(rtdd:fried_porkwith_potatoes_1) + 手持盘子(rtdd:plate_0)右键, 消耗1个
@@ -418,9 +420,11 @@
 ========================================
 菜谱 36 — 胡萝卜炒猪肉 (前置: 炒猪肉, 见 菜谱3)
 ========================================
-步骤1：炒猪肉(炒锅_62(炒猪肉_生) 翻炒后) + 拿胡萝卜碎(rtdd:crushed_carrots)右键, 消耗3个
+组合A：炒猪肉(炒锅_62(炒猪肉_生) 翻炒后) + 拿胡萝卜碎(rtdd:crushed_carrots)右键, 消耗3个
        -> 变身 炒锅_63(胡萝卜炒猪肉_生)(rtdd:fried_porkwith_carrots)
-       todo 或者 炒胡萝卜_熟 拿生猪肉 右键 消耗一个 变成 胡萝卜炒猪肉_生 注意组合!
+组合B：炒锅_19(炒胡萝卜_熟)(rtdd:cooking_pepper) + 拿生猪肉(minecraft:porkchop)右键, 消耗1个
+       -> 变身 炒锅_63(胡萝卜炒猪肉_生)(rtdd:fried_porkwith_carrots)
+(两种组合都出 胡萝卜炒猪肉_生, 注意组合!)
 步骤2：炒锅_63(胡萝卜炒猪肉_生)(rtdd:fried_porkwith_carrots) + 拿锅铲(rtdd:spatula)右键翻炒3次, 冷却1.5秒
        -> 变身 炒锅_67(胡萝卜炒猪肉_熟)(rtdd:friedporkwithcarrots_1)
 步骤3：炒锅_67(胡萝卜炒猪肉_熟)(rtdd:friedporkwithcarrots_1) + 手持盘子(rtdd:plate_0)右键, 消耗1个
@@ -435,11 +439,11 @@
        -> 变身 炒锅_59(炒时蔬_加蔬菜_生)(rtdd:cookingvegetables)
 步骤2：炒锅_59(炒时蔬_加蔬菜_生)(rtdd:cookingvegetables) + 拿锅铲(rtdd:spatula)右键翻炒3次, 冷却1.5秒
        -> 变身 炒锅_60(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1)
-todo(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1) + 拿胡萝卜碎(rtdd:crushed_carrots)右键, 消耗1个
+步骤3：炒锅_60(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1) + 拿胡萝卜碎(rtdd:crushed_carrots)右键, 消耗1个
        -> 变身 炒锅_88(炒时蔬_加胡萝卜_生)(rtdd:seasonalvegetables)
-    炒锅_88(炒时蔬_加胡萝卜_生)(rtdd:seasonalvegetables) + 拿锅铲(rtdd:spatula)右键翻炒3次, 冷却1.5秒
+步骤4：炒锅_88(炒时蔬_加胡萝卜_生)(rtdd:seasonalvegetables) + 拿锅铲(rtdd:spatula)右键翻炒3次, 冷却1.5秒
        -> 变身 炒锅_89(炒时蔬_加胡萝卜_熟)(rtdd:seasonalvegetables_1)
-步骤3：炒锅_89(炒时蔬_加胡萝卜_熟)(rtdd:seasonalvegetables_1) + 手持盘子(rtdd:plate_0)右键, 消耗1个
+步骤5：炒锅_89(炒时蔬_加胡萝卜_熟)(rtdd:seasonalvegetables_1) + 手持盘子(rtdd:plate_0)右键, 消耗1个
        -> 锅变回 炒锅(空)(rtdd:wok), 获得 炒时蔬(rtdd:plate_23)
 
 ========================================
@@ -455,7 +459,7 @@ todo(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1) + 拿胡萝卜碎(rtdd:c
 ========================================
 菜谱 40 — 煎酱香饼
 ========================================
-步骤1：炒锅_40(煎面饼_熟)(rtdd:cookingdought_1) + 拿碎肉, 消耗3个
+步骤1：炒锅_40(煎面饼_熟)(rtdd:cookingdought_1) + 拿辣椒, 消耗3个
        -> 变身 炒锅_46(煎酱香饼)
        炒锅_46(煎酱香饼)->锅铲 右键 翻炒 三次
       炒锅_46(煎酱香饼) + 空手右键,
@@ -470,7 +474,7 @@ todo(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1) + 拿胡萝卜碎(rtdd:c
 步骤3：炒锅_37(煎馍_熟)(rtdd:cookingdough_1) + 空手右键,
        -> 锅变回 炒锅(空)(rtdd:wok), 获得 馍
 
-========================================
+=======================================
 菜谱 42 — 煎面饼
 ========================================
 步骤1：炒锅(添油)(rtdd:oilpan) + 拿生面饼右键, 消耗1个
@@ -534,11 +538,11 @@ todo(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1) + 拿胡萝卜碎(rtdd:c
 ========================================
 菜谱 49 — 蛋炒饭
 ========================================
-步骤1：炒锅_17(煎蛋)(rtdd:cookedegg) + 拿碗装米饭(rtdd:bowlofrice)右键, 消耗1个
+步骤1：炒锅_17(煎蛋)(rtdd:cookedegg) + 拿右键, 消胡萝卜碎耗3个
        -> 变身 炒锅_85(蛋炒饭_加胡萝卜_生)(rtdd:riceegg_1)
 步骤2：炒锅_85(蛋炒饭_加胡萝卜_生)(rtdd:riceegg_1) + 拿锅铲(rtdd:spatula)右键翻炒3次, 冷却1.5秒
        -> 变身 炒锅_86(蛋炒饭_加胡萝卜_熟)(rtdd:riceegg_2)
-步骤3：炒锅_86(蛋炒饭_加胡萝卜_熟)(rtdd:riceegg_2) + 拿碗装米饭(rtdd:bowlofrice)右键, 消耗1个
+步骤3：炒锅_86(蛋炒饭_加胡萝卜_熟)(rtdd:riceegg_2) + 拿米饭(形态1/2/3都行), 消耗1个
        -> 变身 炒锅_87(蛋炒饭_加米饭_熟)(rtdd:riceegg_3)
 步骤4：炒锅_87(蛋炒饭_加米饭_熟)(rtdd:riceegg_3) + 手持盘子(rtdd:plate_0)右键, 消耗1个
        -> 锅变回 炒锅(空)(rtdd:wok), 获得 蛋炒饭(rtdd:bowlofriceegg)
@@ -553,28 +557,67 @@ todo(炒时蔬_加蔬菜_熟)(rtdd:cookingvegetables_1) + 拿胡萝卜碎(rtdd:c
 ========================================
 盖饭分组(itemGroup.name.food_11_rice_meal)
 ========================================
-机制: 手持 成品菜 右键 碗装米饭(rtdd:bowlofrice), 消耗1个成品菜 + 1个碗装米饭, 变 盖饭
+机制: 手持 成品菜 右键 米饭(形态1/2/3都行), 消耗1个成品菜, 米饭原地变 对应盖饭
-(碗装米饭来源: 汤锅; 盖饭归 food_11_rice_meal 分组, 均【吃】)
+- 米饭三形态(均来自 汤锅 大米煮饭):
-- 辣子鸡丁盖饭(rtdd:plate_48) = 辣子鸡丁(rtdd:plate_47) + 碗装米饭
+    米饭_1(熟米饭_形态1)(rtdd:bowlofrice) / 米饭_2(熟米饭_形态2)(rtdd:bowlofrice_2)
-- 香菇滑鸡盖饭(rtdd:plate_55) = 香菇滑鸡(rtdd:plate_54) + 碗装米饭
+    / 米饭_3(熟米饭_形态3)(rtdd:bowlofrice_3), 三形态任意一个都能做盖饭
-- 麻婆豆腐盖饭(rtdd:plate_56) = 麻婆豆腐(rtdd:plate_32) + 碗装米饭
+- 盖饭归 food_11_rice_meal 分组, 均【吃】
-- 鳕鱼盖饭(rtdd:plate_50) = 胡萝卜炒鳕鱼(rtdd:plate_15) + 碗装米饭
+转换:
+- 手持 辣子鸡丁(rtdd:plate_47) 右键 米饭(任一形态), 消耗1个
+  -> 米饭变 辣子鸡丁盖饭(全份)(rtdd:plate_48)
+- 手持 香菇滑鸡(rtdd:plate_54) 右键 米饭(任一形态), 消耗1个
+  -> 米饭变 香菇滑鸡盖饭(全份)(rtdd:plate_55)
+- 手持 麻婆豆腐(全份)(rtdd:plate_32) 右键 米饭(任一形态), 消耗1个
+  -> 米饭变 麻婆豆腐盖饭(rtdd:plate_56)
+- 手持 胡萝卜炒鳕鱼(rtdd:plate_15) 右键 米饭(任一形态), 消耗1个
+  -> 米饭变 鳕鱼盖饭(rtdd:plate_50)
+
+反向转换(手持 米饭 右键 成品菜, 消耗1个米饭, 菜品原地变盖饭):
+- 手持 米饭(任一形态) 右键 辣子鸡丁(rtdd:plate_47), 消耗1个米饭
+  -> 菜品变 辣子鸡丁盖饭(全份)(rtdd:plate_48)
+- 手持 米饭(任一形态) 右键 香菇滑鸡(rtdd:plate_54), 消耗1个米饭
+  -> 菜品变 香菇滑鸡盖饭(全份)(rtdd:plate_55)
+- 手持 米饭(任一形态) 右键 麻婆豆腐(全份)(rtdd:plate_32), 消耗1个米饭
+  -> 菜品变 麻婆豆腐盖饭(rtdd:plate_56)
+- 手持 米饭(任一形态) 右键 胡萝卜炒鳕鱼(rtdd:plate_15), 消耗1个米饭
+  -> 菜品变 鳕鱼盖饭(rtdd:plate_50)
+盖饭方块清单(含半份变体):
+- 辣子鸡丁盖饭(全份)(rtdd:plate_48) / 辣子鸡丁盖饭(半份)(rtdd:plate_48a)
+- 香菇滑鸡盖饭(全份)(rtdd:plate_55) / 香菇滑鸡盖饭(半份)(rtdd:plate_55a)
+- 麻婆豆腐盖饭(rtdd:plate_56) / 鳕鱼盖饭(rtdd:plate_50)
 
 ========================================
-成品菜清单(归 chaoguo_finished, 均为【吃】)
+成品菜清单(归 chaoguo_finished, 均为【吃】, 含全份/半份变体)
 ========================================
 所有出锅产物 均以掉落物形式获得:
-- 黑椒牛排(rtdd:plate_2) / 清炒猪排(rtdd:plate_1) / 清炒羊肉(rtdd:plate_3)
+- 黑椒牛排(全份)(rtdd:plate_2) / 黑椒牛排(半份)(rtdd:plate_2a)
-- 熟鸡肉盘(rtdd:plate_4) / 胡萝卜鲑鱼(rtdd:plate_5) / 胡萝卜牛排骨(rtdd:plate_6)
+- 清炒猪排(全份)(rtdd:plate_1) / 清炒猪排(半份)(rtdd:plate_1a)
-- 黑椒牛腿(rtdd:plate_7) / 胡萝卜牛里脊(rtdd:plate_8) / 胡萝卜羊腿(rtdd:plate_9)
+- 清炒羊肉(rtdd:plate_3) / 熟鸡肉盘(rtdd:plate_4)
-- 胡萝卜炒羊里脊(rtdd:plate_10) / 胡萝卜炒羊排(rtdd:plate_11) / 小炒五花肉(rtdd:plate_12)
+- 胡萝卜鲑鱼(全份)(rtdd:plate_5) / 胡萝卜鲑鱼(半份)(rtdd:plate_5a)
-- 胡萝卜炒猪排骨(rtdd:plate_13) / 炒土豆(rtdd:plate_14) / 胡萝卜炒鳕鱼(rtdd:plate_15)
+- 胡萝卜牛排骨(rtdd:plate_6) / 黑椒牛腿(rtdd:plate_7) / 胡萝卜牛里脊(rtdd:plate_8)
-- 辣炒兔肉(rtdd:plate_19) / 元气煎蛋(rtdd:plate_22) / 炒时蔬(rtdd:plate_23)
+- 胡萝卜羊腿(全份)(rtdd:plate_9) / 胡萝卜羊腿(半份)(rtdd:plate_9a)
-- 炒碎肉(rtdd:plate_24) / 煎鲑鱼(rtdd:plate_25) / 炒鱿鱼(rtdd:plate_26)
+- 胡萝卜炒羊里脊(全份)(rtdd:plate_10) / 胡萝卜炒羊里脊(半份)(rtdd:plate_10a)
-- 炒鱿鱼须(rtdd:plate_26d) / 小炒鸡肉(rtdd:plate_31) / 麻婆豆腐(rtdd:plate_32)
+- 胡萝卜炒羊排(rtdd:plate_11)
-- 炒蟹(rtdd:plate_33) / 辣炒鲑鱼(rtdd:plate_41) / 牛肉意面(rtdd:plate_43)
+- 小炒五花肉(全份)(rtdd:plate_12) / 小炒五花肉(半份)(rtdd:plate_12a)
-- 香菇意面(rtdd:plate_44) / 胡萝卜意面(rtdd:plate_45) / 鸡肉番茄意面(rtdd:plate_46)
+- 胡萝卜炒猪排骨(全份)(rtdd:plate_13) / 胡萝卜炒猪排骨(半份)(rtdd:plate_13a)
-- 辣子鸡丁(rtdd:plate_47) / 辣椒炒牛肉(rtdd:plate_47a) / 土豆炒猪肉(rtdd:plate_52)
+- 炒土豆(rtdd:plate_14) / 胡萝卜炒鳕鱼(rtdd:plate_15)
-- 胡萝卜炒猪肉(rtdd:plate_53) / 香菇滑鸡(rtdd:plate_54) / 蛋炒饭(rtdd:bowlofriceegg)
+- 辣炒兔肉(全份)(rtdd:plate_19) / 辣炒兔肉(半份)(rtdd:plate_19a)
-- 盖饭: 辣子鸡丁盖饭(rtdd:plate_48) / 香菇滑鸡盖饭(rtdd:plate_55) / 麻婆豆腐盖饭(rtdd:plate_56)
+- 元气煎蛋(rtdd:plate_22) / 炒时蔬(rtdd:plate_23) / 炒碎肉(rtdd:plate_24) / 煎鲑鱼(rtdd:plate_25)
-        / 鳕鱼盖饭(rtdd:plate_50)
+- 炒鱿鱼(全份)(rtdd:plate_26) / 炒鱿鱼(三分之二份)(rtdd:plate_26a) / 炒鱿鱼(三分之一份)(rtdd:plate_26b)
+- 炒鱿鱼须(全份)(rtdd:plate_26d) / 炒鱿鱼须(半份)(rtdd:plate_26c)
+- 小炒鸡肉(全份)(rtdd:plate_31) / 小炒鸡肉(半份)(rtdd:plate_31a)
+- 麻婆豆腐(全份)(rtdd:plate_32) / 麻婆豆腐(半份)(rtdd:plate_32a)
+- 炒蟹(全份)(rtdd:plate_33) / 炒蟹(半份)(rtdd:plate_33a)
+- 辣炒鲑鱼(rtdd:plate_41)
+- 牛肉意面(全份)(rtdd:plate_43) / 牛肉意面(半份)(rtdd:plate_43a)
+- 香菇意面(全份)(rtdd:plate_44) / 香菇意面(半份)(rtdd:plate_44a)
+- 胡萝卜意面(全份)(rtdd:plate_45) / 胡萝卜意面(半份)(rtdd:plate_45a)
+- 鸡肉番茄意面(rtdd:plate_46) / 鸡肉番茄意面(半份)(rtdd:plate_46a)
+- 辣子鸡丁(rtdd:plate_47) / 辣椒炒牛肉(rtdd:plate_47a)
+- 天妇罗炸虾(rtdd:plate_49) / 天妇罗炸虾(半份)(rtdd:plate_49a)
+- 炸饺子(rtdd:plate_51) / 土豆炒猪肉(rtdd:plate_52) / 胡萝卜炒猪肉(rtdd:plate_53)
+- 香菇滑鸡(rtdd:plate_54) / 蛋炒饭(rtdd:bowlofriceegg)
+盖饭(归 food_11_rice_meal):
+- 辣子鸡丁盖饭(全份)(rtdd:plate_48) / 辣子鸡丁盖饭(半份)(rtdd:plate_48a)
+- 香菇滑鸡盖饭(全份)(rtdd:plate_55) / 香菇滑鸡盖饭(半份)(rtdd:plate_55a)
+- 麻婆豆腐盖饭(rtdd:plate_56) / 鳕鱼盖饭(rtdd:plate_50)