声明：枪战暂不能运行，正在修复； 其余游戏在Embarcadero Dev-C++6.3能正常运行； 如果出现问题，请检查代码是否因为字体之类的原因丢失与调整过配置（如加了什么东西）； 运行时请自动调整英文； 可能稍有卡顿； 枪战小游戏:

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <map>
#include <windows.h>
#include <algorithm>
#include <iomanip>

using namespace std;

// 武器类型枚举（新增轻机枪和射手步枪）
enum WeaponType {
    PISTOL,
    SNIPER,
    MELEE,
    LAUNCHER,
    ASSAULT_RIFLE,
    LIGHT_MACHINE_GUN,  // 轻机枪
    MARKSMAN_RIFLE      // 射手步枪
};

// 武器属性结构体
struct WeaponStats {
    string name;
    WeaponType type;
    int damage;
    int fireRate; // 每分钟射速(近战武器为攻击速度)
    float accuracy; // 0-1的精度值
    float mobility; // 0-1的机动性
    int range; // 有效射程(米)
    float control; // 0-1的控制性
    int price;
    int ammoCapacity;
    bool isOneShotKill; // 是否一击必杀(近战武器和部分狙击枪)
};
// 更新日志类
class UpdateLog {
private:
    vector<pair<string, string>> logEntries;

public:
    UpdateLog() {
        logEntries = {
            {"0.0.1", "初始版本，写出初始内容，构建基础框架"},
            {"0.1.0", "枪械大更新版本！增加商店，玩家击杀敌人可以获得金币，金币购买武器\n"
                      "新增武器与类型:\n"
                      "突击步枪:Type25，M16，AK117，AK47，AN94，M4，AKBP，G37，ICR，Man0War，KN44，HBR3，HVK30，DRH，DRMK2，ASVAL，CR56，M13，Swordfish，kilo141，ODEN，Krin6，EM2，FFAR1，Grau5.56，Groza，Type19，BP50，LAG53，FR556，Maddox，XM4，Vargo-S\n"
                      "为武器增加属性:伤害，射速，精准度，机动性，射程，控制"},
            {"0.1.0.1", "增加狙击枪:\n"
                        "XPR50，Arctic50，M21EBR，DLQ33，Locus，NA45，Outlaw，AMR，SVD，Koshka，ZRG20mm，HDR，LW3-Tundra\n"
                        "手枪:冲锋手枪，J358，MW11，50GS，Renetti，Shorty，十字弓，L-CAG9，Dobvra，钉枪\n"
                        "近战武器（攻击秒杀但射程超短）:战术刀，战术近战，军用斧，军用铲，棒球棍，双截棍，武士刀，拳套，扳手，镰刀，弯刀，藤棍，蝴蝶刀，钗，弹道刀，长枪，爪刀，荧光棒，冰稿，突击匕首，长剑\n"
                        "发射器:FHJ18毒刺，SMR4，Thumper，D13sector"},
            {"0.1.0.2", "新增武器类型和多种武器：\n"
                        "轻机枪: MG42，S36，SA80，RPD，M4LMG，Chopper，Holger26，Hades，PKM，Dingo，Bruenmk9，RAALMG\n"
                        "射手步枪: Kar98K，SKS，SPR208，MK2，Type63，M1Garand\n"
                        "添加操作说明到游戏界面\n"
                        "更新版本日志系统"}
        };
    }

    void displayLog() {
        system("cls");
        cout << "========== 更新日志 ==========\n";
        for (const auto& entry : logEntries) {
            cout << "版本 " << entry.first << ":\n";
            cout << entry.second << "\n\n";
        }
        cout << "==============================\n";
        cout << "按任意键返回...";
        cin.ignore();
        cin.get();
    }
};
// 玩家类
class Player {
private:
    int health;
    map<WeaponType, WeaponStats> weapons;
    WeaponType currentWeaponType;
    int ammo;
    bool isAlive;
    int kills;
    int gold;
    
public:
    Player() : health(100), isAlive(true), kills(0), gold(0) {
        // 初始武器
        weapons[PISTOL] = {"MW11", PISTOL, 35, 450, 0.7f, 0.8f, 20, 0.75f, 0, 12, false};
        weapons[MELEE] = {"战术刀", MELEE, 100, 120, 1.0f, 0.9f, 2, 1.0f, 0, 1, true};
        currentWeaponType = PISTOL;
        ammo = weapons[currentWeaponType].ammoCapacity;
    }
    
    void shoot(Player& target) {
        if (ammo <= 0 && weapons[currentWeaponType].type != MELEE) {
            cout << "弹药用尽，无法射击！\n";
            return;
        }
        
        if (weapons[currentWeaponType].type != MELEE) {
            ammo--;
        }
        
        int baseDamage = weapons[currentWeaponType].damage;
        float accuracyFactor = weapons[currentWeaponType].accuracy;
        int finalDamage = baseDamage;
        
        if (!weapons[currentWeaponType].isOneShotKill) {
            finalDamage = baseDamage * accuracyFactor + (rand() % (int)(baseDamage * (1 - accuracyFactor)));
        }
        
        target.takeDamage(finalDamage);
        
        cout << "你使用" << weapons[currentWeaponType].name << (weapons[currentWeaponType].type == MELEE ? "近战攻击" : "射击") 
             << "了敌人，造成 " << finalDamage << " 点伤害！\n";
    }
    
    void takeDamage(int damage) {
        health -= damage;
        if (health <= 0) {
            health = 0;
            isAlive = false;
        }
    }
    
    void reload() {
        if (weapons[currentWeaponType].type == MELEE) {
            cout << "近战武器无需装弹！\n";
            return;
        }
        ammo = weapons[currentWeaponType].ammoCapacity;
        cout << "重新装弹！弹药恢复为" << ammo << "发。\n";
    }
    
    void heal() {
        health += 25;
        if (health > 100) health = 100;
        cout << "使用医疗包，恢复25点生命值。\n";
    }
    
    void addKill() {
        kills++;
        gold += 100 + (rand() % 50);
        cout << "击杀敌人！获得" << (gold - (kills-1)*100) << "金币。当前金币: " << gold << "\n";
    }
    
    bool purchaseWeapon(const WeaponStats& weapon) {
        if (gold >= weapon.price) {
            gold -= weapon.price;
            weapons[weapon.type] = weapon;
            cout << "成功购买 " << weapon.name << "！\n";
            return true;
        }
        cout << "金币不足，无法购买 " << weapon.name << "。\n";
        return false;
    }
    
    void equipWeapon(WeaponType type) {
        if (weapons.find(type) != weapons.end()) {
            currentWeaponType = type;
            ammo = weapons[type].ammoCapacity;
            cout << "已装备 " << weapons[type].name << "\n";
        } else {
            cout << "你还没有这种武器！\n";
        }
    }
    
    bool hasWeaponType(WeaponType type) const {
        return weapons.find(type) != weapons.end();
    }
    
