Как сделать чтоб одна вункция роботала всегда а другая паралельно каждую секунду?

Question

[XerimHD]

void game_loop(bool &star_placed, bool &staircase_placed, int &c, bool &t_placed, int &r_placed, bool &p_placed, int rows, int cols, vector<vector<char>> &map)
{
// код игры 
}
void monster_move(vector<vector<char>> &map)
{
// движения монстров 
this_thread::sleep_for(chrono::seconds(1));
}
 void menu(bool &star_pleced, bool &staircase_placed, int &c, bool &t_placed, int &r_placed, bool &p_placed, int rows, int cols, vector<vector<char>> &map)
{
do
                {
                    thread gameThread(game_loop, ref(star_pleced), ref(staircase_placed), ref(c), ref(t_placed), ref(r_placed), ref(p_placed), rows, cols, ref(map));
                    thread monsterThread(monster_move, ref(map));
                    gameThread.join();
monsterThread.join();

                    refresh();
                } while ((c = getch()) != '0');
}

что не так подскажите,если вот так,как я сделала тогда весь код тормозит на 1 секунду

Comments

[Сергей Соловьев]

Внутренность функций тоже можно показать. Возможно причина там

[XerimHD]

void game_loop(bool &star_placed, bool &staircase_placed, int &c, bool &t_placed, int &r_placed, bool &p_placed, int rows, int cols, vector<vector<char>> &map)
{
    bool pause = false;
    bool invent = false;
    int newlvl = player_actions(star_placed, num_lvl, staircase_placed, t_placed, r_placed, p_placed, c, map);
    if (c == raisekey)
    {
        raise_bag(map);
    }
    if (c == attackkey)
    {
        attack(c, rows, map);
    }

    dungeon_gen(star_placed, staircase_placed, p_placed, t_placed, r_placed, rows, cols, map);

    dungeon_graw(num_lvl, p_placed, rows, cols, map);

    if (newlvl == 1)
    {
        clear();
        mvprintw((rows / 2) - 3, (cols / 2) - 3, "New Level %d", num_lvl);
        mvprintw((rows / 2) - 2, (cols / 2) - 1, "PRESS");
        refresh();
    }
    if (c == inventorykey)
    {
        clear();
        invent = true;
        do
        {
            invent = inventory(rows, cols);
        } while (!invent);
    }
    if (c == 27)
    {

        clear();
        pause = true;
        do
        {
            pause = menu_pause(rows, cols);
        } while (!pause);
        dungeon_graw(num_lvl, p_placed, rows, cols, map);
        refresh();
    }
    if (player_hp < 1)
    {

        int choice = 1;
        do
        {
            clear();
            mvprintw(1, 1, "Gold: %d", p_gold);
            mvprintw(2, 1, "Monster kill: %d", monster_kil);
            ;
            mvprintw(rows / 2, cols / 2 - 3, "RIP");
            mvprintw(rows / 2 + 1, cols / 2 - 3, "menu");
            mvprintw(rows / 2 + 2, cols / 2 - 3, "exit");
            mvprintw(rows / 2 + choice, cols / 2 - 5, ">>");
            refresh();

            int ripmenu_c = getch();
            switch (ripmenu_c)
            {
            case KEY_UP:
                choice = max(1, choice - 1);
                break;
            case KEY_DOWN:
                choice = min(2, choice + 1);
                break;
            case 10:
                switch (choice)
                {
                case 1:
                    clear();
                    // сброс игровых даных
                    t_placed = false;
                    p_placed = false;
                    staircase_placed = false;
                    r_placed = 0;
                    num_lvl = 1;
                    att = 1;
                    p_gold = 0;
                    player_hp = 10;
                    monster_kil = 0;
                    counter_star_player = 0;

                    menu(star_placed, staircase_placed, c, t_placed, r_placed, p_placed, rows, cols, map);
                    refresh();

                    break;
                case 2:
                    exit(0);
                }
                break;
            }
        } while (choice != 3);
    }
}

bool is_line_of_sight_clear(const vector<vector<char>> &map, int x1, int y1, int x2, int y2)
{
    int dx = abs(x2 - x1);
    int dy = abs(y2 - y1);
    int sx = (x1 < x2) ? 1 : -1;
    int sy = (y1 < y2) ? 1 : -1;
    int err = dx - dy;

    while (true)
    {
        if (map[y1][x1] == '#')
        {
            // Найдено препятствие на линии видимости
            return false;
        }

        if (x1 == x2 && y1 == y2)
        {
            // Достигнута конечная точка
            break;
        }

        int e2 = 2 * err;
        if (e2 > -dy)
        {
            err -= dy;
            x1 += sx;
        }
        if (e2 < dx)
        {
            err += dx;
            y1 += sy;
        }
    }

    // Пройдена вся линия без препятствий
    return true;
}

