Перейти к основному содержимому

5.16. Примеры простых игр на Си

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Примеры простых игр на Си​

Простые игры на Си часто служат учебным мостом между теоретическим изучением синтаксиса и практическим применением полученных знаний. Они позволяют закрепить понимание циклов, условий, массивов, указателей, работы с файлами и вводом-выводом. При этом такие игры не требуют сложных графических библиотек или многопоточности. Достаточно стандартной библиотеки stdio.h и нескольких дополнительных заголовков, чтобы реализовать полностью функциональный игровой опыт в текстовом режиме.

Почему именно текстовые игры?​

Текстовый интерфейс — естественная среда для первых шагов в игровой разработке на Си. Он не требует подключения внешних зависимостей, не зависит от графических API и работает в любой консоли. Это упрощает отладку, тестирование и распространение программы: достаточно скомпилировать исходный файл и запустить исполняемый модуль. Текстовые игры также развивают воображение игрока, поскольку визуализация происходящего происходит в уме, а не на экране. Такой подход был характерен для ранних компьютерных игр 1970–1980-х годов, таких как Colossal Cave Adventure, Zork или Rogue. Эти игры заложили основы целых жанров — приключенческих квестов, интерактивной литератры и roguelike.

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

Общие принципы построения игр на Си​

Любая игра, независимо от сложности, состоит из нескольких базовых компонентов:

  • Игровое состояние — данные, описывающие текущую ситуацию: положение персонажа, счёт, уровень, инвентарь, карта мира и так далее.
  • Цикл игры — повторяющаяся последовательность действий: отображение состояния, ожидание ввода, обработка ввода, обновление состояния, проверка условий завершения.
  • Ввод от пользователя — способ взаимодействия игрока с программой: клавиши, команды, выбор из меню.
  • Обратная связь — вывод информации о результате действия: сообщения, изменения на экране, звуковые сигналы (в консоли — через символ \a).
  • Правила и логика — алгоритмы, определяющие, какие действия допустимы, как меняется состояние и когда игра заканчивается.

На языке Си все эти компоненты реализуются с помощью базовых конструкций: переменных, массивов, функций, условных операторов и циклов. Нет необходимости использовать объектно-ориентированные паттерны или сложные структуры данных — всё можно выразить через простые типы и линейную логику.

Игра «Угадай число»​

Игра «Угадай число» — одна из самых простых и интуитивно понятных программ, которую можно реализовать на любом языке программирования. Её суть заключается в следующем: компьютер загадывает случайное целое число в заданном диапазоне (например, от 1 до 100), а игрок пытается угадать это число за минимальное количество попыток. После каждой попытки программа сообщает, было ли введённое число больше или меньше загаданного. Игра завершается, когда игрок угадывает число или исчерпывает лимит попыток.

Эта игра демонстрирует работу со следующими концепциями языка Си:

  • генерация псевдослучайных чисел,
  • организация цикла с условием продолжения,
  • обработка пользовательского ввода,
  • сравнение значений и вывод результатов,
  • управление состоянием игры (счётчик попыток, текущее предположение).

Генерация случайного числа​

В языке Си для генерации псевдослучайных чисел используется функция rand() из стандартной библиотеки <stdlib.h>. Однако вызов rand() без предварительной инициализации генератора всегда будет возвращать одну и ту же последовательность чисел при каждом запуске программы. Чтобы избежать этого, необходимо инициализировать генератор с помощью функции srand(), передав ей значение, которое меняется от запуска к запуску. Чаще всего в качестве такого значения используется текущее время, полученное через функцию time() из библиотеки <time.h>.

Пример инициализации:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    srand(time(NULL));
    int secret = rand() % 100 + 1; // число от 1 до 100
    // ...
}

Здесь выражение rand() % 100 даёт остаток от деления случайного числа на 100, то есть значение от 0 до 99. Прибавление единицы смещает диапазон на один шаг вверх — от 1 до 100 включительно.

