项目代码:https://github.com/yicongl1/Machikoro

MachiKoro(街角小吃店)是个很适合练面向对象的题目:规则不算复杂,但卡牌类型多、触发时机分散,而且每一种卡的效果都不一样。用 if/else 硬写当然能跑,但很快就会变成一坨难以维护的分支。

这篇记录我们怎么把规则拆成对象,以及事后回看时觉得哪里还能更好。

规则先拆成“谁在什么时候做什么”

一个回合可以简化成:

掷骰 → 收入结算(红 → 蓝/绿 → 紫)→ 建造 1 张建筑
  • 红卡:其他玩家付钱给卡主(咖啡馆、家庭餐厅)
  • 蓝卡:所有拥有该卡的玩家收钱(麦田、牧场、森林、矿场、苹果园)
  • 绿卡:当前玩家收钱,部分卡按图标数量加倍(面包店、奶酪工厂等)
  • 紫卡:当前玩家对其他人收钱或交换(体育场、电视台、商业中心)
  • 黄卡:四座地标,改变规则本身(火车站、商业中心、游乐园、广播塔)

结算顺序不是随便定的:红卡要在蓝卡之前,因为红卡会先把钱从别人手里拿走;紫卡放在最后,因为它可能改变手牌或金币。规则里的顺序就是代码里的调用顺序。

一个基类,五种颜色

所有卡共有的东西放进 Card:名字、价格、收益、点数区间、图标、颜色。

class Card {
public:
    virtual ~Card() = default;
    virtual void action(Bank *p1, Bank *p2, Card *c1, Card *c2, int val) = 0;

    void set_card(string name, int cost, int value,
                  int low_roll, int high_roll, Icon icon, Color color);

    int get_value();
    int get_cost();
    Color get_color();
    Icon get_icon();
    int get_low_roll();
    int get_high_roll();
    // ...
private:
    int low_roll = 0;
    int high_roll = 0;
    int cost = 0;
    int value = 0;
    Color color = Color::blue;
    Icon icon = Icon::none;
    string name;
};

action() 是纯虚函数,五种子类各自实现。新增一张卡,只需要写一个构造函数和(必要时)一个 action(),主流程不用动。

蓝卡:最简单的多态

void BlueCard::action(Bank *p1, Bank *p2, Card *c1, Card *c2, int val) {
    p1->deposit(this->get_value());
}

蓝卡只关心“谁收钱”,p2、c1、c2、val 都用不上。

绿卡:倍率与地标加成

void GreenCard::action(Bank *p1, Bank *p2, Card *c1, Card *c2, int val) {
    int bonus = 0;
    if (c1 != NULL) bonus = 1;   // 拥有 Shopping Mall
    if (this->multiplier == Icon::none) {
        p1->deposit(this->get_value() + bonus);
    } else {
        p1->deposit(this->get_value() * val + bonus);
    }
}

val 不是骰子点数,而是“场上该图标出现的数量”。奶酪工厂按牛的数量算钱,家具工厂按齿轮,果蔬市场按谷物。这个数量由 Game 在结算前数好传进来,卡牌本身不遍历全场。

红卡:从别人口袋里拿钱

void RedCard::action(Bank *p1, Bank *p2, Card *c1, Card *c2, int val) {
    int bonus = 0;
    if (c1 != NULL) bonus = 1;
    p1->deposit(p2->withdraw(this->get_value() + bonus));
}

p1 是卡主,p2 是当前掷骰的玩家。Bank::withdraw() 在余额不足时返回实际扣除的数量,不会让金币凭空消失:

int Bank::withdraw(int val) {
    if (val <= 0) return 0;
    if (val > this->coins) {
        int temp = this->coins;
        this->coins = 0;
        return temp;
    }
    this->coins -= val;
    return val;
}

紫卡:规则复杂到要交给 Game