    int getHealth() const { return health; }
    int getAmmo() const { return ammo; }
    bool alive() const { return isAlive; }
    int getKills() const { return kills; }
    int getGold() const { return gold; }
    WeaponStats getCurrentWeapon() const { return weapons.at(currentWeaponType); }
    map<WeaponType, WeaponStats> getAllWeapons() const { return weapons; }
};
// 武器商店类
 class WeaponStore {
 private:
     map weapons;
string getTypeName(WeaponType type) {
    switch(type) {
        case PISTOL: return "手枪";
        case SNIPER: return "狙击枪";
        case MELEE: return "近战武器";
        case LAUNCHER: return "发射器";
        case ASSAULT_RIFLE: return "突击步枪";
        case LIGHT_MACHINE_GUN: return "轻机枪";
        case MARKSMAN_RIFLE: return "射手步枪";
        default: return "未知";
    }
}
public:
     WeaponStore() {
         // 手枪
         weapons["冲锋手枪"] = {"冲锋手枪", PISTOL, 30, 600, 0.65f, 0.85f, 15, 0.7f, 800, 15, false};
         weapons["J358"] = {"J358", PISTOL, 75, 150, 0.8f, 0.75f, 25, 0.6f, 1200, 6, false};
         weapons["MW11"] = {"MW11", PISTOL, 35, 450, 0.7f, 0.8f, 20, 0.75f, 0, 12, false};
         weapons["50GS"] = {"50GS", PISTOL, 90, 120, 0.75f, 0.7f, 30, 0.5f, 1500, 7, false};
         weapons["Renetti"] = {"Renetti", PISTOL, 40, 500, 0.78f, 0.82f, 18, 0.8f, 1000, 12, false};
         weapons["Shorty"] = {"Shorty", PISTOL, 120, 60, 0.6f, 0.9f, 8, 0.4f, 1800, 2, false};
         weapons["十字弓"] = {"十字弓", PISTOL, 150, 40, 0.95f, 0.6f, 30, 0.7f, 2000, 1, true};
         weapons["L-CAG9"] = {"L-CAG9", PISTOL, 25, 700, 0.68f, 0.88f, 12, 0.75f, 900, 20, false};
   weapons["Dobvra"] = {"Dobvra", PISTOL, 80, 100, 0.85f, 0.65f, 28, 0.55f, 1600, 5, false};
         weapons["钉枪"] = {"钉枪", PISTOL, 60, 200, 0.9f, 0.7f, 15, 0.9f, 1700, 6, false};
    // 狙击枪
    weapons["XPR50"] = {"XPR50", SNIPER, 120, 60, 0.9f, 0.4f, 100, 0.7f, 2500, 6, false};
    weapons["Arctic50"] = {"Arctic50", SNIPER, 150, 50, 0.92f, 0.35f, 120, 0.65f, 2800, 5, true};
    weapons["M21EBR"] = {"M21EBR", SNIPER, 90, 80, 0.88f, 0.5f, 90, 0.75f, 2300, 10, false};
    weapons["DLQ33"] = {"DLQ33", SNIPER, 180, 40, 0.95f, 0.3f, 150, 0.6f, 3000, 5, true};
    weapons["Locus"] = {"Locus", SNIPER, 160, 45, 0.93f, 0.35f, 140, 0.62f, 2900, 6, true};
    weapons["NA45"] = {"NA45", SNIPER, 200, 30, 0.85f, 0.25f, 200, 0.5f, 3200, 2, true};
    weapons["Outlaw"] = {"Outlaw", SNIPER, 140, 55, 0.91f, 0.4f, 110, 0.68f, 2700, 6, false};
    weapons["AMR"] = {"AMR", SNIPER, 250, 20, 0.96f, 0.2f, 180, 0.4f, 3500, 3, true};
    weapons["SVD"] = {"SVD", SNIPER, 110, 70, 0.87f, 0.45f, 95, 0.72f, 2600, 8, false};
    weapons["Koshka"] = {"Koshka", SNIPER, 170, 42, 0.94f, 0.32f, 130, 0.58f, 2950, 5, true};
    weapons["ZRG20mm"] = {"ZRG20mm", SNIPER, 300, 15, 0.97f, 0.15f, 220, 0.3f, 3800, 2, true};
    weapons["HDR"] = {"HDR", SNIPER, 190, 38, 0.96f, 0.28f, 160, 0.55f, 3100, 4, true};
    weapons["LW3-Tundra"] = {"LW3-Tundra", SNIPER, 175, 40, 0.95f, 0.3f, 140, 0.6f, 3050, 5, true};

    // 近战武器
    weapons["战术刀"] = {"战术刀", MELEE, 100, 120, 1.0f, 0.9f, 2, 1.0f, 0, 1, true};
    weapons["战术近战"] = {"战术近战", MELEE, 100, 110, 1.0f, 0.92f, 2, 1.0f, 500, 1, true};
    weapons["军用斧"] = {"军用斧", MELEE, 100, 90, 1.0f, 0.85f, 2, 0.95f, 600, 1, true};
    weapons["军用铲"] = {"军用铲", MELEE, 100, 100, 0.98f, 0.8f, 2, 0.9f, 550, 1, true};
    weapons["棒球棍"] = {"棒球棍", MELEE, 100, 95, 0.95f, 0.88f, 2, 0.92f, 450, 1, true};
    weapons["双截棍"] = {"双截棍", MELEE, 100, 130, 0.9f, 0.95f, 2, 0.85f, 700, 1, true};
    weapons["武士刀"] = {"武士刀", MELEE, 100, 105, 1.0f, 0.93f, 2, 0.98f, 800, 1, true};
    weapons["拳套"] = {"拳套", MELEE, 100, 140, 0.85f, 1.0f, 1, 0.8f, 400, 1, true};
    weapons["扳手"] = {"扳手", MELEE, 100, 100, 0.95f, 0.85f, 2, 0.9f, 350, 1, true};
    weapons["镰刀"] = {"镰刀", MELEE, 100, 110, 0.98f, 0.87f, 2, 0.95f, 750, 1, true};
    weapons["弯刀"] = {"弯刀", MELEE, 100, 115, 0.99f, 0.9f, 2, 0.95f, 700, 1, true};
}

// 显示商店所有武器
void displayAllWeapons() {
    system("cls");
    cout << "========== 武器商店 ==========\n";

    // 手枪
    cout << "【手枪】\n";
    for (const auto& weapon : weapons) {
        if (weapon.second.type == PISTOL) {
            displayWeapon(weapon.second);
        }
    }

    // 狙击枪
    cout << "\n【狙击枪】\n";
    for (const auto& weapon : weapons) {
        if (weapon.second.type == SNIPER) {
            displayWeapon(weapon.second);
        }
    }

    // 近战武器
    cout << "\n【近战武器】\n";
    for (const auto& weapon : weapons) {
        if (weapon.second.type == MELEE) {
            displayWeapon(weapon.second);
        }
    }

    // 其他武器类型...
    cout << "\n输入武器名称购买，或输入'back'返回: ";
}

// 显示单个武器信息
void displayWeapon(const WeaponStats& weapon) {
    cout << "名称: " << weapon.name << "\n"
         << "类型: " << getTypeName(weapon.type) << "\n"
         << "伤害: " << weapon.damage << "\n"
         << "射速: " << weapon.fireRate << "\n"
         << "精度: " << weapon.accuracy << "\n"
         << "价格: " << weapon.price << "金币\n\n";
}

// 购买武器
bool buyWeapon(Player& player, const string& weaponName) {
    auto it = weapons.find(weaponName);
    if (it == weapons.end()) {
        cout << "武器不存在！\n";
        return false;
    }

    if (player.getGold() < it->second.price) {
        cout << "金币不足！\n";
        return false;
    }

    if (player.hasWeaponType(it->second.type)) {
        cout << "你已经拥有该类型的武器！\n";
        return false;
    }

    // 添加武器到玩家库存
    player.purchaseWeapon(it->second);
    cout << "购买成功！\n";
    return true;
}
};
// 继续武器商店类...
    
    // 显示商店日志
    void displayLog() {
        system("cls");
        cout << "========== 商店日志 ==========\n";
        cout << "1. 新增武器类型：轻机枪、射手步枪\n";
        cout << "2. 优化了武器购买逻辑\n";
        cout << "3. 添加了武器类型检查\n";
        cout << "============================\n";
        cout << "按任意键返回...";
        cin.ignore();
        cin.get();
    }
    
    // 获取武器信息（用于其他功能）
    WeaponStats getWeaponInfo(const string& name) {
        auto it = weapons.find(name);
        if (it != weapons.end()) {
            return it->second;
        }
        return {"不存在", PISTOL, 0, 0, 0, 0, 0, 0, 0, 0, false};
    }
};
// 主游戏类
class Game {
private:
    Player player;
    WeaponStore store;
    UpdateLog log;
    bool isRunning;
    
public:
    Game() : isRunning(true) {}
    
    void start() {
        system("cls");
        cout << "========== 欢迎来到枪战游戏 ==========\n";
        cout << "1. 开始游戏\n";
        cout << "2. 查看更新日志\n";
        cout << "3. 退出游戏\n";
        cout << "请选择: ";
        
        int choice;
        cin >> choice;
        
        switch(choice) {
            case 1:
                startGame();
                break;
            case 2:
                log.displayLog();
                start(); // 返回主菜单
                break;
            case 3:
                isRunning = false;
                break;
            default:
                cout << "无效选择！\n";
                start(); // 重新显示菜单
        }
    }
    
    void startGame() {
        system("cls");
        cout << "游戏开始！\n";
        
        // 游戏主循环
        while(isRunning && player.alive()) {
            // 显示玩家状态
            displayPlayerStatus();
            
            // 玩家行动
            playerAction();
            
            // 敌人行动（简化版）
            enemyAction();
            
            // 检查游戏结束条件
            checkGameEnd();
        }
        
        if(!player.alive()) {
            cout << "游戏结束！你被击败了。\n";
            cout << "最终击杀数: " << player.getKills() << "\n";
            cout << "获得金币: " << player.getGold() << "\n";
        }
    }
    
    void displayPlayerStatus() {
        system("cls");
        cout << "========== 玩家状态 ==========\n";
        cout << "生命值: " << player.getHealth() << "\n";
        cout << "金币: " << player.getGold() << "\n";
        cout << "击杀数: " << player.getKills() << "\n";
        cout << "当前武器: " << player.getCurrentWeapon().name << "\n";
        cout << "弹药: " << player.getAmmo() << "/" << player.getCurrentWeapon().ammoCapacity << "\n";
        cout << "============================\n";
        cout << "1. 攻击\n2. 装弹\n3. 治疗\n4. 商店\n5. 更换武器\n6. 结束回合\n";
        cout << "请选择: ";
    }
    
    void playerAction() {
        int choice;
        cin >> choice;
        
        switch(choice) {
            case 1:
                // 攻击逻辑
                if(player.getCurrentWeapon().type == MELEE) {
                    player.shoot(player); // 近战攻击（这里简化为攻击自己，实际应攻击敌人）
                } else {
                    // 实际游戏中这里应该攻击敌人
                    cout << "攻击敌人！\n";
                }
                break;
            case 2:
                player.reload();
                break;
            case 3:
                player.heal();
                break;
            case 4:
                openStore();
                break;
            case 5:
                changeWeapon();
                break;
            case 6:
                // 结束回合
                break;
            default:
                cout << "无效选择！\n";
        }
    }
    
    void openStore() {
        system("cls");
        store.displayAllWeapons();
        
        string weaponName;
        cin >> weaponName;
        
        if(weaponName == "back") {
            return;
        }
        
        store.buyWeapon(player, weaponName);
    }
    
    void changeWeapon() {
        system("cls");
        cout << "可用的武器:\n";
        
        int index = 1;
        for(const auto& weapon : player.getAllWeapons()) {
            if(weapon.first != MELEE || player.getCurrentWeapon().type != MELEE) { // 避免重复显示近战武器
                cout << index << ". " << weapon.second.name << " (" << getTypeName(weapon.first) << ")\n";
                index++;
            }
        }
        
        cout << "选择武器编号: ";
        int choice;
        cin >> choice;
        
        // 实际游戏中这里应该有武器列表索引逻辑
        // 简化处理：直接装备第一把武器
        if(!player.getAllWeapons().empty()) {
            auto it = player.getAllWeapons().begin();
            player.equipWeapon(it->first);
        }
    }
    
    void enemyAction() {
        // 简化的敌人AI
        cout << "敌人行动...\n";
        
        // 随机攻击或装弹
        int action = rand() % 2;
        if(action == 0) {
            // 攻击玩家
            // 实际游戏中这里应该计算伤害
            cout << "敌人攻击了你！\n";
        } else {
            // 装弹
            cout << "敌人装弹了。\n";
        }
    }
    
    void checkGameEnd() {
        if(!player.alive()) {
            isRunning = false;
        }
    }
};
// 继续主游戏类...

    // 辅助函数：获取武器类型的名称
    string getTypeName(WeaponType type) {
        switch(type) {
            case PISTOL: return "手枪";
            case SNIPER: return "狙击枪";
            case MELEE: return "近战武器";
            case LAUNCHER: return "发射器";
            case ASSAULT_RIFLE: return "突击步枪";
            case LIGHT_MACHINE_GUN: return "轻机枪";
            case MARKSMAN_RIFLE: return "射手步枪";
            default: return "未知";
        }
    }

    // 主函数
    int main() {
        srand(time(0)); // 初始化随机数种子
        Game game;
        game.start();
        return 0;
    }
};

贪吃蛇：

#include <iostream>
#include <conio.h>      // 用于键盘输入
#include <windows.h>    // 用于 Sleep() 和清屏
#include <cstdlib>      // 用于 rand()
#include <ctime>        // 用于随机种子

using namespace std;

bool gameOver;
const int width = 20;
const int height = 20;
int x, y, fruitX, fruitY, score;
int tailX[100], tailY[100];
int nTail;
enum eDirection { STOP = 0, LEFT, RIGHT, UP, DOWN };
eDirection dir;

void Setup() {
    gameOver = false;
    dir = STOP;
    x = width / 2;
    y = height / 2;
    fruitX = rand() % width;
    fruitY = rand() % height;
    score = 0;
}