Основной игровой цикл​

Игровой процесс строится вокруг цикла while или for, внутри которого происходит чтение ввода, проверка условия победы и обновление счётчика попыток. Цикл продолжается до тех пор, пока игрок не угадает число или не превысит допустимое количество попыток.

Типичная структура:

int attempts = 0;
int max_attempts = 7;
int guess;

while (attempts < max_attempts) {
    printf("Введите ваше число: ");
    scanf("%d", &guess);
    attempts++;

    if (guess == secret) {
        printf("Поздравляем! Вы угадали число за %d попыток.\n", attempts);
        break;
    } else if (guess < secret) {
        printf("Слишком мало!\n");
    } else {
        printf("Слишком много!\n");
    }
}

if (attempts >= max_attempts && guess != secret) {
    printf("Вы исчерпали все попытки. Загаданное число было: %d\n", secret);
}

Этот фрагмент кода показывает, как организуется взаимодействие с пользователем. Функция scanf читает целое число из стандартного ввода и сохраняет его в переменную guess. Далее выполняются последовательные проверки: совпадает ли введённое значение с загаданным, меньше ли оно или больше. В зависимости от результата выводится соответствующее сообщение.

Обработка ошибок ввода​

Хотя в учебных примерах часто опускается проверка корректности ввода, в реальных программах важно учитывать возможность некорректных данных. Например, пользователь может ввести букву вместо числа. В таком случае scanf вернёт значение, отличное от 1, и переменная guess останется неинициализированной или сохранит предыдущее значение. Это может привести к неопределённому поведению.

Для повышения надёжности можно добавить проверку возврата scanf и очистку входного буфера:

if (scanf("%d", &guess) != 1) {
    printf("Некорректный ввод. Пожалуйста, введите целое число.\n");
    while (getchar() != '\n'); // очистка буфера
    continue; // переход к следующей итерации
}

Такой подход делает игру более устойчивой к ошибкам и учит хорошей практике написания безопасного кода.

Возможные расширения​

Базовая версия игры легко поддаётся модификации. Например:

  • Можно позволить игроку выбирать диапазон загадываемого числа.
  • Можно добавить режим «двух игроков», где один игрок загадывает число, а другой угадывает.
  • Можно сохранять рекорды в файл с помощью функций fopen, fprintf и fclose.
  • Можно реализовать меню выбора сложности: лёгкий (1–50, 8 попыток), средний (1–100, 7 попыток), сложный (1–1000, 10 попыток).

Каждое из этих улучшений требует применения новых возможностей языка Си: работы с файлами, дополнительных условий, функций для повторного использования логики. Таким образом, даже простая игра становится платформой для экспериментов и обучения.

Почему эта игра важна?​

«Угадай число» — не просто развлечение. Это первый шаг к пониманию того, как программа может поддерживать диалог с пользователем, хранить состояние, принимать решения и реагировать на действия. Эти принципы лежат в основе всех интерактивных приложений, включая сложные видеоигры. Освоив их на простом примере, начинающий программист получает уверенность в том, что способен создавать программы, которые «живут» и «отвечают».

Игра «Крестики-нолики»​

«Крестики-нолики» — это классическая стратегическая игра для двух игроков, разыгрываемая на квадратном поле 3×3. Один игрок использует символ «X» (крестик), другой — «O» (нолик). Игроки по очереди ставят свои символы в свободные клетки. Победителем становится тот, кто первым выстроит три своих символа в ряд — по горизонтали, вертикали или диагонали. Если все клетки заполнены, а победителя нет, игра завершается вничью.

Эта игра идеально подходит для реализации на языке Си, потому что она демонстрирует работу с:

  • двумерными массивами,
  • вложенными циклами,
  • логическими условиями множественного выбора,
  • функциями для разделения ответственности,
  • пользовательским вводом с проверкой корректности позиции.

Представление игрового поля​

