用c++实现回合制战斗类游戏的设计，包括敌我战况，人物战技，敌方技能，场景变换，以及战斗回合的变化

回合制战斗类游戏的设计需要考虑以下几个方面：

1. 敌我战况：需要定义敌方和我方的角色属性，如生命值、攻击力、防御力等，并在战斗开始时初始化它们的属性值。

2. 人物战技和敌方技能：需要定义每个角色的技能，并为它们设置相应的属性值，如攻击力、命中率、消耗的魔法值等。在战斗过程中，每个角色根据自己的行动顺序选择相应的技能，向敌方角色发起攻击或者进行防御。

3. 场景变换：可以在战斗中设置不同的场景，如森林、沙漠等，并为每个场景设置相应的属性值，如攻击力加成、防御力加成等。在切换场景时，需要重新计算所有角色的属性值。

4. 战斗回合的变化：在战斗开始时，可以按照角色的速度属性值确定行动顺序，每个角色在自己的回合内可以选择攻击或者防御，然后轮到下一个角色行动，直到所有角色都行动完毕，然后开始下一轮战斗。

使用C++实现回合制战斗类游戏的设计可以参考以下代码：

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

// 定义角色类
class Character {
public:
    Character(string name, int hp, int atk, int def, int speed) {
        this->name = name;
        this->hp = hp;
        this->atk = atk;
        this->def = def;
        this->speed = speed;
    }

    void attack(Character& target) {
        int damage = this->atk - target.def;
        if (damage < 0) {
            damage = 0;
        }
        target.hp -= damage;
        cout << this->name << "攻击了" << target.name << "，造成了" << damage << "点伤害。" << endl;
    }

    void defend() {
        cout << this->name << "进行了防御。" << endl;
        this->def *= 2;
    }

    bool is_dead() {
        return this->hp <= 0;
    }

    string name;
    int hp;
    int atk;
    int def;
    int speed;
};

// 定义战斗场景类
class Scene {
public:
    Scene(string name, int atk_bonus, int def_bonus) {
        this->name = name;
        this->atk_bonus = atk_bonus;
        this->def_bonus = def_bonus;
    }

    void apply_bonus(Character& character) {
        character.atk += this->atk_bonus;
        character.def += this->def_bonus;
        cout << character.name << "进入了" << this->name << "场景，攻击力和防御力增加了。" << endl;
    }

    string name;
    int atk_bonus;
    int def_bonus;
};

// 定义战斗类
class Battle {
public:
    Battle(vector<Character>& enemies, vector<Character>& players, vector<Scene>& scenes) {
        this->enemies = enemies;
        this->players = players;
        this->scenes = scenes;
    }

    void start() {
        // 初始化敌我属性
        for (auto& enemy : this->enemies) {
            enemy.hp = rand() % 100 + 100;
            enemy.atk = rand() % 10 + 10;
            enemy.def = rand() % 10 + 10;
            enemy.speed = rand() % 10 + 10;
        }
        for (auto& player : this->players) {
            player.hp = rand() % 100 + 100;
            player.atk = rand() % 10 + 10;
            player.def = rand() % 10 + 10;
            player.speed = rand() % 10 + 10;
        }

        // 初始化回合顺序
        vector<Character*> characters;
        for (auto& enemy : this->enemies) {
            characters.push_back(&enemy);
        }
        for (auto& player : this->players) {
            characters.push_back(&player);
        }
        sort(characters.begin(), characters.end(), [](Character* a, Character* b) {
            return a->speed > b->speed;
        });

        // 开始战斗
        int round = 1;
        while (true) {
            cout << "第" << round << "回合开始。" << endl;
            for (auto& character : characters) {
                if (character->is_dead()) {
                    continue;
                }
                cout << character->name << "的回合。" << endl;
                if (character->atk > character->def) {
                    int target_index = rand() % this->enemies.size();
                    character->attack(this->enemies[target_index]);
                } else {
                    character->defend();
                }
            }
            if (this->is_game_over()) {
                break;
            }
            round++;
        }
    }

    bool is_game_over() {
        bool all_enemies_dead = true;
        for (auto& enemy : this->enemies) {
            if (!enemy.is_dead()) {
                all_enemies_dead = false;
                break;
            }
        }
        if (all_enemies_dead) {
            cout << "敌人全灭，战斗胜利！" << endl;
            return true;
        }
        bool all_players_dead = true;
        for (auto& player : this->players) {
            if (!player.is_dead()) {
                all_players_dead = false;
                break;
            }
        }
        if (all_players_dead) {
            cout << "我方全灭，战斗失败！" << endl;
            return true;
        }
        return false;
    }

    vector<Character> enemies;
    vector<Character> players;
    vector<Scene> scenes;
};

int main() {
    srand(time(nullptr));

    // 初始化敌我角色和场景
    vector<Character> enemies = {
        Character("小兵1", 0, 0, 0, 0),
        Character("小兵2", 0, 0, 0, 0),
        Character("BOSS", 0, 0, 0, 0)
    };
    vector<Character> players = {
        Character("战士", 0, 0, 0, 0),
        Character("法师", 0, 0, 0, 0),
        Character("牧师", 0, 0, 0, 0)
    };
    vector<Scene> scenes = {
        Scene("森林", 2, 2),
        Scene("沙漠", 3, 1)
    };

    // 开始战斗
    Battle battle(enemies, players, scenes);
    battle.start();

    return 0;
}

在上面的代码中，我们定义了角色类`Character`，包括角色的属性和攻击、防御等方法。我们还定义了战斗场景类`Scene`，包括场景的名称和攻击、防御加成等属性。最后，我们定义了战斗类`Battle`，包括敌我角色和场景等属性，以及战斗开始、回合顺序、战斗结束等方法。在`main`函数中，我们初始化了敌我角色和场景，并创建了`Battle`对象，然后开始战斗。

需要注意的是，上面的代码只是一个简单的示例，实际上回合制战斗类游戏的设计涉及到的内容还很多，如技能效果、状态机、AI等，需要根据具体情况进行设计和实现。