ECO全球生存游戏计算器类Minecraft物品ID分组方案咨询

直接采用分层ID+配置分离的思路实现，Python桌面端和TypeScript网页端保持逻辑完全一致即可，完全对齐类Minecraft的ID规则，同时天然适配你服务器的统一定价、制作成本计算需求。

核心ID规则设计 #

• 为每个基础物品类别分配全局唯一整数主ID，例如原木类主ID固定为101、泥土类主ID固定为1
• 同类别下的变种分配从0开始递增的整数变种ID，最终物品复合ID统一用主ID:变种ID的字符串格式存储，例如普通原木为101:0、桦木原木为101:1、橡木原木为101:2
• 配置分层存储：主ID绑定类别的通用属性（基础制作耗材、统一定价公式基础系数、支持的变种范围），变种ID只存储差异化属性（名称、耗材修正值、售价修正系数、特殊标签），避免重复配置。计算成本/售价时先取主ID通用参数，再叠加变种修正值即可，后续调整全类别的平衡参数只需要改一次主ID配置，不用逐个修改变种物品

跨语言通用实现逻辑 #

两端复用完全一致的处理流程，避免计算结果出现偏差：

1. 维护两张静态映射表：主ID对应类别通用配置、复合ID对应变种差异化配置
2. 封装通用工具方法：

• 复合ID解析：输入ID字符串按冒号切分，校验格式后返回整数格式的主ID、变种ID
• 全量信息聚合：输入复合ID，校验ID合法性后合并通用配置和变种配置，返回完整物品参数
• 成本/售价计算：基于聚合后的全量参数，直接套入你服务器的固定公式计算即可

3. 建议把所有物品配置抽成独立JSON文件，两端共用同一份数据源，后续新增物品时不用两边分别修改

Python（桌面端）代码示例 #

from typing import TypedDict, Optional

# 主ID对应类别通用配置结构
class BaseCategory(TypedDict):
    category_name: str
    base_craft_cost: dict[str, float]
    base_price_coeff: float
    allowed_variants: list[int]

# 变种ID对应差异化配置结构
class ItemVariant(TypedDict):
    item_name: str
    cost_modifier: dict[str, float]
    price_modifier: float
    tags: list[str]

# 配置表示例
CATEGORY_MAP: dict[int, BaseCategory] = {
    101: {
        "category_name": "原木类",
        "base_craft_cost": {"石斧耐久": 0.2, "体力": 3},
        "base_price_coeff": 1.2,
        "allowed_variants": [0, 1, 2]
    },
    1: {
        "category_name": "泥土类方块",
        "base_craft_cost": {"铲子耐久": 0.1, "体力": 1},
        "base_price_coeff": 0.3,
        "allowed_variants": [0, 1, 2]
    }
}

VARIANT_MAP: dict[str, ItemVariant] = {
    "101:0": {"item_name": "普通原木", "cost_modifier": {}, "price_modifier": 1.0, "tags": []},
    "101:1": {"item_name": "桦木原木", "cost_modifier": {"体力": 0.5}, "price_modifier": 1.1, "tags": ["建材专用"]},
    "101:2": {"item_name": "橡木原木", "cost_modifier": {"体力": 1.0}, "price_modifier": 1.3, "tags": ["家具专用"]},
    "1:0": {"item_name": "普通泥土", "cost_modifier": {}, "price_modifier": 1.0, "tags": []},
    "1:1": {"item_name": "草方块", "cost_modifier": {}, "price_modifier": 1.2, "tags": ["装饰"]},
    "1:2": {"item_name": "灰化土", "cost_modifier": {"体力":0.3}, "price_modifier": 1.5, "tags": ["特殊种植"]}
}

def parse_item_id(compound_id: str) -> Optional[tuple[int, int]]:
    try:
        main_id_str, variant_id_str = compound_id.split(":")
        main_id, variant_id = int(main_id_str), int(variant_id_str)
        return main_id, variant_id
    except (ValueError, IndexError):
        return None

def get_merged_item_config(compound_id: str) -> Optional[dict]:
    id_pair = parse_item_id(compound_id)
    if not id_pair:
        return None
    main_id, variant_id = id_pair
    base_config = CATEGORY_MAP.get(main_id)
    variant_config = VARIANT_MAP.get(compound_id)
    if not base_config or not variant_config or variant_id not in base_config["allowed_variants"]:
        return None
    # 变种配置优先级高于基础配置
    return {**base_config, **variant_config, "main_id": main_id, "variant_id": variant_id}