void Draw() {
    system("cls");  // 清屏

    // 绘制上边界
    for (int i = 0; i < width + 2; i++)
        cout << "#";
    cout << endl;

    // 绘制游戏区域
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            if (j == 0)
                cout << "#";  // 左边界

            if (i == y && j == x)
                cout << "O";  // 蛇头
            else if (i == fruitY && j == fruitX)
                cout << "F";  // 食物
            else {
                bool printTail = false;
                for (int k = 0; k < nTail; k++) {
                    if (tailX[k] == j && tailY[k] == i) {
                        cout << "o";  // 蛇身
                        printTail = true;
                    }
                }
                if (!printTail)
                    cout << " ";
            }

            if (j == width - 1)
                cout << "#";  // 右边界
        }
        cout << endl;
    }

    // 绘制下边界
    for (int i = 0; i < width + 2; i++)
        cout << "#";
    cout << endl;

    cout << "Score: " << score << endl;
}

void Input() {
    if (_kbhit()) {  // 检测键盘输入
        switch (_getch()) {
            case 'a':
                dir = LEFT;
                break;
            case 'd':
                dir = RIGHT;
                break;
            case 'w':
                dir = UP;
                break;
            case 's':
                dir = DOWN;
                break;
            case 'x':
                gameOver = true;
                break;
        }
    }
}

void Logic() {
    // 蛇尾移动逻辑
    int prevX = tailX[0];
    int prevY = tailY[0];
    int prev2X, prev2Y;
    tailX[0] = x;
    tailY[0] = y;

    for (int i = 1; i < nTail; i++) {
        prev2X = tailX[i];
        prev2Y = tailY[i];
        tailX[i] = prevX;
        tailY[i] = prevY;
        prevX = prev2X;
        prevY = prev2Y;
    }

    // 蛇头移动
    switch (dir) {
        case LEFT:
            x--;
            break;
        case RIGHT:
            x++;
            break;
        case UP:
            y--;
            break;
        case DOWN:
            y++;
            break;
        default:
            break;
    }

    // 撞墙检测
    if (x >= width || x < 0 || y >= height || y < 0)
        gameOver = true;

    // 撞到自己检测
    for (int i = 0; i < nTail; i++) {
        if (tailX[i] == x && tailY[i] == y)
            gameOver = true;
    }

    // 吃到食物
    if (x == fruitX && y == fruitY) {
        score += 10;
        fruitX = rand() % width;
        fruitY = rand() % height;
        nTail++;
    }
}

int main() {
    srand(time(0));  // 初始化随机种子
    Setup();
    while (!gameOver) {
        Draw();
        Input();
        Logic();
        Sleep(100);  // 控制游戏速度（毫秒）
    }
    cout << "Game Over! Final Score: " << score << endl;
    return 0;
}

雷电飞机大战：

#include <iostream>
#include <conio.h>
#include <windows.h>
#include <vector>
#include <cstdlib>
#include <ctime>
using namespace std;

// 解决中文乱码
#ifdef _WIN32
void setConsoleToGBK() {
    SetConsoleOutputCP(936);
}
#endif

// 游戏配置
const int WIDTH = 40;
const int HEIGHT = 20;
int score = 0;
bool gameOver = false;

// 玩家飞机
struct Player {
    int x, y;
    char shape;
    Player() : x(WIDTH/2), y(HEIGHT-2), shape('A') {}
} player;

// 子弹
struct Bullet {
    int x, y;
    bool active;
    Bullet() : x(0), y(0), active(false) {}
};
vector<Bullet> bullets(10);

// 敌机
struct Enemy {
    int x, y;
    bool active;
    Enemy() : x(0), y(0), active(false) {}
};
vector<Enemy> enemies(10);

void Setup() {
    #ifdef _WIN32
    setConsoleToGBK();
    system("title 飞机大战");
    #endif
    srand(time(0));
}

void Draw() {
    system("cls");
    cout << "SCORE: " << score << "\n";
    cout << "CONTROL: A-Left D-Right J-Fire\n";
    
    for (int i = 0; i < HEIGHT; i++) {
        for (int j = 0; j < WIDTH; j++) {
            if (i == player.y && j == player.x) {
                cout << player.shape;
                continue;
            }
            
            bool printed = false;
            for (size_t k = 0; k < bullets.size(); k++) {
                if (bullets[k].active && i == bullets[k].y && j == bullets[k].x) {
                    cout << "|";
                    printed = true;
                    break;
                }
            }
            if (printed) continue;
            
            for (size_t k = 0; k < enemies.size(); k++) {
                if (enemies[k].active && i == enemies[k].y && j == enemies[k].x) {
                    cout << "V";
                    printed = true;
                    break;
                }
            }
            if (!printed) cout << " ";
        }
        cout << "\n";
    }
}

void FireBullet() {
    for (size_t i = 0; i < bullets.size(); i++) {
        if (!bullets[i].active) {
            bullets[i].x = player.x;
            bullets[i].y = player.y - 1;
            bullets[i].active = true;
            break;
        }
    }
}

void SpawnEnemy() {
    for (size_t i = 0; i < enemies.size(); i++) {
        if (!enemies[i].active) {
            enemies[i].x = rand() % WIDTH;
            enemies[i].y = 0;
            enemies[i].active = true;
            break;
        }
    }
}

void Update() {
    if (_kbhit()) {
        switch (_getch()) {
            case 'a': if (player.x > 0) player.x--; break;
            case 'd': if (player.x < WIDTH-1) player.x++; break;
            case 'j': FireBullet(); break;
            case 'q': gameOver = true; break;
        }
    }
    
    // 子弹逻辑
    for (size_t i = 0; i < bullets.size(); i++) {
        if (bullets[i].active) {
            bullets[i].y--;
            if (bullets[i].y < 0) bullets[i].active = false;
            
            for (size_t j = 0; j < enemies.size(); j++) {
                if (enemies[j].active && bullets[i].x == enemies[j].x && bullets[i].y == enemies[j].y) {
                    enemies[j].active = false;
                    bullets[i].active = false;
                    score += 10;
                }
            }
        }
    }
    
    // 敌机逻辑
    for (size_t i = 0; i < enemies.size(); i++) {
        if (enemies[i].active) {
            enemies[i].y++;
            if (enemies[i].y >= HEIGHT) enemies[i].active = false;
            
            if (enemies[i].x == player.x && enemies[i].y == player.y) {
                gameOver = true;
            }
        }
    }
    
    if (rand() % 10 == 0) SpawnEnemy();
}

int main() {
    Setup();
    while (!gameOver) {
        Draw();
        Update();
        Sleep(50);
    }
    cout << "GAME OVER! FINAL SCORE: " << score << endl;
    system("pause");
    return 0;
}

棋类小游戏：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <conio.h>
#include <windows.h>
using namespace std;

class Board {
protected:
    vector<vector<int> > board;
    int cursorX, cursorY;
    vector<vector<vector<int> > > history;
public:
    Board(int size) : board(size, vector<int>(size, 0)), cursorX(0), cursorY(0) {}
    
    virtual void display() = 0;
    virtual bool checkWin(int player) = 0;
    virtual bool isDraw() = 0;
    
    void moveCursor(int dx, int dy) {
        cursorX = (cursorX + dx + board.size()) % board.size();
        cursorY = (cursorY + dy + board.size()) % board.size();
    }
    
    bool makeMove(int player) {
        if (board[cursorY][cursorX] == 0) {
            history.push_back(board);
            board[cursorY][cursorX] = player;
            return true;
        }
        return false;
    }
    
    void undoMove() {
        if (!history.empty()) {
            board = history.back();
            history.pop_back();
        }
    }
    
    virtual void aiMove(int player, int difficulty) = 0;
    
    virtual pair<int, int> getBestMove(int player, int difficulty) = 0;
};

class TicTacToe : public Board {
public:
    TicTacToe() : Board(3) {}
    
    void display() {
        system("cls");
        for (int y = 0; y < 3; y++) {
            for (int x = 0; x < 3; x++) {
                if (x == cursorX && y == cursorY) cout << "[";
                else cout << " ";
                
                if (board[y][x] == 0) cout << " ";
                else if (board[y][x] == 1) cout << "O";
                else cout << "X";
                
                if (x == cursorX && y == cursorY) cout << "]";
                else cout << " ";
                
                if (x < 2) cout << "|";
            }
            cout << endl;
            if (y < 2) cout << "-----------" << endl;
        }
    }
    
    bool checkWin(int player) {
        for (int i = 0; i < 3; i++) {
            if ((board[i][0] == player && board[i][1] == player && board[i][2] == player) ||
                (board[0][i] == player && board[1][i] == player && board[2][i] == player))
                return true;
        }
        if ((board[0][0] == player && board[1][1] == player && board[2][2] == player) ||
            (board[0][2] == player && board[1][1] == player && board[2][0] == player))
            return true;
        return false;
    }
    
    bool isDraw() {
        for (int y = 0; y < 3; y++) {
            for (int x = 0; x < 3; x++) {
                if (board[y][x] == 0) return false;
            }
        }
        return true;
    }
    
    void aiMove(int player, int difficulty) {
        if (difficulty == 0) {
            do {
                cursorX = rand() % 3;
                cursorY = rand() % 3;
            } while (!makeMove(player));
        } else {
            pair<int, int> move = getBestMove(player, difficulty);
            cursorX = move.first;
            cursorY = move.second;
            makeMove(player);
        }
    }
    
    pair<int, int> getBestMove(int player, int difficulty) {
        int opponent = 3 - player;
        
        for (int y = 0; y < 3; y++) {
            for (int x = 0; x < 3; x++) {
                if (board[y][x] == 0) {
                    board[y][x] = player;
                    if (checkWin(player)) {
                        board[y][x] = 0;
                        return pair<int, int>(x, y);
                    }
                    board[y][x] = 0;
                }
            }
        }
        
        for (int y = 0; y < 3; y++) {
            for (int x = 0; x < 3; x++) {
                if (board[y][x] == 0) {
                    board[y][x] = opponent;
                    if (checkWin(opponent)) {
                        board[y][x] = 0;
                        return pair<int, int>(x, y);
                    }
                    board[y][x] = 0;
                }
            }
        }
        
        if (board[1][1] == 0) return pair<int, int>(1, 1);
        
        vector<pair<int, int> > available;
        for (int y = 0; y < 3; y++) {
            for (int x = 0; x < 3; x++) {
                if (board[y][x] == 0) available.push_back(pair<int, int>(x, y));
            }
        }
        if (!available.empty()) {
            return available[rand() % available.size()];
        }
        
        return pair<int, int>(0, 0);
    }
};

class Gomoku : public Board {
public:
    Gomoku() : Board(15) {}
    