В Си игровое поле удобно представлять как двумерный массив символов размером 3×3:

char board[3][3];

На старте игры каждая клетка инициализируется пустым значением — например, пробелом ' ' или цифрой, обозначающей номер клетки (для удобства ввода). Инициализация может выглядеть так:

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        board[i][j] = ' ';
    }
}

Такой подход позволяет легко обращаться к любой клетке по её координатам: board[row][col], где row — строка (0–2), col — столбец (0–2).

Отображение доски​

Функция вывода доски формирует наглядное текстовое представление поля. Она использует символы границ (|, -, +) для имитации сетки:

void print_board(char board[3][3]) {
    printf("\n");
    for (int i = 0; i < 3; i++) {
        printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
        if (i < 2) printf("-----------\n");
    }
    printf("\n");
}

Такой вывод помогает игроку ориентироваться и понимать текущее состояние игры. Чёткая визуализация — важная часть пользовательского опыта даже в консольных приложениях.

Ход игрока и валидация ввода​

Игрок делает ход, указывая координаты клетки — например, вводя «1 2» для второй строки и третьего столбца (если используется нумерация с нуля). Программа должна проверить:

  • находятся ли координаты в допустимом диапазоне (0–2),
  • свободна ли выбранная клетка.

Если оба условия выполнены, в клетку записывается символ текущего игрока ('X' или 'O'). В противном случае выводится сообщение об ошибке, и игроку предлагается повторить ввод.

Пример фрагмента:

int row, col;
printf("Игрок %c, введите строку и столбец (0-2): ", current_player);
scanf("%d %d", &row, &col);

if (row >= 0 && row < 3 && col >= 0 && col < 3 && board[row][col] == ' ') {
    board[row][col] = current_player;
    valid_move = 1;
} else {
    printf("Недопустимый ход. Попробуйте снова.\n");
}

Такая проверка предотвращает перезапись занятых клеток и выход за границы массива — распространённые источники ошибок в начинающих программах.

Проверка победы​

После каждого хода необходимо проверить, не достиг ли один из игроков трёх символов в ряд. Это можно сделать, проверив все возможные комбинации:

  • три горизонтальных ряда,
  • три вертикальных столбца,
  • две диагонали.

Функция проверки победы может быть реализована как серия условий:

int check_winner(char board[3][3], char player) {
    // Горизонтали
    for (int i = 0; i < 3; i++) {
        if (board[i][0] == player && board[i][1] == player && board[i][2] == player)
            return 1;
    }
    // Вертикали
    for (int j = 0; j < 3; j++) {
        if (board[0][j] == player && board[1][j] == player && board[2][j] == player)
            return 1;
    }
    // Диагонали
    if (board[0][0] == player && board[1][1] == player && board[2][2] == player)
        return 1;
    if (board[0][2] == player && board[1][1] == player && board[2][0] == player)
        return 1;

    return 0;
}

Если функция возвращает 1, текущий игрок выиграл. Игра завершается с соответствующим сообщением.

Проверка ничьей​

Если после очередного хода никто не выиграл, программа проверяет, остались ли свободные клетки. Если все клетки заполнены, объявляется ничья. Это можно реализовать отдельной функцией или внутри основного цикла, подсчитывая количество сделанных ходов (максимум — 9).

Основной игровой цикл​

Главный цикл игры чередует ходы между игроками, обновляет доску, проверяет условия завершения и выводит текущее состояние:

char current_player = 'X';
int game_over = 0;

while (!game_over) {
    print_board(board);
    make_move(board, current_player); // функция ввода и валидации

    if (check_winner(board, current_player)) {
        print_board(board);
        printf("Игрок %c победил!\n", current_player);
        game_over = 1;
    } else if (is_board_full(board)) {
        print_board(board);
        printf("Ничья!\n");
        game_over = 1;
    } else {
        current_player = (current_player == 'X') ? 'O' : 'X';
    }
}

