Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Есть у Вас предложения по логике кода шахмат на C++? #include #include #include #include…

  1. User

    Есть у Вас предложения по логике кода шахмат на C++?

    #include #include #include #include

    using namespace std;

    void FillArray(char **arr, int size) { for (int i = 0; i < size; i++)//инициализация второго измерения { arr[i] = new char[size]; }

    arr[0][0] = 'L';//ручное заполнение основных фигур
    arr[0][1] = 'K';
    arr[0][2] = 'S';
    arr[0][3] = '@';
    arr[0][4] = 'F';
    arr[0][5] = 'S';
    arr[0][6] = 'K';
    arr[0][7] = 'L';
    
    for (int i = 0; i < size; i++)//автоматическое заполнение побочных фигур (пешек)
    {
            arr[1][i] = 'P';
    }
    
    for (int i = 2; i < size - 2; i++)//заполнение пустого поля для возможности проверок
    {
            for (int y = 0; y < size; y++)
            {
                    arr[i][y] = '*';
            }
    }
    
    for (int i = 0; i < size; i++)//автоматическое заполнение побочных фигур на экранной стороне (пешек)
    {
            arr[6][i] = 'P';
    }
    
    arr[7][0] = 'L';//ручное заполнение основных фигур на экранной стороне
    arr[7][1] = 'K';
    arr[7][2] = 'S';
    arr[7][3] = '@';
    arr[7][4] = 'F';
    arr[7][5] = 'S';
    arr[7][6] = 'K';
    arr[7][7] = 'L';
    

    }

    void DisplayChessBoard(char **arr, int size) { cout << "\t\t\t\t\t A B C D E F G H" << endl; cout << "\t\t\t\t\t _____________________________________" << endl; for (int i = 0; i < size ; i++) { cout << endl; cout << "\t\t\t\t\t |\t\t\t\t |"; cout << endl; for (int y = 0; y < size; y++) { if (y == 0) { cout << "\t\t\t\t\t" << i + 1 << " |" << " " << arr[i][y] << " "; } else if (y == 7) { cout << arr[i][y] << " " << "| " << i + 1; } else { cout << arr[i][y] << " "; } } } cout << "\n\n\t\t\t\t\t _____________________________________" << endl; cout << "\n\t\t\t\t\t A B C D E F G H" << endl << endl << endl << endl; }

    void Logic(char** arr, int size) { string name1, name2; int pick;

    while (true)
    {
            cout << "\tИгрок 1 (снизу), назовитесь: ";
            cin >> name1;
            cout << "\tИгрок 2 (сверху), назовитесь: ";
            cin >> name2;
    
            if (name1 == name2)
            {
                    cout << "\n\tОшибка! Имена не могут совпадать!" << endl << endl;
            }
            else
            {
                    break;
            }
    }
    
    cout << endl;
    
    pick = rand() & 2;
    
    DisplayChessBoard(arr, size);
    
    if (pick == 0)
    {
    
    }
    else if (pick == 1)
    {
    
    }
    

    }

    int main() { setlocale(LC_ALL, "ru"); srand(unsigned(time(NULL)));

    int size = 8;
    
    char** arr = new char*[size];
    
    cout << "\tОбозначения: " << endl << endl << endl;
    cout << "\t\tПешка: P, первый ход либо 2 раза вперед, либо просто вперед, далее просто вперед, убивает на 1 клетку по диагонали, не может ходить назад, при достижении противоположенной стороны становится ферзем." << endl << endl;
    cout << "\t\tКонь: K, ходит буквой \"Г\" и убивает, если на конец буквы попал враг." << endl << endl;
    cout << "\t\tСлон: S, ходит сколько вам угодно по диагонали, убивает на любом отрезке своего пути." << endl << endl;
    cout << "\t\tЛадья: L, ходит сколько вам угодно по вертикали и горизонтали, убивает на любом отрезке своего пути." << endl << endl;
    cout << "\t\tФерзь: F, ходит сколько вам угодно по вертикали, горизонтали и диагонали, убивает на любом отрезке своего пути." << endl << endl;
    cout << "\t\tКороль: @, ходит на 1 клетку вокруг себя, убивает на любом отрезке своего пути." << endl << endl << endl << endl << endl << endl << endl;
    
    FillArray(arr, size);
    
    try
    {
            Logic(arr, size);
    }
    catch (const exception &ex)
    {
            cout << "\n\tОшибка: " << ex.what() << endl << endl;
    }
    
    return 0;
    

    }

    Да, я знаю, подход хреновый, я еще изучаю плюсы. сейчас на ум пришло представить каждую фигуру как объект, который хранит координаты и цвет, но хз, сработает ли это? но тогда и весь массив придется представлять не как чар а как обьекты и выходит что мне нужно звездочку обьектом делать?

  2. Assistant

    Здравствуйте!

    Отлично, что вы начали разрабатывать шахматы на C++ и уже размышляете о структуре кода. Действительно, переход от простой двумерной массивной структуры к объектно-ориентированному подходу значительно повысит гибкость и расширяемость вашего приложения. Ниже приведены рекомендации и примерная логика организации кода для реализации шахматной игры на C++.

    1. Основные компоненты шахматной игры

    Классы и объекты

    1. Фигура (Piece): базовый класс для всех типов фигур (пешка, конь, слон, ладья, ферзь, король). Этот класс может содержать общие свойства и методы, такие как положение на доске, цвет, возможные ходы и метод для отображения символа.

    2. Конкретные фигуры (Pawn, Knight, Bishop, Rook, Queen, King): наследники базового класса Piece, которые реализуют специфическую логику движения и захвата для каждой фигуры.

    3. Доска (Board): класс, представляющий игровую доску. Он может содержать двумерный массив указателей на объекты Piece или nullptr для пустых клеток. Класс Board также отвечает за отображение доски и проверку легальности ходов.

    4. Игра (Game): класс, управляющий процессом игры, обменом ходами между игроками, проверкой шаха и мата и т.д.

    Примерная структура классов

    #include <iostream>
    #include <vector>
    #include <memory>
    
    // Определение цветов фигур
    enum class Color { White, Black };
    
    // Базовый класс для фигур
    class Piece {
    protected:
        Color color;
        int x, y; // Координаты на доске
    
    public:
        Piece(Color c, int xPos, int yPos) : color(c), x(xPos), y(yPos) {}
        virtual ~Piece() {}
    
        Color getColor() const { return color; }
        int getX() const { return x; }
        int getY() const { return y; }
        void setPosition(int newX, int newY) { x = newX; y = newY; }
    
        // Чисто виртуальный метод для отображения символа фигуры
        virtual char getSymbol() const = 0;
    
        // Чисто виртуальный метод для получения возможных ходов
        virtual std::vector<std::pair<int, int>> getPossibleMoves(const std::vector<std::vector<std::shared_ptr<Piece>>> &board) const = 0;
    };
    
    // Пример для Пешки
    class Pawn : public Piece {
    public:
        Pawn(Color c, int xPos, int yPos) : Piece(c, xPos, yPos) {}
    
        char getSymbol() const override {
            return (color == Color::White) ? 'P' : 'p';
        }
    
        std::vector<std::pair<int, int>> getPossibleMoves(const std::vector<std::vector<std::shared_ptr<Piece>>> &board) const override {
            std::vector<std::pair<int, int>> moves;
            // Реализуйте логику возможных ходов для пешки
            // Например, для белых пешек движение вверх по доске
            int direction = (color == Color::White) ? 1 : -1;
            // Одно деление вперед
            if (board[x + direction][y] == nullptr) {
                moves.emplace_back(x + direction, y);
                // Два деления вперед с первого хода
                if ((color == Color::White && x == 1) || (color == Color::Black && x == 6)) {
                    if (board[x + 2 * direction][y] == nullptr)
                        moves.emplace_back(x + 2 * direction, y);
                }
            }
            // Захват по диагонали
            if (y > 0 && board[x + direction][y - 1] != nullptr && board[x + direction][y - 1]->getColor() != color)
                moves.emplace_back(x + direction, y - 1);
            if (y < 7 && board[x + direction][y + 1] != nullptr && board[x + direction][y + 1]->getColor() != color)
                moves.emplace_back(x + direction, y + 1);
            
            return moves;
        }
    };
    
    // Другие классы фигур (Knight, Bishop, Rook, Queen, King) должны наследовать от Piece и реализовывать свои методы
    
    // Класс доски
    class Board {
    private:
        std::vector<std::vector<std::shared_ptr<Piece>>> grid;
    
    public:
        Board() : grid(8, std::vector<std::shared_ptr<Piece>>(8, nullptr)) {
            initialize();
        }
    
        void initialize() {
            // Инициализация фигур на доске
            // Пример для пешек
            for (int i = 0; i < 8; ++i) {
                grid[1][i] = std::make_shared<Pawn>(Color::White, 1, i);
                grid[6][i] = std::make_shared<Pawn>(Color::Black, 6, i);
            }
            // Инициализация других фигур (конь, слон, ладья, ферзь, король)
            // ...
        }
    
        void display() const {
            std::cout << "  A B C D E F G H\n";
            for (int i = 7; i >= 0; --i) {
                std::cout << i + 1 << " ";
                for (int j = 0; j < 8; ++j) {
                    if (grid[i][j] != nullptr)
                        std::cout << grid[i][j]->getSymbol() << " ";
                    else
                        std::cout << ". ";
                }
                std::cout << i + 1 << "\n";
            }
            std::cout << "  A B C D E F G H\n";
        }
    
        std::shared_ptr<Piece> getPiece(int x, int y) const {
            return grid[x][y];
        }
    
        void movePiece(int fromX, int fromY, int toX, int toY) {
            // Простая реализация перемещения без проверки легальности
            grid[toX][toY] = grid[fromX][fromY];
            if (grid[fromX][fromY] != nullptr)
                grid[fromX][fromY]->setPosition(toX, toY);
            grid[fromX][fromY] = nullptr;
        }
    
        // Дополнительные методы для проверки шаха, мата и т.д.
    };
    
    // Класс игры
    class Game {
    private:
        Board board;
        Color currentPlayer;
    
    public:
        Game() : currentPlayer(Color::White) {}
    
        void start() {
            while (true) {
                board.display();
                // Запрос хода у текущего игрока
                std::string move;
                std::cout << ((currentPlayer == Color::White) ? "Белый" : "Черный") << " ход: ";
                std::cin >> move;
                // Преобразование ввода в координаты
                if (move.length() != 4) {
                    std::cout << "Неверный формат хода. Используйте, например, E2E4.\n";
                    continue;
                }
                int fromX = move[1] - '1';
                int fromY = move[0] - 'A';
                int toX = move[3] - '1';
                int toY = move[2] - 'A';
    
                // Проверка существования фигуры и цвета
                auto piece = board.getPiece(fromX, fromY);
                if (piece == nullptr) {
                    std::cout << "Нет фигуры на заданной позиции.\n";
                    continue;
                }
                if (piece->getColor() != currentPlayer) {
                    std::cout << "Это не ваша фигура.\n";
                    continue;
                }
    
                // Получение возможных ходов и проверка
                auto possibleMoves = piece->getPossibleMoves(board.getGrid());
                bool valid = false;
                for (const auto &m : possibleMoves) {
                    if (m.first == toX && m.second == toY) {
                        valid = true;
                        break;
                    }
                }
                if (!valid) {
                    std::cout << "Недопустимый ход для этой фигуры.\n";
                    continue;
                }
    
                // Выполнение хода
                board.movePiece(fromX, fromY, toX, toY);
                // Проверка на шах, мат и т.д.
    
                // Смена игрока
                currentPlayer = (currentPlayer == Color::White) ? Color::Black : Color::White;
            }
        }
    };
    

    Пояснения к структуре

    1. Умные указатели (std::shared_ptr): Использование умных указателей позволяет автоматически управлять памятью и избегать утечек. В данном случае std::shared_ptr подходит, так как несколько частей программы могут ссылаться на одну и ту же фигуру.

    2. Методы фигур: Каждый тип фигуры реализует метод getPossibleMoves, который возвращает список допустимых ходов на основе текущего состояния доски. Это позволяет легко расширять логику движения для каждой фигуры.

    3. Класс Board: Хранит состояние доски и предоставляет методы для инициализации, отображения и перемещения фигур.

    4. Класс Game: Управляет игровым процессом, обрабатывает ввод игроков и выполняет ходы.

    2. Рекомендации по улучшению текущего кода

    1. Переход на объектно-ориентированный подход: Вместо использования двумерного массива char, как вы сделали в текущем коде, рекомендуется использовать классы для представления фигур и доски. Это повысит читаемость и расширяемость кода.

    2. Использование перечислений (enum): Вместо символов для обозначения фигур ('P', 'K' и т.д.) используйте перечисления для большей ясности и предотвращения ошибок.

    3. Обработка пользовательского ввода: Реализуйте более надежную систему ввода и проверки ходов, чтобы предотвратить некорректные или незаконные ходы.

    4. Разделение кода на файлы: По мере роста проекта разделяйте код на заголовочные (.h) и исходные (.cpp) файлы для лучшей организации.

    5. Дополнительные функции: Добавьте функции для проверки шаха, мата, рокировки, взятия на проходе и превращения пешки.

    3. Дополнительные советы

    • Изучите паттерны проектирования: Некоторые паттерны, такие как "Фабрика" (Factory) или "Стратегия" (Strategy), могут быть полезны при разработке шахматной игры.

    • Тестирование: Разрабатывайте модульные тесты для проверки логики движения фигур и других компонентов игры.

    • Используйте стандартные библиотеки: Стандартная библиотека C++ предоставляет множество полезных инструментов, таких как контейнеры (std::vector), умные указатели и алгоритмы, которые облегчат разработку.

    • Рефакторинг: По мере добавления новых функций периодически пересматривайте и улучшайте структуру кода.

    Пример инициализации доски

    Вот пример того, как можно инициализировать фигуры на доске в классе Board:

    void initialize() {
        // Пешки
        for (int i = 0; i < 8; ++i) {
            grid[1][i] = std::make_shared<Pawn>(Color::White, 1, i);
            grid[6][i] = std::make_shared<Pawn>(Color::Black, 6, i);
        }
        // Ладьи
        grid[0][0] = std::make_shared<Rook>(Color::White, 0, 0);
        grid[0][7] = std::make_shared<Rook>(Color::White, 0, 7);
        grid[7][0] = std::make_shared<Rook>(Color::Black, 7, 0);
        grid[7][7] = std::make_shared<Rook>(Color::Black, 7, 7);
        // Конь
        grid[0][1] = std::make_shared<Knight>(Color::White, 0, 1);
        grid[0][6] = std::make_shared<Knight>(Color::White, 0, 6);
        grid[7][1] = std::make_shared<Knight>(Color::Black, 7, 1);
        grid[7][6] = std::make_shared<Knight>(Color::Black, 7, 6);
        // Слоны
        grid[0][2] = std::make_shared<Bishop>(Color::White, 0, 2);
        grid[0][5] = std::make_shared<Bishop>(Color::White, 0, 5);
        grid[7][2] = std::make_shared<Bishop>(Color::Black, 7, 2);
        grid[7][5] = std::make_shared<Bishop>(Color::Black, 7, 5);
        // Ферзи
        grid[0][3] = std::make_shared<Queen>(Color::White, 0, 3);
        grid[7][3] = std::make_shared<Queen>(Color::Black, 7, 3);
        // Короли
        grid[0][4] = std::make_shared<King>(Color::White, 0, 4);
        grid[7][4] = std::make_shared<King>(Color::Black, 7, 4);
    }
    

    4. Заключение

    Переход на объектно-ориентированную архитектуру значительно улучшит структуру вашего шахматного приложения и упростит дальнейшее развитие функциональности. Начните с базовых классов и постепенно добавляйте специфику для каждой фигуры и механики игры. Не бойтесь экспериментировать и обращаться к учебным материалам по C++ и объективно-ориентированному программированию. Удачи в разработке!