    void display() {
        system("cls");
        cout << "  ";
        for (int x = 0; x < 15; x++) {
            cout << (x < 10 ? " " : "") << x << " ";
        }
        cout << endl;
        
        for (int y = 0; y < 15; y++) {
            cout << (y < 10 ? " " : "") << y << " ";
            for (int x = 0; x < 15; x++) {
                if (x == cursorX && y == cursorY) cout << "[";
                else cout << " ";
                
                if (board[y][x] == 0) cout << "+";
                else if (board[y][x] == 1) cout << "O";
                else cout << "X";
                
                if (x == cursorX && y == cursorY) cout << "]";
                else cout << " ";
            }
            cout << endl;
        }
    }
    
    bool checkWin(int player) {
        int directions[4][2] = {{1,0}, {0,1}, {1,1}, {1,-1}};
        for (int y = 0; y < 15; y++) {
            for (int x = 0; x < 15; x++) {
                if (board[y][x] == player) {
                    for (int d = 0; d < 4; d++) {
                        int count = 1;
                        for (int step = 1; step < 5; step++) {
                            int nx = x + directions[d][0] * step;
                            int ny = y + directions[d][1] * step;
                            if (nx >= 0 && nx < 15 && ny >= 0 && ny < 15 && board[ny][nx] == player) {
                                count++;
                            } else {
                                break;
                            }
                        }
                        if (count >= 5) return true;
                    }
                }
            }
        }
        return false;
    }
    
    bool isDraw() {
        for (int y = 0; y < 15; y++) {
            for (int x = 0; x < 15; x++) {
                if (board[y][x] == 0) return false;
            }
        }
        return true;
    }
    
    void aiMove(int player, int difficulty) {
        if (difficulty == 0) {
            do {
                cursorX = rand() % 15;
                cursorY = rand() % 15;
            } while (!makeMove(player));
        } else {
            pair<int, int> move = getBestMove(player, difficulty);
            cursorX = move.first;
            cursorY = move.second;
            makeMove(player);
        }
    }
    
    pair<int, int> getBestMove(int player, int difficulty) {
        int opponent = 3 - player;
        vector<pair<int, int> > available;
        
        for (int y = 0; y < 15; y++) {
            for (int x = 0; x < 15; x++) {
                if (board[y][x] == 0) available.push_back(pair<int, int>(x, y));
            }
        }
        
        if (difficulty == 3 && available.size() > 100) {
            vector<pair<int, int> > center;
            for (size_t i = 0; i < available.size(); i++) {
                int x = available[i].first, y = available[i].second;
                if (x >= 5 && x <= 9 && y >= 5 && y <= 9) {
                    center.push_back(available[i]);
                }
            }
            if (!center.empty()) {
                return center[rand() % center.size()];
            }
        }
        
        vector<int> scores(available.size(), 0);
        for (size_t i = 0; i < available.size(); i++) {
            int x = available[i].first;
            int y = available[i].second;
            
            board[y][x] = player;
            if (checkWin(player)) {
                board[y][x] = 0;
                return pair<int, int>(x, y);
            }
            
            board[y][x] = opponent;
            if (checkWin(opponent)) {
                board[y][x] = 0;
                return pair<int, int>(x, y);
            }
            board[y][x] = 0;
            
            scores[i] = evaluatePosition(x, y, player);
        }
        
        int maxScore = -1;
        vector<pair<int, int> > bestMoves;
        for (size_t i = 0; i < scores.size(); i++) {
            if (scores[i] > maxScore) {
                maxScore = scores[i];
                bestMoves.clear();
                bestMoves.push_back(available[i]);
            } else if (scores[i] == maxScore) {
                bestMoves.push_back(available[i]);
            }
        }
        
        if (!bestMoves.empty()) {
            return bestMoves[rand() % bestMoves.size()];
        }
        
        if (!available.empty()) {
            return available[0];
        }
        
        return pair<int, int>(7, 7);
    }
    
    int evaluatePosition(int x, int y, int player) {
        int score = 0;
        int opponent = 3 - player;
        int directions[4][2] = {{1,0}, {0,1}, {1,1}, {1,-1}};
        
        for (int d = 0; d < 4; d++) {
            int playerCount = countConsecutive(x, y, directions[d][0], directions[d][1], player);
            score += getPatternScore(playerCount);
            
            int opponentCount = countConsecutive(x, y, directions[d][0], directions[d][1], opponent);
            score += getPatternScore(opponentCount) * 0.8;
        }
        
        int centerDist = abs(x - 7) + abs(y - 7);
        score += (14 - centerDist) * 2;
        
        return score;
    }
    
    int countConsecutive(int x, int y, int dx, int dy, int player) {
        int count = 1;
        
        for (int step = 1; step < 5; step++) {
            int nx = x + dx * step;
            int ny = y + dy * step;
            if (nx >= 0 && nx < 15 && ny >= 0 && ny < 15 && board[ny][nx] == player) {
                count++;
            } else {
                break;
            }
        }
        
        for (int step = 1; step < 5; step++) {
            int nx = x - dx * step;
            int ny = y - dy * step;
            if (nx >= 0 && nx < 15 && ny >= 0 && ny < 15 && board[ny][nx] == player) {
                count++;
            } else {
                break;
            }
        }
        
        return count >= 5 ? 5 : count;
    }
    
    int getPatternScore(int count) {
        switch(count) {
            case 5: return 100000;
            case 4: return 10000;
            case 3: return 1000;
            case 2: return 100;
            default: return 0;
        }
    }
};

void gameLoop() {
    srand(time(0));
    
    while (true) {
        system("cls");
        cout << "欢迎来到棋类游戏!" << endl;
        cout << "1. 井字棋" << endl;
        cout << "2. 五子棋" << endl;
        cout << "0. 退出" << endl;
        cout << "请选择: ";
        
        int gameChoice;
        cin >> gameChoice;
        
        if (gameChoice == 0) break;
        
        int mode;
        cout << "选择模式:" << endl;
        cout << "1. 双人对战" << endl;
        cout << "2. 人机对战" << endl;
        cout << "请选择: ";
        cin >> mode;
        
        int difficulty = 0;
        if (mode == 2) {
            cout << "选择难度:" << endl;
            cout << "0. 简单" << endl;
            cout << "1. 普通" << endl;
            cout << "2. 困难" << endl;
            cout << "3. 地狱" << endl;
            cout << "请选择: ";
            cin >> difficulty;
        }
        
        Board* game;
        if (gameChoice == 1) {
            game = new TicTacToe();
        } else {
            game = new Gomoku();
            
            if (mode == 2 && difficulty == 3) {
                game->aiMove(1, difficulty);
                game->display();
                cout << "地狱难度: AI先手" << endl;
                Sleep(1000);
            }
        }
        
        int currentPlayer = (mode == 2 && difficulty == 3) ? 2 : 1;
        bool gameOver = false;
        
        while (!gameOver) {
            game->display();
            
            if (mode == 1 || currentPlayer == 2 || (currentPlayer == 1 && !(mode == 2 && difficulty == 3))) {
                cout << "玩家" << currentPlayer << " (" << (currentPlayer == 1 ? "O" : "X") << ") 回合" << endl;
                cout << "方向键移动, 空格落子, U悔棋" << endl;
                
                while (true) {
                    int key = _getch();
                    if (key == 0 || key == 0xE0) {
                        key = _getch();
                        switch (key) {
                            case 72: game->moveCursor(0, -1); break;
                            case 80: game->moveCursor(0, 1); break;
                            case 75: game->moveCursor(-1, 0); break;
                            case 77: game->moveCursor(1, 0); break;
                        }
                        game->display();
                        cout << "玩家" << currentPlayer << " (" << (currentPlayer == 1 ? "O" : "X") << ") 回合" << endl;
                        cout << "方向键移动, 空格落子, U悔棋" << endl;
                    } else if (key == ' ') {
                        if (game->makeMove(currentPlayer)) {
                            break;
                        }
                    } else if (key == 'u' || key == 'U') {
                        game->undoMove();
                        if (mode == 2) game->undoMove();
                        game->display();
                        cout << "玩家" << currentPlayer << " (" << (currentPlayer == 1 ? "O" : "X") << ") 回合" << endl;
                        cout << "方向键移动, 空格落子, U悔棋" << endl;
                    }
                }
            } else {
                cout << "AI思考中..." << endl;
                Sleep(500);
                game->aiMove(currentPlayer, difficulty);
            }
            
            if (game->checkWin(currentPlayer)) {
                game->display();
                if (mode == 1 || currentPlayer == 2) {
                    cout << "玩家" << currentPlayer << " (" << (currentPlayer == 1 ? "O" : "X") << ") 获胜!" << endl;
                } else {
                    cout << "AI获胜!" << endl;
                }
                gameOver = true;
            } else if (game->isDraw()) {
                game->display();
                cout << "平局!" << endl;
                gameOver = true;
            } else {
                currentPlayer = 3 - currentPlayer;
            }
        }

        cout << "\n1. 再来一局" << endl;
        cout << "2. 返回主菜单" << endl;
        cout << "0. 退出游戏" << endl;
        cout << "请选择: ";
        
        int choice;
        cin >> choice;
        
        if (choice == 0) {
            delete game;
            break;
        } else if (choice == 2) {
            delete game;
            continue;
        } else {
            delete game;
            if (gameChoice == 1) {
                game = new TicTacToe();
            } else {
                game = new Gomoku();
                
                if (mode == 2 && difficulty == 3) {
                    game->aiMove(1, difficulty);
                    game->display();
                    cout << "地狱难度: AI先手" << endl;
                    Sleep(1000);
                }
            }
            currentPlayer = (mode == 2 && difficulty == 3) ? 2 : 1;
            gameOver = false;
        }
    }
}
void setConsoleUTF8() {
    SetConsoleOutputCP(65001);
    SetConsoleCP(65001);
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_FONT_INFOEX fontInfo;
    fontInfo.cbSize = sizeof(fontInfo);
    GetCurrentConsoleFontEx(hConsole, FALSE, &fontInfo);
    wcscpy(fontInfo.FaceName, L"Consolas");
    SetCurrentConsoleFontEx(hConsole, FALSE, &fontInfo);
}

int main() {
    setConsoleUTF8();
    gameLoop();
    return 0;
}

自想游戏介绍（未写代码）： 《棋牌肉鸽》完整玩法说明（最终版）游戏概述 《棋牌肉鸽》是一款融合中国象棋、国际象棋、国际跳棋、围棋、五子棋、斗兽棋、日本将棋、中国军旗和飞行棋规则的策略塔防游戏。玩家需在双棋盘战场上通过招募多棋类兵种构建防御体系，抵御无尽波次的怪物进攻。

核心机制 ‌双棋盘战场‌