# 计算示例：10个桦木原木的总成本与售价
if __name__ == "__main__":
    item_config = get_merged_item_config("101:1")
    if item_config:
        craft_count = 10
        total_cost = {}
        for mat, consume in item_config["base_craft_cost"].items():
            total_cost[mat] = consume * craft_count
        for mat, consume in item_config["cost_modifier"].items():
            total_cost[mat] = total_cost.get(mat, 0) + consume * craft_count
        # 服务器统一定价公式可直接替换此处逻辑
        total_price = item_config["base_price_coeff"] * item_config["price_modifier"] * craft_count
        print(f"制作{craft_count}个{item_config['item_name']}，总成本：{total_cost}，统一售价：{round(total_price,2)}")

TypeScript（网页端）代码示例 #

interface BaseCategory {
  categoryName: string;
  baseCraftCost: Record<string, number>;
  basePriceCoeff: number;
  allowedVariants: number[];
}

interface ItemVariant {
  itemName: string;
  costModifier: Record<string, number>;
  priceModifier: number;
  tags: string[];
}

// 与Python端保持完全一致的配置
const CATEGORY_MAP: Record<number, BaseCategory> = {
  101: {
    categoryName: "原木类",
    baseCraftCost: { "石斧耐久": 0.2, "体力": 3 },
    basePriceCoeff: 1.2,
    allowedVariants: [0, 1, 2],
  },
  1: {
    categoryName: "泥土类方块",
    baseCraftCost: { "铲子耐久": 0.1, "体力": 1 },
    basePriceCoeff: 0.3,
    allowedVariants: [0, 1, 2],
  }
};

const VARIANT_MAP: Record<string, ItemVariant> = {
  "101:0": { itemName: "普通原木", costModifier: {}, priceModifier: 1.0, tags: [] },
  "101:1": { itemName: "桦木原木", costModifier: { "体力": 0.5 }, priceModifier: 1.1, tags: ["建材专用"] },
  "101:2": { itemName: "橡木原木", costModifier: { "体力": 1.0 }, priceModifier: 1.3, tags: ["家具专用"] },
  "1:0": { itemName: "普通泥土", costModifier: {}, priceModifier: 1.0, tags: [] },
  "1:1": { itemName: "草方块", costModifier: {}, priceModifier: 1.2, tags: ["装饰"] },
  "1:2": { itemName: "灰化土", costModifier: { "体力": 0.3 }, priceModifier: 1.5, tags: ["特殊种植"] }
};

function parseItemId(compoundId: string): [number, number] | null {
  const parts = compoundId.split(":");
  if (parts.length !== 2) return null;
  const mainId = Number(parts[0]);
  const variantId = Number(parts[1]);
  if (isNaN(mainId) || isNaN(variantId)) return null;
  return [mainId, variantId];
}

function getMergedItemConfig(compoundId: string) {
  const idPair = parseItemId(compoundId);
  if (!idPair) return null;
  const [mainId, variantId] = idPair;
  const baseConfig = CATEGORY_MAP[mainId];
  const variantConfig = VARIANT_MAP[compoundId];
  if (!baseConfig || !variantConfig || !baseConfig.allowedVariants.includes(variantId)) return null;
  return { ...baseConfig, ...variantConfig, mainId, variantId };
}

// 计算示例：10个桦木原木的总成本与售价
const itemConfig = getMergedItemConfig("101:1");
if (itemConfig) {
  const craftCount = 10;
  const totalCost: Record<string, number> = {};
  Object.entries(itemConfig.baseCraftCost).forEach(([mat, consume]) => {
    totalCost[mat] = consume * craftCount;
  });
  Object.entries(itemConfig.costModifier).forEach(([mat, consume]) => {
    totalCost[mat] = (totalCost[mat] || 0) + consume * craftCount;
  });
  // 服务器统一定价公式可直接替换此处逻辑
  const totalPrice = itemConfig.basePriceCoeff * itemConfig.priceModifier * craftCount;
  console.log(`制作${craftCount}个${itemConfig.itemName}，总成本：${JSON.stringify(totalCost)}，统一售价：${totalPrice.toFixed(2)}`);
}

扩展提示 #

• 复合ID始终用字符串做映射表的键，不要用数字存储带冒号的格式，避免出现精度、格式解析错误
• 变种修正值支持正负数值，后续如果出现成本低于基础类别的变种，直接填负修正值即可，不需要修改核心计算逻辑
• 如果后续需要新增品质、附魔等更多分层维度，直接扩展为主ID:变种ID:品质ID的格式即可，解析逻辑只需要多切分一段，扩展性足够

内容的提问来源于stack exchange，提问作者user15931633