void monster_move(vector<vector<char>> &map)
{

    srand(time(0));
    for (int m = 0; m < 10; m++)
    {
        if (monster[m].hp < 1)
            continue;

        int dist_y = abs(py - monster[m].y);
        int dist_x = abs(px - monster[m].x);

        int dir_y = monster[m].y;
        int dir_x = monster[m].x;

        if (dist_y >= 5 && dist_x >= 5)
        {
            // Если монстр от игрока далеко, добавляем случайные шаги для патрулирования
            int random_y_or_x = rand() % 2; 
            int y_changes, x_changes;
            switch (random_y_or_x)
            {
            case 0:
                y_changes = rand() % 2;
                switch (y_changes) // движения по y
                {
                case 0:
                    dir_y--;
                    break;

                case 1:
                    dir_y++;
                    break;
                }
            case 1: // движения по х
                x_changes = rand() % 2;
                switch (x_changes)
                {
                case 0:
                    dir_x--;
                    break;

                case 1:
                    dir_x++;
                    break;
                }
                break;
            }

            // Проверяем, чтобы новая позиция была в пределах карты и была свободной и не пересекала барьер
            if (dir_y >= 0 && dir_y < map.size() && dir_x >= 0 && dir_x < map[0].size() && map[dir_y][dir_x] == ' ')
            {
                map[monster[m].y][monster[m].x] = ' ';
                monster[m].y = dir_y;
                monster[m].x = dir_x;
                map[monster[m].y][monster[m].x] = 't';
            }
        }
        else if (dist_y < 5 || dist_x < 5)
        {
            // Если монстр близко к игроку, преследуем игрока
            if (is_line_of_sight_clear(map, monster[m].x, monster[m].y, px, py))
            {
                if (dist_y > dist_x)
                {
                    if (monster[m].y < py)
                        dir_y++;
                    else
                        dir_y--;
                }
                else
                {
                    if (monster[m].x < px)
                        dir_x++;
                    else
                        dir_x--;
                }

                if (dist_y < 2 && dist_x < 2)
                {
                    player_hp -= num_lvl / 2 + 1;
                }

                // Проверяем, чтобы новая позиция была в пределах карты и была свободной и не пересекала барьер
                if (dir_y >= 0 && dir_y < map.size() && dir_x >= 0 && dir_x < map[0].size() && map[dir_y][dir_x] == ' ')
                {
                    map[monster[m].y][monster[m].x] = ' ';
                    monster[m].y = dir_y;
                    monster[m].x = dir_x;
                    map[monster[m].y][monster[m].x] = 't';
                }
            }
        }
    }
}

вот Сергей Соловьев, только тут сейчас без задержки стоит

Answer 1

[Wataru]

{
  thread gameThread(game_loop, ref(star_pleced), ref(staircase_placed), ref(c), ref(t_placed), ref(r_placed), ref(p_placed), rows, cols, ref(map));
  thread monsterThread(monster_move, ref(map));
  gameThread.join();
  monsterThread.join();
  refresh();
} while ((c = getch()) != '0');

Этот код запускает потоки (они один раз исполняются) потом ждет их завершения. И это в цикле.
Проблема в том, что на каждой итерации этого цикла вы будете ждать, пока monster thread спит.

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

Потоки должны быть запущены один раз и работать в фоне. Тот, который каждую секунду что-то делает, должен внутри содержать цикл и работать бесконечно, на каждой итерации засыпать на 1 секунду.

Answer 2

[Mercury13]

Итак.
1. В играх очень хорош объектный подход — что-то вроде

class World {
public:
  bool wasStarPlaced = false;
  bool wasStaircasePlaced = false;
  std::vector<std::vector<char>> map;
  unsigned long long tick = 0;  // пригодится ещё
  void update();  // стандартное название для функции «исполнить игровой такт»
};

Тут даже не нужны все каноны ООП, достаточно что-то вроде «поле X принадлежит объекту Y».

2. Многопоточка чревата гонками по данным, и если в многопоточку не стоит — пожалуйста, не делайте! В данном случае вы хотите что-то вроде: каждую секунду выполнять дополнительную ветку.

Как я понял, игра динамичная, и расчёты в ней достаточно простые, чтобы вести их с постоянной частотой (например, 60 тактов/с).

constexpr int TICKS_PER_SEC = 60;

void World::update()
{
  ++tick;
  if (tick % TICKS_PER_SEC == 0) {
     // происходит каждые 60 тактов
  }
}