左区：中国象棋棋盘（保护「将」） 右区：国际象棋棋盘（保护「后」） 领域转换：棋子移动后，3×3区域转换为所属棋类规则领域 ‌兵种系统（全卡池）‌ ‌中国象棋‌：将/士/象/马/车/炮/兵（经典象棋规则） ‌国际象棋‌：后/王/车/马/象/兵（国际象棋规则） ‌国际跳棋‌：兵/王（兵：斜角秒杀普通怪；王：对角线秒杀精英怪） ‌围棋‌：黑子（9枚，包围怪物可秒杀，与五子棋联动可秒精英怪） ‌五子棋‌：白子（限2枚，五连线伤害×2，九连线秒杀精英怪） ‌斗兽棋‌：象/鼠/狮/虎/豹/狼/狗/猫（特殊攻击规则） ‌日本将棋‌：王将（玉将）/飞车/角行/金将/银将/桂马/香车/步兵（抽取词条解锁） 军棋‌：司令、军长、师长、旅长、团长、营长、连长、排长、工兵、地雷、炸弹、军旗（抽取词条解锁） 飞行棋‌：4色飞机棋子（红、黄、蓝、绿） 古印度象棋：王、战车、象、马、船、兵 蒙古象棋：可汗、车、骆驼、马、狗、兵 波斯象棋‌：王、维齐尔（斜走1格）、象（跳2格斜线）、马、车、兵 军旗规则： ‌司令‌：全场最高指挥官，攻击和防御大幅提升，可无视部分敌人特殊效果。 ‌军长‌：高级指挥官，拥有强大的单体攻击能力。 ‌师长‌：中级指挥官，攻击附带范围伤害。 ‌旅长‌：负责区域防御，能够吸引敌人火力。 ‌团长‌：快速移动单位，擅长穿插敌人阵型。 ‌营长‌：辅助单位，可为周围友军提供增益效果。 ‌连长‌：远程攻击单位，擅长打击后排敌人。 ‌排长‌：基础战斗单位，具备均衡的攻击和防御能力。 ‌工兵‌：特殊单位，能够挖掘地道，瞬间转移位置或破坏敌人地雷。 ‌地雷‌：布置在战场上，敌人触碰后引发爆炸，造成大量伤害。 ‌炸弹‌：高威力爆炸单位，可对周围敌人造成毁灭性打击。 ‌军旗‌：胜利象征，保护军旗不被敌人夺取即为胜利条件之一。

战斗流程‌ 招募阶段：每关从七大卡池（含斗兽棋、日本将棋）中选择棋子 部署阶段：按原规则移动棋子 自动战斗：触发领域效果与联动 胜负判定：保护「将/后」至全灭敌人 ‌BOSS与成长系统‌ ‌一、敌人体系重构总览 本次更新将游戏敌人系统全面升级为麻将扑克主题，形成三级敌人架构： 终极BOSS：幺鸡（二阶段凤凰形态）、红中、扑克大小王 小BOSS：东风/南风/西风/北风（麻将四风牌） 精英怪：扑克JQK系列（红桃/黑桃/梅花/方块各3张） 普通怪：剩余所有麻将牌与扑克牌 二、BOSS机制设计

1. 幺鸡（凤凰形态） 一阶段： 技能「雀鸣」：每3回合召唤2张随机麻将牌 被动「单吊」：血量低于30%时自动胡牌恢复20%生命 二阶段： 变身凤凰后获得飞行能力（无视地形） 新技能「涅槃」：死亡时若场上有其他麻将牌则复活
2. 红中 核心技能「红中发财」： 每损失25%血量召唤1张发财或白板 3张中发白同场时触发全屏AOE
3. 大小王 大王技能「王炸」：蓄力3回合的全屏秒杀（可打断） 小王技能「鬼牌」：随机复制场上一个单位的技能 三、小BOSS特性 名称特殊能力克制方式东风每回合推动全体敌人向东移动利用棋盘西侧障碍物南风点燃3×3区域水系棋子伤害+50%西风偷取1个棋子2回合快速击杀优先北风冰冻直线路径火系技能解冻 四、精英怪组合效果 同花顺：3张同花色JQK在场时： 红桃：全体回血每秒2% 黑桃：附加中毒效果 梅花：召唤扑克牌护盾 方块：暴击率+30% 四条：4张同数字牌触发秒杀级攻击 五、普通敌人分类 麻将组： 万/条/筒：近战单位 字牌：特殊技能单位 扑克组： 数字牌：根据点数获得对应强化 A：自爆单位 2：治疗单位 ‌击败奖励‌：3个随机词条中选择1个 特殊词条出现概率为基础词条的1/3 隐藏词条需满足条件后自动获得 部分词条存在互斥关系（如"二龙戏珠"和"天元领域"不可同时选择） ‌2. 复活机制‌ 阵亡单位下一波自动复活，支持长期策略构筑。 ‌策略深度与特色‌ ‌跨棋类联动‌：如围棋黑子+五子棋白子=秒杀精英怪。 ‌领域争夺‌：移动棋子改变棋盘规则，动态调整战术。 ‌斗兽棋爆发‌：鼠对BOSS特攻，狮虎跨地形突袭。

《棋牌肉鸽》词条与羁绊优化版 一、词条（更新） 基础词条 ‌铜墙铁壁‌：所有棋子生命值+20% ‌锋芒毕露‌：所有棋子攻击力+15% ‌嗜血本能‌：攻击附带10%吸血效果 ‌致命节奏‌：攻击速度+25% ‌暴击专精‌：暴击率+15%，暴击伤害+30% ‌生生不息‌：每波次开始时恢复10%最大生命值 ‌策略大师‌：所有棋子的技能冷却时间减少20%。 ‌坚韧不拔‌：所有棋子受到控制效果的持续时间减少30%。 ‌快速部署‌：下一轮，棋子获得一次额外的移动机会。 ‌紧急避险‌：当核心棋子（将/后）生命值低于50%时，周围友军单位获得一次免死机会（仅触发一次）。 特殊词条（限选1次，抽取解锁） ‌象棋系‌

‌楚河汉界‌：中国象棋棋盘上的友方单位防御+30% ‌连环马‌：两个马同时在场时，移动范围+1格 ‌重炮轰击‌：炮的攻击范围扩大50% ‌国际象棋系‌

‌王车易位‌：王和车可以交换位置（每3波次触发1次） ‌升变法则‌：兵到达敌方底线可临时变为后（持续1波次） ‌斜线压制‌：象的攻击附带穿透效果 ‌国际跳棋系‌（抽取词条解锁）

‌解封‌：国际跳棋兵或王可以不停连吃（即连续攻击） ‌跳跃大师‌：国际跳棋兵跳跃后，下回合可再行动一次 ‌王域掌控‌：国际跳棋王在场上时，周围3×3区域的敌人移动速度减半 ‌围棋系‌

‌二龙戏珠‌：围棋可选两次（最多持有18枚黑子） ‌天元领域‌：中央5×5区域内的黑子攻击力翻倍 ‌星罗棋布‌：黑子每3枚相连，即可对周围敌人造成范围伤害 ‌星位压制‌：当黑子在棋盘上的“星位”形成包围时（即四个角的星位各有一枚黑子），这些黑子攻击力翻倍，且对周围敌人的控制效果（如减速、眩晕）时间延长50%。 ‌气数已尽‌：黑子包围敌人时，不仅秒杀敌人，还能额外吸收其部分生命值转化为己方所有棋子的生命值恢复，恢复量为被秒杀敌人生命值的20%。 ‌大局观‌：每波次战斗开始前，自动分析敌方布局，优化黑子的落子位置，以最大化下一轮包围敌人的可能性。此效果每波次限用一次。 ‌五子棋系‌（抽取词条解锁）

‌五子连珠‌：白子的连线伤害加成提升至3倍 ‌禁手突破‌：允许使用"三三"禁手（额外攻击机会） ‌棋局掌控‌：每回合可额外放置1枚白子（或黑子，视情况而定） 五子连环‌：白子连线成功后，不仅造成伤害，还会额外生成一个白子，并自动寻找最近的空位落下，继续尝试连线，最多可连续触发三次。 ‌禁手大师‌：允许玩家主动使用“三三”和“四四”禁手，使用后立刻对敌方全体造成一次伤害，并有一定概率使敌方一个单位下回合无法行动。 ‌子力充沛‌：每回合开始时，若场上白子数量少于上限，则自动补充一枚白子至随机空位，确保战术布局的灵活性。 ‌斗兽棋系‌（抽取词条解锁）

‌乳虎啸谷‌：老虎攻击附带击退效果（推开2格） ‌百兽归来‌：解锁斗兽棋完整卡池 ‌兽王降临‌：场上每有一种斗兽棋单位，象的攻击力+10% ‌狮王怒吼‌：狮子在场时，所有斗兽棋单位的攻击力提升20%，且每回合开始时有50%概率对随机一个敌人造成恐惧效果，使其下回合无法行动。 ‌狼群战术‌：场上每有一只狼，所有斗兽棋单位的移动速度增加5%。当三只或以上狼同时在场时，触发狼群突袭，对敌方全体造成一次额外伤害。 ‌鼠辈逆袭‌：鼠的攻击力虽然较低，但当其生命值低于30%时，攻击力翻倍，且对BOSS单位造成的伤害额外增加50%。 日本将棋系（抽取词条解锁）‌

‌飞车纵横‌：飞车移动不受限制，可横竖斜任意方向移动 ‌角行旋风‌：角行攻击附带旋转效果，可攻击周围多个敌人 ‌金将威严‌：金将在场时，所有友方单位攻击力+10% ‌银将守护‌：银将在场时，所有友方单位防御力+10% ‌桂马跃进‌：桂马移动后可再行动一次（每回合限一次） ‌香车突袭‌：香车直线攻击可穿透敌人并造成额外伤害 ‌步兵荣耀‌：步兵升变后，获得其升变棋子的全部能力并额外提升攻击力20% 中国军棋系（抽取词条解锁）‌

‌司令威严‌：司令在场时，所有友军攻击力提升10%。 ‌军旗不倒‌：军旗存在时，所有单位防御力提升15%，且每波次开始时恢复5%生命值。 ‌地雷密布‌：布置地雷时，有额外几率触发连环爆炸，对周围敌人造成多次伤害。 ‌炸弹狂潮‌：炸弹爆炸范围扩大50%，且对精英怪造成额外伤害。 ‌工兵奇袭‌：工兵挖掘地道后，下回合可瞬间转移至战场任意位置。 飞行棋系（抽取词条解锁）‌

‌空中霸主‌：飞机攻击力+20%，无视地形。 ‌协同飞行‌：≥2种颜色飞机时，移速+30%。 ‌紧急降落‌：未移动则下回合恢复10%生命值。 ‌古印度象棋系（抽取词条解锁）‌

