使用 Python 打造模拟工厂游戏：工厂大师-CFANZ编程社区

技术准备

在开始编码之前，我们需要准备开发环境和相关工具。以下是开发 工厂大师 所需的技术栈和资源。

1. 技术栈

编程语言：Python 3.x（推荐 3.8 或更高版本）。
核心库：

random：用于模拟市场波动或其他随机事件（基础版本暂未使用）。
time：控制游戏节奏，添加回合间延迟。

数据存储：使用 Python 字典和列表管理资源、产品和生产线状态。
用户界面：基于命令行界面（CLI）显示游戏状态和交互，简单易用。
依赖安装：random 和 time 是 Python 标准库，无需额外安装。

2. 开发环境

确保已安装 Python（可从 python.org 下载）。推荐使用 Visual Studio Code 或 PyCharm 作为开发工具，提供代码补全和调试支持。本游戏无需图像或音频资源，保持轻量级设计。项目结构如下：

factory_simulation_game/
├── main.py           # 主程序入口
└── game.py           # 游戏逻辑模块

3. 游戏目标

玩家将管理一家工厂，从市场购买原材料，通过生产线加工成产品，并在市场上出售以赚取利润。游戏采用回合制，每回合玩家可以购买资源、设置生产水平并出售产品。目标是在 20 个回合内生产 100 辆汽车，同时保持资金平衡。游戏的挑战在于资源管理和生产效率的优化。

游戏设计与核心功能

1. 游戏结构

我们将游戏分解为多个模块，使用类和字典封装功能，确保代码清晰且易于维护。以下是核心设计：

Factory 类：管理工厂状态，包括资金、资源、生产线和产品。
生产线的定义：使用字典表示生产线，包含输入资源、输出产品和生产能力。
市场机制：通过字典定义固定价格（后续可扩展为动态价格）。
游戏循环：每回合提供菜单选项，处理玩家决策。

数据结构

资源：字典，键为资源名称（如“Iron ore”），值为数量。
产品：字典，键为产品名称（如“Cars”），值为数量。
生产线：字典，包含名称、输入资源、输出产品和生产能力。
市场：字典，包含购买和出售价格。

2. 核心代码实现

以下是游戏的完整代码框架，我们将逐一讲解每个部分的实现细节。

2.1 工厂类：Factory

Factory 类是游戏的核心，管理所有状态和逻辑。

# game.py
import time