Такая структура делает код читаемым и легко расширяемым. Каждая задача вынесена в отдельную функцию, что соответствует принципам модульного программирования.

Возможные улучшения​

Базовая версия «Крестиков-ноликов» может быть расширена множеством способов:

  • Добавление игры против компьютера с простой стратегией (например, случайный ход или защита от проигрыша).
  • Реализация меню: новая игра, правила, выход.
  • Поддержка разных размеров поля (4×4, 5×5) с динамическим выделением памяти.
  • Сохранение статистики побед в файл.
  • Использование цветового вывода через escape-последовательности ANSI (если терминал поддерживает).

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

Образовательная ценность​

«Крестики-нолики» учат мыслить в терминах состояний, переходов и правил. Они развивают навык декомпозиции задачи: вместо того чтобы писать всё в одной функции main, программист учится разделять логику на части — отображение, ввод, проверка, управление ходом. Это фундаментальный навык, необходимый для создания любых сложных систем, включая операционные системы, компиляторы и игровые движки.

Игра «Змейка» в текстовом режиме​

«Змейка» — одна из самых узнаваемых аркадных игр в истории. Её суть проста: игрок управляет змейкой, которая перемещается по полю, собирая еду (обычно обозначаемую символом * или o). При каждом сборе еды змейка удлиняется на один сегмент. Игра завершается, если змейка врезается в стену или в собственное тело.

В классической графической версии игра работает в реальном времени: змейка постоянно движется, а игрок лишь меняет направление. В консоли достичь такого поведения без потоков или специфичных системных вызовов сложно, но возможно — за счёт неблокирующего ввода или ограниченного ожидания. Однако для учебных целей часто используется упрощённый вариант: змейка делает один шаг за итерацию цикла, а игрок вводит направление перед каждым ходом. Такой подход сохраняет логику игры и демонстрирует ключевые концепции программирования на Си.

Представление змейки и игрового поля​

Игровое поле можно представить как двумерный массив символов фиксированного размера, например 20×20:

#define WIDTH 20
#define HEIGHT 10
char field[HEIGHT][WIDTH];

Змейка — это последовательность координат. Наиболее гибкий способ хранения — два массива: один для строк (y), другой для столбцов (x), или структура с массивом пар координат. Для простоты используем два отдельных массива и переменную length, указывающую текущую длину змейки:

#define MAX_LENGTH 200
int snake_x[MAX_LENGTH];
int snake_y[MAX_LENGTH];
int length = 3; // начальная длина

На старте змейка размещается в центре поля, например:

snake_x[0] = WIDTH / 2;
snake_y[0] = HEIGHT / 2;
snake_x[1] = WIDTH / 2 - 1;
snake_x[2] = WIDTH / 2 - 2;
// y остаётся одинаковым — змейка горизонтальна
for (int i = 0; i < length; i++) {
    snake_y[i] = HEIGHT / 2;
}

Еда — это одна пара координат, генерируемая случайным образом в свободной клетке:

int food_x, food_y;
place_food(); // функция, использующая rand() и проверку на пересечение со змеёй

Отображение игрового поля​