‌帝王之威‌：王在场时，所有友军单位攻击力提升。 ‌战车之轮‌：战车移动后，下次攻击造成额外伤害。 ‌象之守护‌：象在场上时，周围友军单位防御力提升。 ‌蒙古象棋系（抽取词条解锁）‌

‌草原霸主‌：可汗在场时，所有蒙古象棋棋子攻击力提升。 ‌沙漠之舟‌：骆驼在沙漠中移动和攻击时，获得额外加成。 ‌犬牙交错‌：狗在场上时，所有蒙古象棋棋子移动速度提升。 ‌波斯象棋系（抽取词条解锁）‌

‌智慧之光‌：维齐尔在场时，所有波斯象棋棋子策略值提升（假设游戏中存在策略值设定）。 ‌飞翔之象‌：象跳跃攻击时，造成额外范围伤害。 ‌王之荣耀‌：王存活时，所有波斯象棋棋子获得额外护盾。 ‌通用强力词条‌

‌未知者勇‌：对BOSS伤害×2 ‌多多益善‌：场上每有1个棋子，全体伤害+1% ‌先发制人‌：第一波攻击必定暴击 ‌绝境反击‌：核心棋子（将/后）血量低于30%时，攻击力+50% 隐藏词条（特殊条件解锁） ‌棋圣附体‌：同时拥有5个不同棋类词条时解锁 - 所有棋子获得全棋类基础能力 ‌万物归一‌：围棋黑子和五子棋白子各9枚时解锁 - 可发动"天地大同"秒杀全屏 ‌野兽狂潮‌：场上同时存在5个斗兽棋单位时解锁 - 所有斗兽棋单位攻击速度+50% ‌铁血军团‌：当场上同时存在司令、军长、师长时解锁，所有军棋单位攻击速度提升50%，持续整场战斗。 ‌雷霆一击‌：当地雷与炸弹同时触发时，有一定概率触发全屏AOE伤害，对敌人造成重创。 二、羁绊（优化） 普通羁绊（经典战术组合）

‌彩虹编队‌（红+黄+蓝+绿飞机）：获得「彩色护盾」。 ‌马后炮‌（象棋马 + 炮）：马移动后，炮可对马经过的路径发动范围轰炸。 ‌双车错‌（2个象棋车）：直线攻击可穿透3个目标，并附带额外伤害。 ‌连环马‌（2个象棋马，调整数量）：移动路径可互相跳跃，形成合击，攻击伤害+30%。 ‌重炮阵地‌（3个象棋炮，调整数量）：炮击范围扩大至全屏，但冷却增加。 ‌黑白无常‌（围棋黑子 + 五子棋白子）：相邻时触发位置交换并刷新技能CD，额外获得1层护盾。 飞车角行阵‌（飞车 + 角行）：两者相邻时，攻击附带额外伤害并有一定概率造成眩晕 ‌金银双将‌（金将 + 银将）：两者同时在场时，所有友方单位攻防各+15% 铁壁防线‌（司令 + 军长 + 旅长）：形成坚不可摧的防线，大幅降低敌人穿透效果。 ‌雷霆突击‌（师长 + 团长 + 连长）：快速突击敌人后排，造成大量伤害并扰乱敌人阵型。 ‌地雷阵‌（地雷 × 3）：布置三个地雷，形成交叉火力网，敌人触碰即触发连锁爆炸。 ‌爆破专家‌（炸弹 + 工兵）：炸弹威力提升，且工兵挖掘地道后可快速布置炸弹。 ‌皇家卫队‌（王 + 战车 + 象）：所有友军单位防御力大幅提升。 ‌水陆并进‌（战车 + 船）：战车和船在各自擅长领域（陆地和水域）中攻击力提升。 ‌草原之盟‌（可汗 + 骆驼 + 马）：所有蒙古象棋棋子移动速度提升，并具备穿透敌人防线的能力。 ‌猎犬出击‌（可汗 + 狗）：可汗在场上时，狗获得额外攻击机会。 ‌宫廷智囊‌（王 + 维齐尔）：王和维齐尔相邻时，所有波斯象棋棋子暴击值大幅提升。 ‌铁骑踏遍‌（马 + 车）：马和车在战场上形成联动，移动和攻击能力增强。 特殊羁绊（跨棋类联动）

‌象群‌（国际象棋象×1 + 中国象棋象×1 + 斗兽棋象×1 + 任意2个象，调整数量）：不同棋种的象获得特殊能力，攻击附带眩晕效果。 ‌虎豹骑‌（斗兽棋虎 + 斗兽棋豹 + 中国象棋士 + 中国象棋马，调整数量）：4个单位连成一线时触发特殊效果，攻击附带破甲效果。 ‌野兽骑兵‌（斗兽棋虎 + 象棋马）：虎获得移动后留下燃烧区域的能力，燃烧伤害提升50%。 ‌禁卫军团‌（国际象棋王 + 中国象棋士 + 任意2个防御单位）：为核心棋子生成防御御阵，御阵内单位免疫一次伤害。 ‌远程火力组‌（象棋炮 + 国际象棋后）：炮和后攻击时互相充能，充能后下次攻击必定暴击。 ‌绝杀一子‌（五子棋专属，2个五子棋同色单位相邻）：攻击附带额外伤害，并有一定概率秒杀非BOSS单位。 ‌野兽特攻组‌（斗兽棋鼠 + 国际象棋车）：车直线攻击可携带鼠突进，突进过程中免疫碰撞伤害。 ‌征子‌（围棋黑子×2）：攻击会生成临时标记，标记爆炸造成范围伤害，范围扩大50%。 东西合璧‌（中国象棋象 + 日本将棋角行）：两者同时在场时，攻击附带范围伤害效果 ‌王将联盟‌（日本将棋王将 + 国际象棋王）：两者相邻时，核心棋子（将/后/王将）防御力大幅提升 ‌步炮协同‌（日本将棋步兵 + 中国象棋炮）：步兵升变后，与炮相邻时，炮的攻击范围扩大并附带穿透效果 铁血联盟‌（军棋司令 + 象棋将/国际象棋后）：核心棋子获得额外护盾，且攻击附带范围伤害。 ‌突袭小队‌（军棋工兵 + 国际跳棋王）：工兵挖掘地道后，可协助国际跳棋王快速突袭敌人。 ‌地雷陷阱‌（军棋地雷 + 围棋黑子）：在黑子周围布置地雷，敌人触碰黑子时同时触发地雷爆炸。 ‌爆破先锋‌（军棋炸弹 + 斗兽棋鼠）：炸弹爆炸时，鼠可趁机对敌人造成额外特攻伤害。 天空之桥‌（飞机+国际象棋后）：后攻击范围扩大50%。 ‌空中支援‌（飞机+远程单位）：远程单位获得额外攻击机会。 ‌东西交融‌（古印度象棋王 + 蒙古象棋可汗）：当两位不同文化的王者同时存在时，所有棋子获得额外生命值加成。 ‌智慧与力量‌（波斯象棋维齐尔 + 中国象棋炮）：维齐尔和炮形成联动，暴击值与攻击力同时提升。 隐藏羁绊（特殊条件触发）

‌棋圣试炼‌（同时激活5个不同羁绊）：随机一个棋子进化为"棋圣"，棋圣攻击附带全体单位10%攻击力的额外伤害。 ‌野兽狂潮‌（场上存在5个斗兽棋单位）：所有斗兽棋单位进入狂暴状态，攻击速度提升100%，持续10秒，期间免疫控制效果。 七国争雄‌（同时激活七大棋类羁绊中的任意五个）：随机三个棋子获得“七国之力”，攻击力、防御力、生命值各+20%，持续三波战斗 ‌将棋荣耀‌（场上存在四个及以上日本将棋单位）：所有日本将棋单位进入“荣耀状态”，攻击速度提升50%，持续五秒，期间免疫控制效果 ‌铁血荣耀‌：当场上同时存在所有军棋单位（司令至军旗）时，所有单位进入“铁血荣耀”状态，攻击力、防御力、生命值各提升30%，持续整场战斗。此状态下，每次击败敌人都有概率触发全屏AOE伤害。 ‌‌翱翔天际‌：当场上同时存在所有飞行棋棋子，所有飞机棋子进入「翱翔状态」，攻击力、防御力、移动速度各提升50%，持续5回合。

