v1.0.0

.gitignore

@@ -0,0 +1,3 @@
+.vscode
+build
+tictactoe

README.md

@@ -0,0 +1,50 @@
+# TicTacToe
+
+Крестики-нолики
+
+![game](images/game.png)
+
+```sh
+~ $ ./tictactoe --help   
+Использование: tictactoe [option] [arguments] ...
+
+  -h,  --help                               Получить информацию об использовании
+  -s,  --size        <count columns>        Размер сетки N*N
+  -w,  --width       <size>                 Ширина/высота игрового окна
+  -m,  --margin      <size>                 Размер внутреннего отступа от границы окна до игрового поля
+  -v,  --version                            Версия TicTacToe
+```
+
+## Сборка
+
+```sh
+mkdir build
+cd build
+cmake -B . -S ../game
+make
+```
+
+Основные данные, необходимые для запуска игры, находятся в каталоге [data](data/).
+
+### Для Windows
+
+#### Ключи для сборки
+
+`-lallegro_dialog-static -lallegro_image-static -lallegro_primitives-static -lallegro-static -ljpeg -lpng16 -lwebp -lwinmm -lopengl32 -lcomdlg32 -lgdi32 -lole32 -lshlwapi -lz -mwindows`
+
+#### Статическая сборка
+
+`-static`
+
+#### Дополнительные библиотеки для сборки
+
+- `jpeg`
+- `png16`
+- `webp`
+- `winmm`
+- `opengl32`
+- `comdlg32`
+- `gdi32`
+- `ole32`
+- `shlwapi`
+- `z`

game/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.0)
+project(tictactoe)
+
+include_directories("lib/" "network/" "objects/")
+
+set(SRC_GAME
+    ai.cpp
+    main.cpp
+    map.cpp
+    parse_args.cpp
+    version.cpp)
+
+find_library(ALLEGRO_LIB NAMES allegro)
+find_library(ALLEGRO_PRIMITIVES_LIB NAMES allegro_primitives)
+find_library(ALLEGRO_DIALOG_LIB NAMES allegro_dialog)
+find_library(ALLEGRO_IMAGE_LIB allegro_image)
+
+add_executable(${PROJECT_NAME} ${SRC_GAME})
+
+target_link_libraries(${PROJECT_NAME}
+    ${ALLEGRO_LIB}
+    ${ALLEGRO_PRIMITIVES_LIB}
+    ${ALLEGRO_DIALOG_LIB}
+    ${ALLEGRO_IMAGE_LIB})

game/ai.cpp

@@ -0,0 +1,118 @@
+#include "ai.hpp"
+
+std::random_device rd;
+std::mt19937 mt(rd());
+
+void aiTurn(map *m)
+{
+    std::uniform_int_distribution<int> dist(0, m->size - 1);
+
+    if (aiWinCheck(m)) return;
+    if (humWinCheck(m)) return;
+    int x;
+    int y;
+    do {
+        y = dist(mt);
+        x = dist(mt);
+    } while (m->cells[x][y]->p != EMPTY);
+    setVal(m->cells[x][y], AI, true);
+}
+
+bool aiWinCheck(map *m)
+{
+    for (int y = 0; y < m->size; y++)
+    {
+        for (int x = 0; x < m->size; x++)
+        {
+            cell *c = m->cells[y][x];
+
+            if (c->p == EMPTY)
+            {
+                setVal(c, AI, true);
+                if (checkWin(m, AI))
+                    return true;
+                setVal(c, EMPTY);
+            }
+        }
+    }
+    return false;
+}
+
+bool humWinCheck(map *m)
+{
+    for (int y = 0; y < m->size; y++)
+    {
+        for (int x = 0; x < m->size; x++)
+        {
+            cell *c = m->cells[y][x];
+
+            if (c->p == EMPTY)
+            {
+                setVal(c, HUMAN, true);
+                if (checkWin(m, HUMAN))
+                {
+                    setVal(c, AI, true);
+                    return true;
+                }
+                setVal(c, EMPTY);
+            }
+        }
+    }
+
+    return false;
+}
+
+void setVal(cell *c, PLAYER p, bool draw)
+{
+    c->p = p;
+    c->is_draw = draw;
+}
+
+bool checkWin(map *m, PLAYER p)
+{
+    for (int y = 0; y < m->size; y++)
+    {
+        for (int x = 0; x < m->size; x++)
+        {
+            if (m->cells[y][x]->p == EMPTY) continue;
+            if (checkLine(m, y, x, 0, 1, m->toWin, p)) return true;
+            if (checkLine(m, y, x, 1, 1, m->toWin, p)) return true;
+            if (checkLine(m, y, x, 1, 0, m->toWin, p)) return true;
+            if (checkLine(m, y, x, -1, 1, m->toWin, p)) return true;
+        }
+    }
+
+    return false;
+}
+
+bool checkLine(map *m, int y, int x, int vy, int vx, int len, PLAYER p)
+{
+    const int endX = x + (len - 1) * vx;
+    const int endY = y + (len - 1) * vy;
+
+    if (!isValid(m, endX, endY))
+        return false;
+
+    for (int i = 0; i < len; i++)
+    {
+        if (m->cells[y + i * vy][x + i * vx]->p != p)
+            return false;
+    }
+
+    return true;
+}
+
+bool isValid(map *m, int y, int x)
+{
+    return CHECK_DOT(y, m->size) && CHECK_DOT(x, m->size);
+}
+
+bool isDraw(map *m)
+{
+    for (int y = 0; y < m->size; y++)
+        for (int x = 0; x < m->size; x++)
+            if (m->cells[y][x]->p == EMPTY)
+                return false;
+    return true;
+}
+