体育场和电视台可以复用“从别人扣钱”的逻辑,但商业中心需要玩家选择交换对象和卡牌,卡牌自己没法弹交互。所以 BusinessCenter::action() 是空的,由 Game::business_center_effect() 接管:

void Game::purple_card_check() {
    if (this->dice == 6) {
        player* p = this->players[this->turn];
        for (Card* card : p->purple_cards) {
            if (Stadium* stadium = dynamic_cast<Stadium*>(card)) {
                // 向除自己以外的每个玩家收钱
            } else if (TVStation* tv = dynamic_cast<TVStation*>(card)) {
                this->tv_station_effect(tv);
            } else if (BusinessCenter* bc = dynamic_cast<BusinessCenter*>(card)) {
                this->business_center_effect(bc);
            }
        }
    }
    this->buy_propery();
}

这里用 dynamic_cast 而不是比较卡名。早期版本用 get_name() == "Stadium" 判断,名字一改效果就静默失效——能用类型表达的东西,不要用字符串。

结算流水线

Game::roll_dice() 负责整个回合的前半段:

  1. 发牌、打印市场与当前玩家
  2. 有火车站时选 1 或 2 颗骰子
  3. 掷骰;有广播塔且点数 ≤ 4 时重掷一次
  4. 依次调用 red_card_check() → blue_card_check() → green_card_check() → purple_card_check()

每个 *_check() 只做两件事:判断点数是否落在卡的区间里,命中就调用 action()。卡牌不关心自己是怎么被找到的,Game 也不关心卡牌具体怎么结算。

for (RedCard* card : owner->red_cards) {
    if (dice >= card->get_low_roll() && dice <= card->get_high_roll()) {
        card->action(owner->bank, current->bank, mall, nullptr, 0);
    }
}

牌堆、单例与玩家

Deck 的构造函数集中创建所有卡牌,相当于一个简单工厂:

Deck::Deck() {
    Card* c;
    for (int i = 0; i < 6; i++) { c = new WheatField();  deck.push_back(c); }
    for (int i = 0; i < 6; i++) { c = new Ranch();       deck.push_back(c); }
    // ... 15 种建筑,按官方数量创建
    shuffle();
}

Game 用单例保证全局只有一份游戏状态;player 按颜色维护五个 vector,每种卡只进对应的容器。这样结算时不用遍历“所有卡再判断颜色”,直接遍历对应容器。

回看:action() 的参数其实是一个没定义的上下文对象

action(Bank*, Bank*, Card*, Card*, int) 能跑,但每个参数的含义只存在于注释和记忆里:

  • p1 收钱,p2 付钱
  • c1 非空表示购物中心加成
  • c2 目前没用
  • val 是图标数量

这就是典型的“参数太多,其实该建一个结构体”:

struct SettlementContext {
    Bank* receiver;
    Bank* payer;
    bool has_shopping_mall;
    int icon_count;
};

如果重做,我会把 c2 删掉,把 val 改名成 icon_count,再让 action(const SettlementContext&) 只接收它真正需要的字段。这样读代码的人不需要先读一遍 README。

另一个可以改的地方是地标的下标:

enum YellowSlot {
    TRAIN_STATION = 0,
    SHOPPING_MALL = 1,
    AMUSEMENT_PARK = 2,
    RADIO_TOWER = 3
};

四个地标固定放在 yellow_cards 的四个位置,简单直接,但一旦顺序变化就会全盘出错。更稳的做法是用 map<Landmark, YellowCard*>,或者干脆给每个地标一个独立成员。

小结

这个项目最重要的不是“用了多态”,而是把规则里的变化点放进了类型系统:

  • 卡牌效果 → 虚函数
  • 卡牌颜色 → 子类 + 独立容器
  • 结算阶段 → 固定的调用顺序
  • 地标状态 → active 标志 + 明确的槽位

规则会变,卡牌会加,但主循环可以保持不变。这是面向对象在这个题目里真正有用的地方。