学习扩展包（包含犹太塔木德棋，文道弈，文道弈——文渊劫变） 犹太塔木德祺扩展包（本扩展包棋子提到的数值默认为血量，且都是卡池中可以抽到的同阵营友方单位） 新增棋子 微积分棋子组 ‌导数棋子（△）‌：移动时可改变相邻棋子数值（f'(x)运算）。 ‌积分棋子（∫）‌：可吸收直线路径上棋子数值之和（∑f(x)dx）。 集合论棋子 ‌并集棋子（∪）‌：可合并两枚己方棋子数值。 ‌补集棋子（∁）‌：使对方棋子数值取模运算（如∁7=3，模10）。 特殊棋子 ‌虚数棋子 (i)‌：每次走√-1格（实际为骑士跳变体），使接触的实数棋子数值×i。 ‌斐波那契兔子 (F)‌：步数必须为斐波那契数列（1,2,3,5...），可吃掉相邻两子之和等于自身的棋子。 ‌素数螺旋棋 (Pₙ)‌：沿乌拉姆螺旋路径行进，经过的格子会标记素数坐标。 ‌矩阵方块 [M]‌：移动需声明行/列变换（如R1+R2），当行列式值为对方棋子数值时吃子。 ‌分形树 (🌳)‌：每次分裂为3个1/3尺寸子棋，需满足豪斯多夫维数计算。 ‌混沌蝴蝶 (χ)‌：按洛伦兹吸引子轨迹移动，每3步触发"蝴蝶效应"随机位移。 ‌黎曼猜想棋 (ζ)‌：移动仅限非平凡零点格位，胜利条件为同时控制ζ(-2)和ζ(1/2+14.1347i)。 ‌拓扑环面 (⧉)‌：可穿越棋盘边界（环面映射），移动后高斯曲率必须守恒。 ‌量子叠加态 (Ψ)‌：同时存在于3格（概率云显示），被观察时按波函数确定位置。 ‌AI神经网络 (α)‌：每回合记录对手策略，3步后激活反向传播反制。 ‌分形递归棋 (∞)‌：每次移动生成缩小50%的克隆体，克隆体数值需满足曼德博集迭代公式。 ‌混沌吸引子 (δ)‌：按洛伦兹方程三维轨迹行进，使周围棋子进入"确定性随机"状态。 ‌黎曼曲面棋 (ℛ)‌：在多值复平面上解析延拓，胜利条件为同时控制ζ函数的极点与零点。 ‌量子纠缠对 (⚛)‌：两枚棋子共享状态，测量一枚会导致另一枚瞬时坍缩。 ‌拓扑变形者 (𝕋)‌：将棋盘局部变为环面/克莱因瓶，每次变形需保持欧拉示性数不变。 ‌质数刺客（ℙ）‌：只能移动到质数格，若目标棋子数值是合数则可吃掉它。 ‌几何骑士（△□○）‌：按几何图形路径移动，吃掉棋子后可将其数值转为面积。 ‌代数未知数（𝑥）‌：开局时隐藏数值，每次移动后公布“线索”，对手需解方程才能攻击它。 ‌分数祭司（½）‌：移动时需用分数运算，若目标数值能被自己分母整除则吞噬目标。 ‌希伯来字母棋（א-ת）‌：每枚棋子对应一个希伯来字母及其数值，拼出特定犹太圣词可触发群体治疗。 ‌无限祭司（∞）‌：可复制任意棋子的能力一次，但复制后自身数值变为“未定义”。 ‌概率先知（🎲）‌：每次移动前掷骰，根据结果触发不同效果。 ‌对称镜像（⇌）‌：必须沿棋盘对称轴移动，若吃子则目标棋子的数值必须与自己成对称数。 ‌公约数守卫（⋁）‌：只能被数值与自己有≥2个公约数的棋子攻击。 ‌立方圣殿骑士（³√）‌：只能移动到立方数格，吃子时若目标数值是立方数则直接移除。 ‌因数拉比（÷）‌：可分解目标棋子，选择保留一个因数作为新数值，每局限用2次。 ‌希伯来日历棋（☽）‌：按犹太历移动，需判断当前虚拟年份是否为犹太闰年。 ‌矩阵先知（⊠）‌：在3×3方格内建立矩阵，中心棋子可吸收周围棋子数值之和。 ‌神圣比例棋（φ²）‌：每次按黄金比例（1.618）舍入步数，接近棋盘中心时获得防御加成。 ‌卡巴拉路径棋（ספירה）‌：对应生命之树的10个质点，移动到不同质点触发不同效果。 ‌代数流放者（→𝑥）‌：每回合必须移动"解方程步数"，对手可设置简易方程控制其移动。 ‌妥拉密码棋（תּוֹרָה）‌：通过字母数值对应破译加密格，拼出"תורה"可复活棋子。 ‌无限圣戒（∞̸）‌：数值可无限增大但会被0除效应重置，当有棋子被0除时触发"虚空吞噬"事件。 ‌逾越节方程（פֶּסַח）‌：需满足4个数学条件才能移动，对应逾越节4个问题传统。 新增词条 基础词条 ‌微积分掌控‌：所有微积分棋子移动时，对相邻棋子的数值改变效果增强。 ‌集合论大师‌：集合论棋子合并或取模运算时，数值增益提升。 ‌虚数领域‌：虚数棋子接触实数棋子时，额外造成一次基于数值差的伤害。 ‌斐波那契智慧‌：斐波那契兔子移动时，若路径上存在可吃的棋子，则步数消耗减少。 ‌素数追踪‌：素数螺旋棋经过的素数坐标格子，对敌方棋子造成持续伤害。

特殊词条 ‌量子纠缠效应‌：量子纠缠对中任意一枚棋子受到攻击时，另一枚棋子获得护盾。 ‌拓扑变形战术‌：拓扑变形者变形后，改变区域地形对敌方棋子造成不利影响。 ‌质数刺客信条‌：质数刺客移动到质数格时，攻击力大幅提升。 ‌几何骑士领域‌：几何骑士吃掉棋子后，将数值转为面积的效果对周围友军提供增益。 ‌代数未解之谜‌：代数未知数每次移动后公布的“线索”，有概率使敌方棋子迷茫一回合。

联动词条 ‌质数共鸣‌：当质数刺客（ℙ）移动到由素数螺旋棋（Pₙ）标记的素数坐标格子时，攻击力与移动力临时翻倍。 ‌斐波那契共鸣‌：斐波那契兔子（F）在吃掉由分数祭司（½）分解后的棋子时（就是吃队友），可额外获得一次移动机会。 ‌几何协同‌：几何骑士（△□○）在吃掉棋子并将数值转为面积后，若该面积与虚数棋子（i）接触的格子相匹配（如圆形面积对应虚数棋子的“骑士跳”路径），则虚数棋子下次移动不消耗步数。 ‌代数融合‌：代数未知数（𝑥）每次公布“线索”后，若该方程能被AI神经网络（α）解析，则AI神经网络下回合预测准确率提升。 ‌日历同步‌：希伯来日历棋（☽）在移动至特定月份时，若该月份与矩阵方块[M]当前形成的矩阵行列式值相对应，则矩阵方块可额外吸收一次周围棋子数值。

新增羁绊

普通羁绊 ‌微积分联盟‌：导数棋子与积分棋子相邻时，两者数值互增。 ‌集合论双子‌：并集棋子与补集棋子同时存在时，防御力提升。 ‌虚数实数交织‌：虚数棋子与任意实数棋子相邻时，攻击力提升。

特殊羁绊 ‌量子纠缠矩阵‌：量子纠缠对与矩阵先知同时存在时，矩阵先知建立的矩阵效果翻倍。 ‌拓扑变形守护‌：拓扑变形者与公约数守卫相邻时，公约数守卫的防御力大幅提升。 ‌质数刺客与几何骑士‌：质数刺客与几何骑士相邻时，质数刺客的移动力增加，几何骑士的攻击力提升。

联动羁绊 ‌质数螺旋联盟‌：质数刺客（ℙ）与素数螺旋棋（Pₙ）相邻时，两者均获得「素数强化」（防御力+20%，攻击力+15%）。 ‌分数与几何‌：分数祭司（½）与几何骑士（△□○）形成羁绊时，分数祭司分解目标棋子后，几何骑士可额外将其数值转化为一种几何形状的面积增益（如三角形面积增益攻击力，正方形面积增益防御力）。 ‌虚数与斐波‌：虚数棋子（i）与斐波那契兔子（F）在同一回合内分别移动至相邻格子时，触发「时空扭曲」，使斐波那契兔子下回合能够跳过一次步数限制，直接移动至任意可达格子。 ‌代数与神经‌：代数未知数（𝑥）与AI神经网络（α）形成羁绊时，代数未知数每次移动后公布的“线索”将作为AI神经网络学习的一部分，提升其后续预测的准确性。 ‌日历矩阵‌：希伯来日历棋（☽）与矩阵先知（⊠）在同一月份内同时行动时，矩阵先知建立的矩阵效果将额外持续一回合，并吸收更多周围棋子数值。

跨文化联动羁绊 ‌丝绸之路：东西交融‌：与中国象棋中的“马”或日本将棋中的“香车”形成羁绊时，几何骑士（△□○）可额外获得一次“弧形绕过”移动能力，模拟丝绸之路上的驼队绕行沙丘。 ‌智慧之光：东西方学者‌：卡巴拉学者（卡巴拉路径棋的持有者）与代表东方智慧的“智者”（如中国象棋中的“士”或国际象棋中的“象”）形成羁绊时，双方均获得「智慧共鸣」（法强+15%，技能冷却时间-10%）。

隐藏羁绊 ‌智慧之树守护者‌：卡巴拉路径棋与任意其他棋类棋子形成羁绊时，随机触发一个生命之树质点的效果。 ‌未解代数之谜‌：代数未知数与任意棋类棋子形成羁绊时，有一定概率使敌方一个棋子陷入混乱状态。

文道弈（自创游戏）扩展包 一、汉字结构系（40枚） ‌1. 基础构件（20枚）‌

‌笔画棋组‌

‌横‌：直线移动，无视障碍，但无法穿越敌方单位。 ‌竖‌：垂直移动，可穿越敌方单位及障碍，特定情况下可击落空中单位。 ‌撇‌：斜向三格移动并突刺，附带破甲效果。 ‌捺‌：扇形范围内移动并溅射伤害，击退敌人。 ‌点‌：快速标记目标，无需移动，后续攻击必中。 ‌提‌：牵引友方棋子至身边，自身不移动。 ‌折‌：路径转向攻击，最多三次弹射，移动方式灵活多变。 ‌钩‌：强制拉近敌方单位至身边，自身不移动。 ‌弯‌：弧形范围内移动并控制，减速效果。 ‌卧钩‌：地面陷阱，无需移动，束缚敌人2回合。 ‌部首棋组‌

‌氵‌：召唤水流改变地形，自身可沿水流移动。 ‌火‌：持续燃烧伤害，可蔓延至木质区域，自身移动不受影响。 ‌木‌：生成障碍物，自身无法穿越但可阻挡敌方。 ‌钅‌：破防攻击，无视护甲，移动方式与普通棋子相同。 ‌礻‌：范围内友军获得护盾，自身不移动。 ‌彳‌：加速移动，跨越地形障碍。 ‌心‌：解除负面状态并反制精神攻击，自身不移动。 ‌手‌：抢夺敌方道具或增益，移动至目标身边。 ‌雨‌：范围治疗并清除燃烧效果，自身不移动。 ‌山‌：召唤不可摧毁地形，阻挡路径，自身可沿地形边缘移动。 ‌专属词条‌：笔画与部首的灵活运用，形成独特的攻防体系。

‌羁绊‌：当同一棋局中同时存在多个笔画或部首棋子时，可触发额外效果，如增加攻击力或防御力。

‌2. 复合文字（20枚）‌

‌自然演化‌

‌森‌：召唤树林，自身可隐匿于树林中移动。 ‌焱‌：爆炸连锁反应，无需移动即可攻击。 ‌淼‌：大面积水域，自身可在水域中快速移动。 ‌垚‌：地形隆起形成高地，自身可占据高地获得优势。 ‌鑫‌：金属共鸣，反弹物理伤害，自身移动方式与普通棋子相同。 ‌人文造字‌

‌武‌：强制单挑领域，双方在同一位置进行战斗，移动受限。 ‌信‌：契约锁定，双方共享伤害，移动方式与普通棋子相同。 ‌弈‌：复制当前棋局镜像迷惑对手，自身不移动。 ‌匠‌：修复受损棋子并强化耐久，自身不移动。 ‌书‌：记录敌方技能，下一回合复现，移动方式与普通棋子相同。 ‌专属词条‌：复合文字拥有强大的特殊效果，可改变战场局势。

‌羁绊‌：当同一棋局中同时存在多个复合文字棋子时，可触发联动效果，如增加技能触发概率或提升技能威力。

二、文学智慧系（48枚） ‌1. 成语具现（24枚）‌

‌战术类‌