Функция отрисовки заполняет массив field пробелами, затем помещает символы змейки (например, # для тела и @ для головы) и еды (*):

void draw() {
    // Очистка поля
    for (int y = 0; y < HEIGHT; y++)
        for (int x = 0; x < WIDTH; x++)
            field[y][x] = ' ';

    // Еда
    field[food_y][food_x] = '*';

    // Змейка: сначала тело, потом голова поверх
    for (int i = 1; i < length; i++)
        field[snake_y[i]][snake_x[i]] = '#';
    field[snake_y[0]][snake_x[0]] = '@';

    // Вывод
    for (int y = 0; y < HEIGHT; y++) {
        for (int x = 0; x < WIDTH; x++)
            putchar(field[y][x]);
        putchar('\n');
    }
}

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

Движение змейки​

Движение реализуется сдвигом всех сегментов тела к предыдущему положению, начиная с хвоста и заканчивая шеей. Голова перемещается в новое положение в зависимости от текущего направления (up, down, left, right).

Пример логики движения:

// Сохраняем старую голову
int prev_x = snake_x[0];
int prev_y = snake_y[0];

// Обновляем голову
switch (direction) {
    case 'w': snake_y[0]--; break; // вверх
    case 's': snake_y[0]++; break; // вниз
    case 'a': snake_x[0]--; break; // влево
    case 'd': snake_x[0]++; break; // вправо
}

// Сдвигаем тело
for (int i = 1; i < length; i++) {
    int temp_x = snake_x[i];
    int temp_y = snake_y[i];
    snake_x[i] = prev_x;
    snake_y[i] = prev_y;
    prev_x = temp_x;
    prev_y = temp_y;
}

Этот алгоритм гарантирует, что каждый сегмент следует за предыдущим, сохраняя форму змейки.

Проверка коллизий​

После движения необходимо проверить, не вышла ли голова за границы поля или не попала ли в тело:

if (snake_x[0] < 0 || snake_x[0] >= WIDTH ||
    snake_y[0] < 0 || snake_y[0] >= HEIGHT) {
    game_over = 1;
}

for (int i = 1; i < length; i++) {
    if (snake_x[0] == snake_x[i] && snake_y[0] == snake_y[i]) {
        game_over = 1;
        break;
    }
}

Если коллизия произошла, игра завершается.

Сбор еды и рост змейки​

Если голова оказывается на клетке с едой, длина змейки увеличивается, а новая еда размещается в случайном месте:

if (snake_x[0] == food_x && snake_y[0] == food_y) {
    length++;
    place_food(); // убедиться, что еда не на теле
    score++;
}

Функция place_food должна генерировать координаты до тех пор, пока они не окажутся в пустой клетке.

Управление и игровой цикл​

В упрощённой версии игрок вводит команду (w, a, s, d) перед каждым ходом:

printf("Управление: w/a/s/d. Текущий счёт: %d\n", score);
char input;
scanf(" %c", &input); // пробел перед %c пропускает whitespace

if (input == 'w' || input == 'a' || input == 's' || input == 'd') {
    // Запрет поворота в противоположную сторону
    if (!(direction == 'w' && input == 's') &&
        !(direction == 's' && input == 'w') &&
        !(direction == 'a' && input == 'd') &&
        !(direction == 'd' && input == 'a')) {
        direction = input;
    }
}

Это предотвращает мгновенное самоуничтожение при нажатии противоположной клавиши.

Основной цикл объединяет все этапы:

while (!game_over) {
    draw();
    get_input();
    move();
    check_collision();
    check_food();
}
printf("Игра окончена! Ваш счёт: %d\n", score);

Возможные улучшения​

Несмотря на простоту, текстовая «Змейка» допускает множество расширений:

  • Использование функции _kbhit() (в Windows) или select()/poll() (в Unix) для неблокирующего ввода, что приближает поведение к оригинальной аркаде.
  • Добавление уровней сложности: ускорение движения с ростом счёта.
  • Цветной вывод через ANSI-коды: зелёная змейка, красная еда.
  • Сохранение рекордов в файл.
  • Поддержка паузы, перезапуска без выхода из программы.

Каждое из этих улучшений углубляет понимание работы с вводом-выводом, временем, памятью и файловой системой в контексте языка Си.

Почему «Змейка» важна?​

«Змейка» — это первая игра, в которой появляется понятие динамического состояния во времени. Объект (змейка) существует непрерывно, его форма изменяется, и каждое действие имеет последствия. Это переход от статических задач (угадай число, крестики-нолики) к моделированию процессов. Такие навыки необходимы для создания симуляторов, робототехнических программ, сетевых приложений и даже компиляторов, где состояние системы постоянно эволюционирует.

Теоретическое обобщение: почему игры на Си важны​

Простые игры, реализованные на языке Си, — это не просто упражнения для начинающих. Они являются практическим воплощением фундаментальных идей системного программирования. Каждая из рассмотренных игр — «Угадай число», «Крестики-нолики», «Змейка» — демонстрирует, как можно строить интерактивные программы, используя только стандартную библиотеку, базовые типы данных и линейную логику. Такой подход развивает дисциплину мышления: программист учится чётко формулировать состояние, правила перехода и условия завершения.

Язык Си не предоставляет встроенных средств для графики, анимации или обработки событий в реальном времени. Это ограничение становится преимуществом в учебном контексте. Оно заставляет разработчика сосредоточиться на логике, а не на визуальных эффектах. Вместо того чтобы вызывать готовый метод drawSprite(), программист сам определяет, как символы располагаются на экране. Вместо автоматического управления памятью он отслеживает границы массивов и избегает переполнений. Так формируется глубокое понимание того, как работают программы «под капотом».

Историческая преемственность​

Многие ранние компьютерные игры создавались именно на Си или на ассемблере с использованием Си-подобных конструкций. Например, оригинальная версия Doom (1993) написана на Си и использует текстовые конфигурационные файлы, ручное управление памятью и собственный цикл отрисовки. Даже современные игровые движки, такие как Quake III Arena или Unreal Engine (в ранних версиях), опираются на принципы, заложенные в Си: предсказуемость производительности, прямой доступ к данным, минимизация накладных расходов.

Текстовые игры 1970–1980-х годов — Adventure, Rogue, Nethack — также были написаны на Си или C-подобных языках. Они доказали, что даже без пикселей и звука можно создать захватывающий игровой опыт, основанный на воображении, стратегии и взаимодействии. Современные учебные проекты на Си продолжают эту традицию, сохраняя дух минимализма и интеллектуальной вовлечённости.

Архитектурная дисциплина​

Разработка игр на Си требует чёткого разделения ответственности. Функции должны быть маленькими, специализированными и легко тестируемыми. Глобальные переменные используются с осторожностью, а состояние игры инкапсулируется в структуры или передаётся явно через параметры. Такой стиль программирования совпадает с лучшими практиками системного кода: ядро Linux, компилятор GCC, базы данных SQLite — все они построены на тех же принципах.

Когда студент пишет «Змейку» на Си, он не просто реализует игру. Он тренирует навык проектирования программ, где каждая строка имеет значение, каждый байт учитывается, а каждая ошибка может привести к сбою. Это формирует инженерное мышление — способность видеть систему целиком и управлять её поведением на низком уровне.

Путь к более сложным проектам​

Освоив текстовые игры, программист получает прочную основу для дальнейшего роста. Следующие шаги могут включать:

  • Подключение библиотек вроде ncurses для продвинутого управления терминалом: цвета, окна, неблокирующий ввод.
  • Переход к графике через Allegro, SDL или даже прямую работу с framebuffer в Linux.
  • Реализация сетевой многопользовательской игры с использованием сокетов (<sys/socket.h>).
  • Создание простого игрового движка с поддержкой тайлов, спрайтов и коллизий.
  • Порт игры на микроконтроллер (например, Arduino или ESP32), где ресурсы ещё более ограничены.

Все эти направления опираются на тот же базовый набор знаний: работа с памятью, циклы, указатели, структуры, функции. Язык Си остаётся общим знаменателем, связующим звеном между встраиваемыми системами, настольными приложениями и высокопроизводительными серверами.

Образовательная роль в современном мире​

В эпоху высокоуровневых языков и фреймворков изучение Си может показаться анахронизмом. Однако именно этот язык позволяет понять, как устроены современные технологии. Виртуальные машины, JIT-компиляторы, операционные системы, драйверы устройств — всё это написано на Си или зависит от кода, написанного на нём. Знание Си даёт ключ к пониманию всей стек-технологии, от железа до веб-браузера.

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