game/ai.hpp

@@ -0,0 +1,20 @@
+#ifndef AI_HPP_
+#define AI_HPP_
+
+#include <iostream>
+#include <random>
+#include <algorithm>
+#include "map.hpp"
+
+#define CHECK_DOT(X, Y) ((X) >= 0 && (X) < (Y))
+
+void aiTurn(map *);
+bool aiWinCheck(map *);
+bool humWinCheck(map *);
+void setVal(cell *, PLAYER, bool = false);
+bool checkWin(map *, PLAYER);
+bool checkLine(map *, int, int, int, int, int, PLAYER);
+bool isValid(map *, int, int);
+bool isDraw(map *m);
+
+#endif

game/main.cpp

@@ -0,0 +1,211 @@
+#include <iostream>
+#include <allegro5/allegro.h>
+#include <allegro5/allegro_native_dialog.h>
+#include <allegro5/allegro_primitives.h>
+#include <allegro5/allegro_image.h>
+
+#include "ai.hpp"
+#include "map.hpp"
+#include "parse_args.hpp"
+#include "version.hpp"
+
+int main(int argc, char **argv)
+{
+    int countKeys = 3;
+
+    ra::key ks;  // size
+    ra::key kw;  // width/height window
+    ra::key km;  // margin map
+    ra::key kv;  // version
+
+    ra::key *keys[countKeys] = {&ks, &kw, &km, &kv};
+
+    ra::parse_args(argc, argv, keys);
+
+    int size = 3;
+    int window_wh = 600;
+    int margin_map = 20;
+
+    if (kv.isset)
+    {
+        std::cout << "TicTacToe " << version << std::endl;
+        return 0;
+    }
+
+    if (ks.isset)
+    {
+        size = atoi(ks.arguments[0]);
+        if (size > 10 || size < 3)
+            size = 3;
+    }
+
+    if (kw.isset)
+    {
+        window_wh = atoi(kw.arguments[0]);
+        if (window_wh > 1000 || window_wh < 300)
+            window_wh = 600;
+    }
+
+    if (km.isset)
+    {
+        margin_map = atoi(km.arguments[0]);
+        if (margin_map > 100 || size < 20)
+            margin_map = 20;
+    }
+
+    map *m = init_map(size, window_wh, margin_map);
+
+    bool done = false;
+    bool redraw = true;
+    bool isdraw = true;
+    int FPS = 60;
+    bool move_ai = false;
+
+    int mouse_x = 0;
+    int mouse_y = 0;
+
+    ALLEGRO_DISPLAY *display = NULL;
+    ALLEGRO_EVENT_QUEUE *event_queue = NULL;
+    ALLEGRO_TIMER *timer = NULL;
+    ALLEGRO_BITMAP *img_x = NULL;
+    ALLEGRO_BITMAP *img_o = NULL;
+
+    if (!al_init())
+    {
+        al_show_native_message_box(NULL, NULL, NULL,
+                "Не удается инициализировать allegro!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
+        return (-1);
+    }
+    
+    display = al_create_display(window_wh, window_wh);
+
+    if(!display)
+    {
+        al_show_native_message_box(NULL, NULL, "Ошибка!", "Не удается инициализировать дисплей!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
+        return (-1);
+    }
+
+    al_init_primitives_addon();
+    al_install_keyboard();
+    al_install_mouse();
+    al_init_image_addon();
+
+    img_x = al_load_bitmap("data/x.png");
+
+    if(!img_x)
+    {
+        al_show_native_message_box(display, NULL, "Ошибка!", "Не удается инициализировать \"x.png\"", NULL, ALLEGRO_MESSAGEBOX_ERROR);
+        return (-1);
+    }
+
+    img_o = al_load_bitmap("data/o.png");
+
+    if(!img_o)
+    {
+        al_show_native_message_box(display, NULL, "Ошибка!", "Не удается инициализировать \"o.png\"!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
+        return (-1);
+    }
+
+    timer = al_create_timer(1.0 / FPS);
+    event_queue = al_create_event_queue();
+
+    if(!event_queue)
+    {
+        al_show_native_message_box(display, NULL, "Ошибка!",
+                "Не удается инициализировать событие!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
+        return (-1);
+    }
+
+    al_register_event_source(event_queue, al_get_keyboard_event_source());
+    al_register_event_source(event_queue, al_get_display_event_source(display));
+    al_register_event_source(event_queue, al_get_timer_event_source(timer));
+    al_register_event_source(event_queue, al_get_mouse_event_source());
+
+    al_start_timer(timer);
+
+    while (!done)
+    {
+        ALLEGRO_EVENT ev;
+        al_wait_for_event(event_queue, &ev);
+
+        if (ev.type == ALLEGRO_EVENT_KEY_UP)
+        {
+            switch (ev.keyboard.keycode)
+            {
+                case ALLEGRO_KEY_ESCAPE:
+                    if (exit_game(display))
+                    {
+                        done = true;
+                        continue;
+                    }
+                    al_flush_event_queue(event_queue);
+            }
+        }
+        else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
+        {
+            if (exit_game(display))
+            {
+                done = true;
+                continue;
+            }
+            al_flush_event_queue(event_queue);
+        }
+        else if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP)
+        {
+            if (isdraw && enter_cell(m, mouse_x, mouse_y, HUMAN))
+            {
+                move_ai = true;
+                isdraw = false;
+            }
+        }
+        else if (ev.type == ALLEGRO_EVENT_MOUSE_AXES)
+        {
+            mouse_x = ev.mouse.x;
+            mouse_y = ev.mouse.y;
+        }
+        else if (ev.type == ALLEGRO_EVENT_TIMER)
+        {
+            if (isdraw)
+            {
+                if (game_check(m, display))
+                {
+                    al_flush_event_queue(event_queue);
+                    done = true;
+                    continue;
+                }
+
+                if (move_ai)
+                {
+                    aiTurn(m);
+                    move_ai = false;
+                    isdraw = false;
+                }
+            }
+
+            select_cell(m, mouse_x, mouse_y);
+
+            redraw = true;
+        }
+
+        if (redraw && al_is_event_queue_empty(event_queue))
+        {
+            redraw = false;
+            isdraw = true;
+
+            draw_map(m, img_x, img_o);
+
+            al_flip_display();
+            al_clear_to_color(al_map_rgb(255, 255, 255));
+        }
+    }
+
+    free_map(m);
+
+    al_destroy_display(display);
+    al_destroy_bitmap(img_x);
+    al_destroy_bitmap(img_o);
+    al_destroy_timer(timer);
+    al_destroy_event_queue(event_queue);
+
+    return 0;
+}

game/map.cpp

@@ -0,0 +1,256 @@
+#include "map.hpp"
+#include <cstdlib>
+#include <allegro5/allegro_primitives.h>
+#include <allegro5/allegro_native_dialog.h>
+#include "ai.hpp"
+
+map *init_map(const int size, const int window_wh, const int margin_map)
+{
+    map *m = (map *)malloc(sizeof(map));
+
+    float map_wh = 0;                             // размер карты с учётом отступов
+    float cell_width = 0;                         // ширина ячейки
+    float cell_margin = 0;                        // отступ внутри ячейки
+    float line_count = 0;                         // количество линий на одно направление
+    float line_width = 0;                         // ширина линии
+    float cell_sym_width = 0;                     // ширина сивола внутри ячейки
+
+    m->size = size;
+    m->window_wh = window_wh;
+    m->margin_map = margin_map;
+    m->toWin = size;
+
+    line_count = size - 1;
+    map_wh = window_wh - margin_map * 2;
+    line_width = map_wh * 0.0036;
+    cell_width = map_wh / size;
+    cell_margin = cell_width * 0.0538;
+    cell_sym_width = cell_width - (line_width * 2) - (cell_margin * 2);
+
+    m->sym_width = cell_sym_width;
+
+    m->cells = (cell ***)malloc(sizeof(cell **) * (size * size));
+
+    for (int i = 0; i < size; ++i)
+    {
+        m->cells[i] = (cell **)malloc(sizeof(cell *) * size);
+
+        for (int j = 0; j < size; ++j)
+        {
+            m->cells[i][j] = create_cell(j, i, cell_width, cell_margin, line_width, margin_map);
+        }
+    }
+
+    m->grid = (line ***)malloc(sizeof(line **) * (line_count * line_count));
+
+    for (int i = 0; i < 2; ++i)
+    {
+        m->grid[i] = (line **)malloc(sizeof(line *) * line_count);
+
+        DIRECTION d = (i == 0 ? HORIZONTAL : VERTICAL);
+
+        for (int j = 0; j < line_count; ++j)
+        {
+            m->grid[i][j] = create_line(d, j, line_width, map_wh, cell_width, margin_map);
+        }
+    }
+
+    return m;
+}
+
+cell *create_cell(const float row, const float col, const float cell_width, const float cell_margin, const float line_width, const float margin_map)
+{
+    cell *c = (cell *)malloc(sizeof(cell));
+    c->select = false;
+    c->is_draw = false;
+    c->pos_x = row * cell_width + margin_map;
+    c->pos_y = col * cell_width + margin_map;
+    c->width = cell_width;
+    c->sym_pos_x = c->pos_x + line_width + cell_margin;
+    c->sym_pos_y = c->pos_y + line_width + cell_margin;
+    c->p = EMPTY;
+    return c;
+}
+
+line *create_line(DIRECTION d, const float row, const float line_width, const float map_wh, const float cell_width, const float margin_map)
+{
+    line *l = (line *)malloc(sizeof(line));
+    l->d = d;
+    l->height = map_wh;
+    l->width = line_width;
+    if (d == HORIZONTAL)
+    {
+        l->pos_x = margin_map;
+        l->pos_y = (row + 1) * cell_width + margin_map - line_width;
+    }
+    else
+    {
+        l->pos_x = (row + 1) * cell_width + margin_map - line_width;
+        l->pos_y = margin_map;
+    }
+
+    return l;
+}
+
+void draw_map(const map *m, ALLEGRO_BITMAP *bx, ALLEGRO_BITMAP *bo)
+{
+    int size = m->size;
+
+    int swh = al_get_bitmap_width(bx);
+
+    for (int i = 0; i < size; ++i)
+    {
+        for (int j = 0; j < size; ++j)
+        {
+            cell *c = m->cells[i][j];
+
+            if (c->is_draw)
+            {
+                if (c->p == HUMAN)
+                    al_draw_scaled_bitmap(bx, 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
+                else
+                    al_draw_scaled_bitmap(bo, 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
+            }
+
+            if (c->select)
+            {
+                if (c->is_draw)
+                    al_draw_tinted_scaled_bitmap(bx, al_map_rgba_f(255, 0, 0, 0.3), 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
+                else
+                    al_draw_tinted_scaled_bitmap(bx, al_map_rgba_f(0, 255, 0, 0.3), 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
+            }
+        }
+    }
+
+    for (int i = 0; i < 2; ++i)
+    {
+        for (int j = 0; j < size - 1; ++j)
+        {
+            line *l = m->grid[i][j];
+
+            if (l->d == HORIZONTAL)
+                al_draw_filled_rectangle(l->pos_x, l->pos_y, l->pos_x + l->height, l->pos_y + l->width, al_map_rgb(0, 0, 0));
+            else
+                al_draw_filled_rectangle(l->pos_x, l->pos_y, l->pos_x + l->width, l->pos_y + l->height, al_map_rgb(0, 0, 0));
+        }
+    }
+}
+
+void select_cell(map *m, const int mouse_x, const int mouse_y)
+{
+    int size = m->size;
+
+    for (int i = 0; i < size; ++i)
+    {
+        for (int j = 0; j < size; ++j)
+        {
+            cell *c = m->cells[i][j];
+
+            if ((mouse_x >= c->pos_x && mouse_y >= c->pos_y) &&
+                    (mouse_x <= (c->pos_x + c->width) && mouse_y <= (c->pos_y + c->width)) && c->p != HUMAN)
+                c->select = true;
+            else
+                c->select = false;
+        }
+    }
+}
+
+bool enter_cell(map *m, const int mouse_x, const int mouse_y, PLAYER p)
+{
+    int size = m->size;
+
+    for (int i = 0; i < size; ++i)
+    {
+        for (int j = 0; j < size; ++j)
+        {
+            cell *c = m->cells[i][j];
+
+            if (!c->is_draw && (mouse_x >= c->pos_x && mouse_y >= c->pos_y) &&
+                    (mouse_x <= (c->pos_x + c->width) && mouse_y <= (c->pos_y + c->width)))
+            {
+                c->is_draw = true;
+                c->p = p;
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+void clear_map(map *m)
+{
+    int size = m->size;
+
+    for (int i = 0; i < size; ++i)
+    {
+        for (int j = 0; j < size; ++j)
+        {
+            cell *c = m->cells[i][j];
+
+            c->is_draw = false;
+            c->select = false;
+            c->p = EMPTY;
+        }
+    }
+}
+
+bool game_check(map *m, ALLEGRO_DISPLAY *d)
+{
+    int answer = -1;
+
+    if (checkWin(m, HUMAN))
+        answer = al_show_native_message_box(d, "Игра окончена!", "Вы победили!",
+                        "Начать игру сначала?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);
+
+    if (checkWin(m, AI))
+        answer = al_show_native_message_box(d, "Игра окончена!", "Вы проиграли!",
+                        "Начать игру сначала?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);
+
+    if (isDraw(m))
+        answer = al_show_native_message_box(d, "Игра окончена!", "Ничья!",
+                        "Начать игру сначала?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);
+
+    if (answer == 1)
+        clear_map(m);
+    else if (answer == 0 || answer == 2)
+        return true;
+
+    return false;
+}
+
+void free_map(map *m)
+{
+    for (int i = 0; i < m->size; ++i)
+    {
+        for (int j = 0; j < m->size; ++j)
+        {
+            free(m->cells[i][j]);
+        }
+        free(m->cells[i]);
+    }
+    free(m->cells);
+
+    for (int i = 0; i < 2; ++i)
+    {
+        for (int j = 0; j < m->size - 1; ++j)
+        {
+            free(m->grid[i][j]);
+        }
+        free(m->grid[i]);
+    }
+    free(m->grid);
+
+    free(m);
+}
+
+bool exit_game(ALLEGRO_DISPLAY *d)
+{
+    int answer = al_show_native_message_box(d, NULL, "Выход из игры",
+            "Вы хотите закончить игру?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);
+
+    if (answer == 1)
+        return true;
+    else
+        return false;
+}

game/map.hpp

@@ -0,0 +1,53 @@
+#ifndef MAP_HPP_
+#define MAP_HPP_
+
+#include <allegro5/allegro.h>
+
+typedef enum {HUMAN, AI, EMPTY} PLAYER;
+
+typedef struct
+{
+    bool is_draw;
+    bool select;
+    float pos_x;
+    float pos_y;
+    float width;
+    float sym_pos_x;
+    float sym_pos_y;
+    PLAYER p;
+} cell;
+
+typedef enum {HORIZONTAL, VERTICAL} DIRECTION;
+
+typedef struct
+{
+    DIRECTION d;
+    float pos_x;
+    float pos_y;
+    float width;
+    float height;
+} line;
+
+typedef struct
+{
+    cell ***cells;
+    line ***grid;
+    int toWin;
+    int size;
+    int window_wh;
+    int margin_map;
+    int sym_width;
+} map;
+
+map *init_map(const int, const int, const int);
+cell *create_cell(const float, const float, const float, const float, const float, const float);
+line *create_line(DIRECTION, const float, const float, const float, const float, const float);
+void draw_map(const map *, ALLEGRO_BITMAP *, ALLEGRO_BITMAP *);
+void select_cell(map *, const int, const int);
+bool enter_cell(map *, const int, const int, PLAYER);
+bool game_check(map *, ALLEGRO_DISPLAY *);
+void clear_map(map *);
+void free_map(map *);
+bool exit_game(ALLEGRO_DISPLAY *);
+
+#endif

game/parse_args.cpp

@@ -0,0 +1,53 @@
+#include "parse_args.hpp"
+
+[[ noreturn ]] void ra::print_usage_and_exit(int code)
+{
+    puts("Использование: tictactoe [option] [arguments] ...\n");
+    puts("  -h,  --help                               Получить информацию об использовании");
+    puts("  -s,  --size        <count columns>        Размер сетки N*N");
+    puts("  -w,  --width       <size>                 Ширина/высота игрового окна");
+    puts("  -m,  --margin      <size>                 Размер внутреннего отступа от границы окна до игрового поля");
+    puts("  -v,  --version                            Версия TicTacToe\n");
+    exit(code);
+}
+
+void ra::parse_args(int argc, char *argv[], key **keys)
+{
+    int next_option = 0;
+
+    do{
+        next_option = getopt_long(argc, argv, short_options, long_options, nullptr);
+
+        switch(next_option)
+        {
+            case 's':
+                ra::get_argument(keys[ksize]);
+                break;
+            case 'w':
+                ra::get_argument(keys[kwidth]);
+                break;
+            case 'm':
+                ra::get_argument(keys[kmargin]);
+                break;
+            case 'v':
+                ra::get_argument(keys[kversion]);
+                break;
+            case 'h':
+                ra::print_usage_and_exit(0);
+                break;
+            case '?':
+                ra::print_usage_and_exit(1);
+                break;
+        }
+    } while (next_option != -1);
+}
+
+void ra::get_argument(key *curKey)
+{
+    if (curKey->isset)
+        ra::print_usage_and_exit(3);
+
+    curKey->arguments[0] = optarg;
+    curKey->isset = true;
+    curKey->count = 1;
+}

game/parse_args.hpp

@@ -0,0 +1,38 @@
+#ifndef PARSE_ARGS_HPP_
+#define PARSE_ARGS_HPP_
+
+#include <iostream>
+#include <getopt.h>
+
+namespace ra // read arguments
+{
+    enum keys {ksize, kwidth, kmargin, kversion};
+
+    typedef struct
+    {
+        bool required = false;              // Ключ является обязательным для установки
+        bool isset = false;                 // Ключ был установлен при запуске программы
+        int count = 0;                      // Количество аргументов переданных для текущего ключа
+        char *arguments[1] = {nullptr};    // Переданные аргументы (до 10 аругментов на один ключ)
+    } key;
+
+    const char* const short_options = "hs:w:m:v";
+
+    const struct option long_options[] =
+    {
+        { "help", 0, nullptr, 'h'},
+        { "size", 1, nullptr, 's'},
+        { "width", 1, nullptr, 'w'},
+        { "margin", 1, nullptr, 'm'},
+        { "version", 0, nullptr, 'v'},
+        { nullptr, 0, nullptr, 0}
+    };
+
+    [[ noreturn ]] void print_usage_and_exit(int);    // Напечатать справку и выйти с кодом ошибки
+    void parse_args(int, char **, key **);            // Прочитать все ключи
+    void get_argument(key *);                         // Получить аргумент ключа
+}
+
+
+
+#endif

game/version.cpp

@@ -0,0 +1,3 @@
+#include "version.hpp"
+
+std::string version = "v1.0.0";

game/version.hpp

@@ -0,0 +1,8 @@
+#ifndef VERSION_HPP_
+#define VERSION_HPP_
+
+#include <string>
+
+extern std::string version;
+
+#endif