‌暗度陈仓‌：隐身移动至敌方后排，无视障碍。 ‌釜底抽薪‌：无需移动，永久移除敌方一个增益。 ‌声东击西‌：制造幻象吸引火力，自身可趁机移动或攻击。 ‌围魏救赵‌：强制敌方攻击友军，自身不移动。 ‌金蝉脱壳‌：免疫一次致命伤害，移动方式与普通棋子相同。 ‌自然类‌

‌风卷残云‌：大范围击退+地形清除，自身可跟随风势移动。 ‌水落石出‌：揭露所有隐藏单位/陷阱，自身不移动。 ‌星火燎原‌：点燃全图草地类地形，自身可沿火势移动。 ‌铁树开花‌：逆转属性克制关系，移动方式与普通棋子相同。 ‌石破天惊‌：对护甲单位造成双倍伤害，无需移动即可攻击。 ‌专属词条‌：成语具现拥有独特的战术和自然效果，可灵活应对各种战场情况。

‌羁绊‌：当同一棋局中同时存在多个成语具现棋子时，可触发成语组合效果，如增加额外伤害或控制效果。

‌2. 诗词意境（24枚）‌

‌五言诗境‌

‌白日依山尽‌：落日斩杀残血单位，无需移动即可攻击。 ‌野火烧不尽‌：延时3回合的燃烧伤害，自身可沿火势移动。 ‌红豆生南国‌：生成持续治疗领域，自身不移动。 ‌大漠孤烟直‌：纵向贯穿全屏攻击，移动轨迹直线。 ‌月出惊山鸟‌：群体沉默效果，自身不移动。 ‌七言诗境‌

‌千树万树梨花开‌：冰冻爆炸+减速领域，自身可在领域内自由移动。 ‌轻舟已过万重山‌：连续位移叠加伤害，移动方式灵活多变。 ‌铜雀春深锁二乔‌：禁锢敌方核心单位，自身不移动。 ‌黑云压城城欲摧‌：范围压制并降低防御，自身可趁机攻击。 ‌春风不度玉门关‌：生成单向屏障，自身可穿越屏障移动。 ‌特殊联动‌

‌一江春水‌：引导水流改变战场流向，自身可沿水流移动。 ‌万里长征‌：强化友方移动力至极限，自身不移动但可影响友方。 ‌飞流直下‌：垂直瀑布冲击+击飞效果，无需移动即可攻击。 ‌晴空一鹤‌：召唤飞行单位侦察全场，飞行单位可自由移动。 ‌专属词条‌：诗词意境棋子拥有独特的诗词效果和意境领域，可影响战场环境。

‌羁绊‌：当同一棋局中同时存在多个诗词意境棋子时，可触发诗词组合效果，如增加治疗效果或提升攻击力。

三、天地万象系（40枚） ‌1. 自然法则（20枚）‌

‌天象棋‌

‌雷暴‌：连锁闪电攻击导电单位，无需移动即可攻击。 ‌虹桥‌：连接两地点供瞬移，自身可沿虹桥瞬移。 ‌极光‌：随机混乱敌方指令，无需移动即可发动。 ‌日蚀‌：降低全图视野和命中率，自身不受影响。 ‌月相‌：周期性强化/削弱魔法伤害，移动方式与普通棋子相同。 ‌地理棋‌

‌龙脉‌：能量节点，周期性爆发能量，自身可占据节点获得增益。 ‌溶洞‌：腐蚀敌方护甲并降低移动，自身可在溶洞地形中快速移动。 ‌冰川‌：滑移地形，改变移动轨迹，自身可在冰川上自由滑行。 ‌沙漠‌：持续流失生命但强化物理攻击，自身在沙漠中移动速度减慢但攻击力提升。 ‌沼泽‌：束缚+中毒双重效果，自身在沼泽中移动速度减慢但可攻击敌人。 ‌专属词条‌：自然法则棋子拥有强大的自然力量和地形效果，可改变战场环境。

‌羁绊‌：当同一棋局中同时存在多个自然法则棋子时，可触发自然组合效果，如增加能量爆发概率或提升地形影响效果。

‌2. 文明造物（20枚）‌

‌器物棋‌

‌司南‌：强制敌方集火指定目标，自身不移动但可影响敌方攻击。 ‌漏刻‌：延时陷阱，3回合后触发，自身不移动但可设置陷阱。 ‌浑仪‌：反转棋盘重力方向，自身不受影响但可影响其他棋子移动。 ‌罗盘‌：揭露隐形单位并标记弱点，自身不移动但可侦查敌方。 ‌燧石‌：点燃武器附加燃烧伤害，移动方式与普通棋子相同但攻击附带火焰效果。 ‌建筑棋‌

‌长城‌：直线无敌防御墙，持续3回合，自身可沿城墙移动或驻守。 ‌运河‌：分割战场并强化水系技能，自身可在运河中快速移动。 ‌天坛‌：群体净化+免疫控制，自身不移动但可为友方提供增益。 ‌地库‌：存储并加倍释放能量，自身不移动但可影响能量释放。 ‌烽火台‌：预警敌方行动，提前3回合显示敌方关键技能释放位置，自身不移动但可提供全局视野。 ‌铜鼎‌：吸收敌方攻击能量并反弹，自身不移动但可储存伤害。 ‌竹简‌：记录敌方技能并随机释放一次，移动方式与普通棋子相同。 ‌陶俑‌：召唤可操控的傀儡单位，傀儡可自由移动但无法攻击。 ‌丝绸‌：降低敌方攻击速度并缠绕目标，自身不移动但可影响敌方行动。 ‌建筑棋（续）‌

‌烽燧‌（烽火台升级版）：预警+反制，敌方在预警范围内释放技能会被打断，自身不移动但可影响敌方施法。 ‌栈道‌：在悬崖或水域上架设临时通道，友方可沿栈道移动，自身可自由调整栈道位置。 ‌石桥‌：永久性桥梁，可跨越地形障碍，自身可沿桥梁移动或驻守。 ‌水车‌：周期性恢复友方单位生命值，自身不移动但可提供持续治疗。 ‌牌坊‌：提升友方士气，增加攻击力与移动速度，自身不移动但可提供增益光环。 ‌专属词条‌：文明造物棋子可提供战略支援、地形改造或能量储存，影响战局走向。 ‌羁绊‌：当同一棋局中同时存在多个文明造物棋子时，可触发“文明传承”效果，如提升建筑耐久度或增强器物技能效果。 词条 ‌1. 文道弈专属词条 - 笔墨飞舞‌

描述：文道弈棋子在战场上移动时，会留下墨迹，对经过的敌人造成持续伤害，并降低其移动速度。 ‌2. 文道智慧 - 策略升华‌

描述：文道弈棋子在战斗中不断积累经验，每击败一个敌人，所有文道弈棋子的策略值提升，策略值可用于发动更强大的技能。 ‌3. 棋谱传承 - 历史回响‌

描述：当场上存在多个文道弈棋子时，它们可以共享棋谱中的战术布局，提升全体棋子的防御力和生命恢复速度。 ‌4. 墨韵连环 - 羁绊联动‌

描述：文道弈棋子在攻击时，有一定概率触发墨韵连环效果，对目标及其周围敌人造成额外伤害，并有一定概率造成眩晕。 ‌5. 文道之心 - 领袖光环‌

描述：文道弈的核心棋子（如特定的文道弈将军或文士）在场时，所有文道弈棋子攻击力提升，并获得额外的暴击概率。 羁绊 ‌1. 棋盘诗画 - 文道弈与艺术共鸣‌

描述：当文道弈棋子与围棋或五子棋棋子同时存在时，会触发棋盘诗画效果，战场上随机位置出现艺术符号，对周围敌人造成伤害并降低其属性。 ‌2. 文武双全 - 文道弈与军棋联盟‌

描述：文道弈棋子与军棋棋子形成联盟，所有棋子获得额外的生命值和防御力加成，同时文道弈棋子的策略值恢复速度提升。 ‌3. 笔墨与刀锋 - 文道弈与象棋协同‌

描述：文道弈棋子与中国象棋棋子协同作战，当象棋棋子发动攻击时，文道弈棋子有一定概率触发额外的策略攻击，对目标造成额外伤害。 ‌4. 智慧交织 - 文道弈与国际象棋共鸣‌

描述：文道弈棋子与国际象棋棋子共同战斗时，所有棋子的策略值和技能冷却时间减少，提升整体战斗效率。 ‌5. 文道弈之阵 - 全棋类联动‌

描述：当战场上存在至少五个不同棋类的文道弈棋子时，触发文道弈之阵效果，所有文道弈棋子获得额外的攻击力、防御力和生命值加成，并提升技能触发概率。 ‌6. 棋圣之佑 - 文道弈棋圣降临‌

描述：在特定条件下（如击败一定数量的敌人或完成特定任务），随机一个文道弈棋子进化为棋圣，棋圣在场时，所有文道弈棋子获得额外的护盾和免伤效果，并提升全体棋子的暴击伤害。

文道弈扩展——文渊劫变（击败所有BOSS一次后触发） 随机词条系统 ‌正向词条（抽取获得）‌

‌笔走龙蛇‌：移动路径留下持续1回合的墨痕，触碰的敌人减速30%。 ‌才高八斗‌：成语类棋子技能范围+2格。 ‌金石为开‌：建筑类棋子获得30%伤害反弹。 ‌墨韵千秋‌：每次使用诗词技能后，随机1个友军获得「诗兴」状态（暴击率+15%）。 ‌天工巧夺‌：文明造物类棋子可额外存储1次技能。 ‌负面词条（BOSS赋予）‌

‌错简乱编‌：15%概率使技能目标偏移至相邻单位。 ‌焚书坑儒‌：每回合开始时，随机1个文学类棋子进入「禁言」状态（无法释放技能）。 ‌碑裂石枯‌：自然类棋子每移动3次损失10%最大生命。 ‌六书失传‌：部首类棋子无法触发元素相克效果。 二、动态羁绊系统 ‌1. 文字之道‌

‌单字成军‌（3个独体字棋子）：所有笔画攻击附带「破甲」效果。 ‌说文解字‌（2个部首+2个偏旁）：触发元素反应时追加一次15%生命值的真实伤害。 ‌2. 文明兴衰‌

‌青铜时代‌（铜鼎+司南+甲骨）：敌方在文明造物3格内攻击时，有20%概率触发「文明震慑」（打断技能）。 ‌礼崩乐坏‌（烽火台+牌坊+残简）：每损失一个建筑类棋子，存活友军攻击力+25%。 ‌3. 天地共鸣‌

‌雷雨作砚‌（雷暴棋+水车+毛笔）：雷暴范围扩大50%，且在水域中传导伤害。 ‌山河为谱‌（山脉+河流+古琴）：地形效果持续时间+2回合，并随机生成1个临时增益区域。