class Factory:
    def __init__(self):
        # 初始化工厂状态
        self.money = 1000  # 初始资金
        self.resources = {"Iron ore": 0, "Coal": 0}  # 资源库存
        self.products = {"Steel": 0, "Cars": 0}  # 产品库存
        self.production_lines = [
            {
                "name": "Smelting",
                "input": {"Iron ore": 2, "Coal": 1},
                "output": {"Steel": 1},
                "capacity": 10
            },
            {
                "name": "Manufacturing",
                "input": {"Steel": 1},
                "output": {"Cars": 1},
                "capacity": 10
            }
        ]
        self.market = {
            "buy": {"Iron ore": 5, "Coal": 3},  # 购买价格
            "sell": {"Cars": 30}  # 出售价格
        }
        self.total_cars_produced = 0  # 累计生产的汽车数量
        self.turn = 0  # 当前回合数
        self.max_turns = 20  # 最大回合数

    def play(self):
        """游戏主循环"""
        print("欢迎来到《工厂大师》！你的目标是在 20 回合内生产 100 辆汽车。")
        while True:
            self.display_state()
            action = self.get_action()
            if action == "buy":
                self.buy_resources()
            elif action == "produce":
                self.set_production()
            elif action == "sell":
                self.sell_products()
            elif action == "end":
                self.end_turn()
            if self.check_win():
                print("恭喜！你成功生产了 100 辆汽车！")
                break
            if self.check_lose():
                print("游戏结束。你未能在 20 回合内生产 100 辆汽车。")
                break
            time.sleep(1)  # 回合间延迟

    def display_state(self):
        """显示当前工厂状态"""
        print(f"\n回合 {self.turn + 1}")
        print(f"资金: {self.money}")
        print("资源:")
        for res, qty in self.resources.items():
            print(f" - {res}: {qty}")
        print("产品:")
        for prod, qty in self.products.items():
            print(f" - {prod}: {qty}")
        print("生产线:")
        for line in self.production_lines:
            print(f" - {line['name']}: 产能 {line['capacity']} 单位/回合")

    def get_action(self):
        """获取玩家行动"""
        print("\n你想做什么？")
        print("1. 购买资源")
        print("2. 设置生产水平")
        print("3. 出售产品")
        print("4. 结束回合")
        choice = input("输入选项 (1-4): ")
        if choice == "1":
            return "buy"
        elif choice == "2":
            return "produce"
        elif choice == "3":
            return "sell"
        elif choice == "4":
            return "end"
        else:
            print("无效选项。")
            return self.get_action()

    def buy_resources(self):
        """购买资源"""
        print("\n购买资源:")
        for res, price in self.market["buy"].items():
            qty = int(input(f"购买多少 {res}（每单位 {price}）？ "))
            cost = qty * price
            if cost > self.money:
                print("资金不足。")
            else:
                self.resources[res] += qty
                self.money -= cost
                print(f"购买了 {qty} {res}，花费 {cost}。")

    def set_production(self):
        """设置生产线生产水平"""
        print("\n设置生产水平:")
        for line in self.production_lines:
            # 计算最大可生产数量，考虑资源和产能限制
            max_produce = min(line["capacity"], 
                            *[self.resources[res] // amt for res, amt in line["input"].items()])
            qty = int(input(f"{line['name']} 生产多少单位 (0-{max_produce})？ "))
            if qty > max_produce:
                print("无法生产那么多。")
            else:
                # 消耗资源
                for res, amt in line["input"].items():
                    self.resources[res] -= qty * amt
                # 生产产品
                for prod, amt in line["output"].items():
                    self.products[prod] += qty * amt
                    if line["name"] == "Manufacturing":
                        self.total_cars_produced += qty * amt
                print(f"{line['name']} 生产了 {qty} 单位。")

    def sell_products(self):
        """出售产品"""
        print("\n出售产品:")
        qty = int(input(f"出售多少辆汽车（每辆 {self.market['sell']['Cars']}）？ "))
        if qty > self.products["Cars"]:
            print("汽车数量不足。")
        else:
            revenue = qty * self.market["sell"]["Cars"]
            self.products["Cars"] -= qty
            self.money += revenue
            print(f"出售了 {qty} 辆汽车，收入 {revenue}。")

    def end_turn(self):
        """结束当前回合"""
        self.turn += 1

    def check_win(self):
        """检查胜利条件"""
        return self.total_cars_produced >= 100

    def check_lose(self):
        """检查失败条件"""
        return self.turn > self.max_turns

说明：

__init__：初始化工厂的资金、资源、生产线和市场。
play：游戏主循环，显示状态、处理行动并检查胜负。
display_state：显示当前资金、资源、产品和生产线信息。
get_action：提供交互菜单，返回玩家选择的行动。
buy_resources：根据市场价格购买资源，扣除资金。
set_production：根据资源和产能设置生产水平，更新库存。
sell_products：出售汽车，增加资金。
end_turn：推进回合计数。
check_win 和 check_lose：检查是否达成目标或超过回合限制。

2.2 主程序：main.py

启动游戏的入口文件。

# main.py
from game import Factory

if __name__ == "__main__":
    factory = Factory()
    factory.play()

运行游戏

1. 启动游戏

在项目目录下运行：

python main.py

2. 游戏流程

初始化：

玩家从 1000 单位资金开始，目标是 20 回合内生产 100 辆汽车。

每回合行动：

显示状态：查看资金、资源和产品。
购买资源：从市场购买铁矿石和煤。
设置生产：调整冶炼和制造线的生产水平。
出售产品：出售汽车赚取资金。
结束回合：推进到下一回合。

游戏结束：

生产 100 辆汽车则胜利，超过 20 回合未完成则失败。

3. 示例运行

欢迎来到《工厂大师》！你的目标是在 20 回合内生产 100 辆汽车。

回合 1
资金: 1000
资源:
 - Iron ore: 0
 - Coal: 0
产品:
 - Steel: 0
 - Cars: 0
生产线:
 - Smelting: 产能 10 单位/回合
 - Manufacturing: 产能 10 单位/回合

你想做什么？
1. 购买资源
2. 设置生产水平
3. 出售产品
4. 结束回合
输入选项 (1-4): 1

购买资源:
购买多少 Iron ore（每单位 5）？ 20
购买了 20 Iron ore，花费 100。
购买多少 Coal（每单位 3）？ 10
购买了 10 Coal，花费 30。

回合 1
资金: 870
资源:
 - Iron ore: 20
 - Coal: 10
产品:
 - Steel: 0
 - Cars: 0
生产线:
 - Smelting: 产能 10 单位/回合
 - Manufacturing: 产能 10 单位/回合

你想做什么？
1. 购买资源
2. 设置生产水平
3. 出售产品
4. 结束回合
输入选项 (1-4): 2

设置生产水平:
Smelting 生产多少单位 (0-10)？ 10
Smelting 生产了 10 单位。
Manufacturing 生产多少单位 (0-10)？ 10
Manufacturing 生产了 10 单位。

回合 1
资金: 870
资源:
 - Iron ore: 0
 - Coal: 0
产品:
 - Steel: 0
 - Cars: 10
生产线:
 - Smelting: 产能 10 单位/回合
 - Manufacturing: 产能 10 单位/回合

你想做什么？
1. 购买资源
2. 设置生产水平
3. 出售产品
4. 结束回合
输入选项 (1-4): 3

出售产品:
出售多少辆汽车（每辆 30）？ 10
出售了 10 辆汽车，收入 300。

回合 1
资金: 1170
资源:
 - Iron ore: 0
 - Coal: 0
产品:
 - Steel: 0
 - Cars: 0
生产线:
 - Smelting: 产能 10 单位/回合
 - Manufacturing: 产能 10 单位/回合

你想做什么？
1. 购买资源
2. 设置生产水平
3. 出售产品
4. 结束回合
输入选项 (1-4): 4

分析：

第一回合中，玩家花费 130 单位资金购买了 20 单位铁矿石和 10 单位煤。
使用冶炼线生产了 10 单位钢材（消耗所有资源），然后制造了 10 辆汽车。
出售 10 辆汽车赚了 300 单位资金，净赚 170。
每回合重复此过程，10 回合可生产 100 辆汽车。

游戏机制详解

1. 资源与生产链

资源：

铁矿石（Iron ore）：每单位 5 资金。
煤（Coal）：每单位 3 资金。

生产链：

冶炼（Smelting）：2 铁矿石 + 1 煤 → 1 钢材，产能 10。
制造（Manufacturing）：1 钢材 → 1 汽车，产能 10。

产品：

钢材（Steel）：中间产品，不出售。
汽车（Cars）：最终产品，每辆 30 资金。

2. 经济计算

生产一辆汽车的成本：

1 钢材 = 2 铁矿石 (10) + 1 煤 (3) = 13 资金。
1 汽车 = 1 钢材 = 13 资金。
出售价格 30，利润 17。

每回合最大利润：

生产 10 辆汽车，成本 130，收入 300，利润 170。

3. 游戏挑战

资源平衡：确保有足够的铁矿石和煤支持生产。
资金管理：避免资金耗尽。
时间限制：20 回合内完成目标。

游戏扩展与优化

当前版本是一个基础原型，我们可以通过以下方式增强游戏性、技术实现和深度。

1. 游戏性增强

动态市场：

价格随供需波动，例如大量购买铁矿石后价格上涨。

生产线升级：

花费资金提升产能（如从 10 到 15）。

随机事件：

资源短缺或市场需求增加。

示例代码：动态市场

def update_market(self):
    for res in self.market["buy"]:
        self.market["buy"][res] += random.randint(-1, 1)  # 价格波动
        self.market["buy"][res] = max(1, self.market["buy"][res])  # 最低价格为 1
    self.market["sell"]["Cars"] += random.randint(-5, 5)
    self.market["sell"]["Cars"] = max(10, self.market["sell"]["Cars"])

# 在 end_turn 中调用
def end_turn(self):
    self.turn += 1
    self.update_market()
    print("市场价格已更新！")

2. 技术优化

图形界面：

使用 pygame 显示资源和生产状态。

数据可视化：

使用 matplotlib 绘制资金和生产曲线。

存档功能：

保存游戏状态到文件。

示例代码：简单 Pygame 界面

import pygame

class FactoryWithGUI(Factory):
    def __init__(self):
        super().__init__()
        pygame.init()
        self.screen = pygame.display.set_mode((800, 600))
        pygame.display.set_caption("工厂大师")
        self.font = pygame.font.Font(None, 36)

    def display_state(self):
        self.screen.fill((0, 0, 0))
        y = 50
        text = self.font.render(f"回合 {self.turn + 1}  资金: {self.money}", True, (255, 255, 255))
        self.screen.blit(text, (50, y))
        y += 50
        for res, qty in self.resources.items():
            text = self.font.render(f"{res}: {qty}", True, (255, 255, 255))
            self.screen.blit(text, (50, y))
            y += 50
        pygame.display.flip()

    def play(self):
        print("欢迎来到《工厂大师》！")
        running = True
        while running:
            self.display_state()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
            # Integrate CLI inputs with GUI or replace with buttons

3. 经营深度

工人系统：

雇佣工人，影响生产效率。

维护成本：

生产线运行需支付费用。

多产品线：

添加新资源（如橡胶）和产品（如轮胎）。

游戏策略与玩法分析

1. 玩家策略

资源采购：根据生产需求购买，避免库存积压。
生产优化：平衡冶炼和制造，确保无资源浪费。
资金规划：保留足够资金应对未来回合。

2. 平衡性

初始资金：1000 足够启动，但需谨慎管理。
生产能力：10 单位/回合限制了单回合产出。
时间限制：20 回合需要至少 10 回合满产。

3. 重玩价值

可调整目标（如 200 辆汽车）或市场条件。
添加随机性增加变化。

总结与未来展望

通过这篇博文，您已经成功构建了一个模拟工厂游戏 工厂大师！这个项目展示了如何使用 Python 创建一个经营类游戏，涵盖资源管理、生产链和经济策略。以下是回顾和未来方向：

1. 收获

掌握了 Python OOP 设计和游戏开发基础。
实现了资源管理、生产优化和经济系统。
提供了一个可玩的原型，展示了工厂模拟的魅力。

2. 未来扩展

图形化：使用 Pygame 创建可视化界面。
动态经济：实现供需驱动的价格系统。
多人模式：支持玩家合作或竞争经营工厂。
教育模块：融入工业管理和经济学知识。

3. 动手实践

快去运行代码，管理您的工厂吧！您可以尝试：

调整价格和产能，优化策略。
添加新生产线，丰富生产链。
实现图形界面，提升体验。

希望这篇教程为您打开了模拟工厂游戏开发的大门！如果您有任何疑问或想深入某部分，欢迎留言，我将进一步完善内容。祝您编程愉快，享受经营工厂的乐趣！

附录：完整代码

以下是整合后的完整代码，分为 game.py 和 main.py，可直接运行。

game.py

import time

class Factory:
    def __init__(self):
        self.money = 1000
        self.resources = {"Iron ore": 0, "Coal": 0}
        self.products = {"Steel": 0, "Cars": 0}
        self.production_lines = [
            {
                "name": "Smelting",
                "input": {"Iron ore": 2, "Coal": 1},
                "output": {"Steel": 1},
                "capacity": 10
            },
            {
                "name": "Manufacturing",
                "input": {"Steel": 1},
                "output": {"Cars": 1},
                "capacity": 10
            }
        ]
        self.market = {
            "buy": {"Iron ore": 5, "Coal": 3},
            "sell": {"Cars": 30}
        }
        self.total_cars_produced = 0
        self.turn = 0
        self.max_turns = 20

    def play(self):
        print("欢迎来到《工厂大师》！你的目标是在 20 回合内生产 100 辆汽车。")
        while True:
            self.display_state()
            action = self.get_action()
            if action == "buy":
                self.buy_resources()
            elif action == "produce":
                self.set_production()
            elif action == "sell":
                self.sell_products()
            elif action == "end":
                self.end_turn()
            if self.check_win():
                print("恭喜！你成功生产了 100 辆汽车！")
                break
            if self.check_lose():
                print("游戏结束。你未能在 20 回合内生产 100 辆汽车。")
                break
            time.sleep(1)

    def display_state(self):
        print(f"\n回合 {self.turn + 1}")
        print(f"资金: {self.money}")
        print("资源:")
        for res, qty in self.resources.items():
            print(f" - {res}: {qty}")
        print("产品:")
        for prod, qty in self.products.items():
            print(f" - {prod}: {qty}")
        print("生产线:")
        for line in self.production_lines:
            print(f" - {line['name']}: 产能 {line['capacity']} 单位/回合")

    def get_action(self):
        print("\n你想做什么？")
        print("1. 购买资源")
        print("2. 设置生产水平")
        print("3. 出售产品")
        print("4. 结束回合")
        choice = input("输入选项 (1-4): ")
        if choice == "1":
            return "buy"
        elif choice == "2":
            return "produce"
        elif choice == "3":
            return "sell"
        elif choice == "4":
            return "end"
        else:
            print("无效选项。")
            return self.get_action()

    def buy_resources(self):
        print("\n购买资源:")
        for res, price in self.market["buy"].items():
            qty = int(input(f"购买多少 {res}（每单位 {price}）？ "))
            cost = qty * price
            if cost > self.money:
                print("资金不足。")
            else:
                self.resources[res] += qty
                self.money -= cost
                print(f"购买了 {qty} {res}，花费 {cost}。")

    def set_production(self):
        print("\n设置生产水平:")
        for line in self.production_lines:
            max_produce = min(line["capacity"], 
                            *[self.resources[res] // amt for res, amt in line["input"].items()])
            qty = int(input(f"{line['name']} 生产多少单位 (0-{max_produce})？ "))
            if qty > max_produce:
                print("无法生产那么多。")
            else:
                for res, amt in line["input"].items():
                    self.resources[res] -= qty * amt
                for prod, amt in line["output"].items():
                    self.products[prod] += qty * amt
                    if line["name"] == "Manufacturing":
                        self.total_cars_produced += qty * amt
                print(f"{line['name']} 生产了 {qty} 单位。")

    def sell_products(self):
        print("\n出售产品:")
        qty = int(input(f"出售多少辆汽车（每辆 {self.market['sell']['Cars']}）？ "))
        if qty > self.products["Cars"]:
            print("汽车数量不足。")
        else:
            revenue = qty * self.market["sell"]["Cars"]
            self.products["Cars"] -= qty
            self.money += revenue
            print(f"出售了 {qty} 辆汽车，收入 {revenue}。")

    def end_turn(self):
        self.turn += 1

    def check_win(self):
        return self.total_cars_produced >= 100

    def check_lose(self):
        return self.turn > self.max_turns

main.py

from game import Factory

if __name__ == "__main__":
    factory = Factory()
    factory.play()