Сон спит всю программу

0

Когда я нажимаю клавишу со стрелкой вверх, звезда двигается вверх 2 раза, но я хочу добавить задержку между звездой, двигающейся в 1-й и 2-й раз, это код:

#include <iostream>
#include <windows.h>

using namespace std;

char Map[10][20] = {"###################",
                    "####    #########!#",
                    "####  # ######### #",
                    "####* # ######### #",
                    "#     # ######### #",
                    "# ##### ######### #",
                    "# ##### ######### #",
                    "# ##### ######### #",
                    "#@#####           #",
                    "###################" };

int Gamespeed = 100;
int Level = 1;
bool stopgame = false;
int Hp = 100;
int MaxHp = 100;

int main()
{
    while(stopgame == false && Level == 1)
    {
        system("cls");
        for (int y = 0; y < 10; y++)
        {
            cout << Map[y] << endl;
        }
        cout << "Hp: "<< Hp << "/" << MaxHp << endl;
        for (int y = 0; y<10; y++)
        {
            for(int x = 0; x<20; x++)
            {

                switch(Map[y][x])
                {
                    case '#':
                    {
                       Map[y][x] = 219;
                    }
                    break;
                    case '*':
                        {
                            if (GetAsyncKeyState(VK_UP) != 0)
                            {
                                if (y = 3)
                                {
                                    Map[y][x] = ' ';
                                    y -= 1;
                                    Map[y][x] = '*';
                                }
                                Sleep(1000);
                                if (y = 2)
                                {
                                    Map[y][x] = ' ';
                                    y -= 1;
                                    Map[y][x] = '*';
                                }

                            }
                        }
                        break;
                    case '@':
                    {

                        if (GetAsyncKeyState(VK_UP) != 0)
                        {
                            int y2 = (y-1);

                            switch(Map[y2][x])
                            {
                                case ' ':
                                {
                                    Map[y][x] = ' ';
                                    y -= 1;
                                    Map[y2][x] = '@';
                                }break;
                                case '!':
                                    {
                                        Level = 2;
                                    }break;
                                    case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        y -= 1;
                                        Map[y2][x] = '@';
                                    }break;
                            }
                        }

                        if (GetAsyncKeyState(VK_DOWN) != 0)
                        {
                            int y2 = (y + 1);

                            switch(Map[y2][x])
                            {
                            case ' ':
                                {
                                    Map[y][x] = ' ';
                                    y += 1;
                                    Map[y2][x] = '@';
                                }break;
                            case '!':
                                {
                                    Level = 2;
                                }break;
                                case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        y -= 1;
                                        Map[y2][x] = '@';
                                    }break;
                            }
                       }

                       if (GetAsyncKeyState(VK_RIGHT) != 0)
                       {
                           int x2 = (x + 1);

                           switch(Map[y][x2])
                           {
                           case ' ':
                            {
                                Map[y][x] = ' ';
                                x += 1;
                                Map[y][x2] = '@';
                            }break;
                           case '!':
                            {
                                Level = 2;
                            }break;
                            case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        x -= 1;
                                        Map[y][x2] = '@';
                                    }break;
                           }
                       }
                       if (GetAsyncKeyState(VK_LEFT) != 0)
                       {
                           int x2 = (x - 1);

                           switch(Map[y][x2])
                           {
                           case ' ':
                            {
                                Map[y][x] = ' ';
                                x -= 1;
                                Map[y][x2] = '@';
                            }break;
                           case '!':
                            {
                                Level = 2;
                            }break;
                            case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        x -= 1;
                                        Map[y][x2] = '@';
                                    }break;
                           }
                       }
                    }
                }
            }
        }
        Sleep(Gamespeed);
    }

это код, который заставляет звезду двигаться

case '*':
    {
        if (GetAsyncKeyState(VK_UP) != 0)
        {
            if (y = 3)
            {
                Map[y][x] = ' ';
                y -= 1;
                Map[y][x] = '*';
            }
            Sleep(1000);
            if (y = 2)
            {
                Map[y][x] = ' ';
                y -= 1;
                Map[y][x] = '*';
            }

        }
    }
  break;

проблема заключается в том, что Сон приостанавливает всю программу, а не движение звезды

Решение Эдварда Алехандро Медины:

    #include <iostream>
    #include <windows.h>
    #include <chrono>

    using namespace std;

    char Map[10][20] = {"###################",
                        "####    #########!#",
                        "####  # ######### #",
                        "####* # ######### #",
                        "#     # ######### #",
                        "# ##### ######### #",
                        "# ##### ######### #",
                        "# ##### ######### #",
                        "#@#####           #",
                        "###################" };

    int Gamespeed = 100;
    int Level = 1;
    bool stopgame = false;
    int Hp = 100;
    int MaxHp = 100;

    int main()
    {
    chrono::time_point<chrono::system_clock> current_time,last_time;
    float delta_time,star_delay=0;
    current_time=chrono::system_clock::now();
    last_time=current_time;
    while(stopgame == false && Level == 6)
    {
           current_time=chrono::system_clock::now();
           delta_time=chrono::duration_cast<chrono::duration<float>>(current_time-last_time).count();
           last_time=current_time;
        system("cls");
        cout << "Well done you made it to level 6\n\n";
    for (int y = 0; y < 10; y++)
        {
            cout << Map6[y] << endl;
        }
        cout << "Hp: "<< Hp << "/" << MaxHp << endl;
        for (int y = 0; y<10; y++)
        {
            for(int x = 0; x<20; x++)
            {

                switch(Map6[y][x])
                {
                    case '#':
                    {
                       Map6[y][x] = 219;
                    }
                    break;
                    case '*':
                        {
                                if (y == 8 && x == 12)
                                {
                                    Map6[y][x] = ' ';
                                    y -= 1;
                                    Map6[y][x] = '*';
                                    star_delay=0;
                                }
                                if (y == 7 && x == 12)
                                {
                                    Map6[y][x] = ' ';
                                    y -= 1;
                                    Map6[y][x] = '*';
                                    star_delay=0;
                                }
                                if (y == 6 && x == 12)
                                {
                                    Map6[y][x] = ' ';
                                    x += 1;
                                    Map6[y][x] = '*';
                                    star_delay=0;
                                }
                                if (y == 6 && x == 13)
                                {
                                    Map6[y][x] = ' ';
                                    y += 1;
                                    Map6[y][x] = '*';
                                    star_delay=0;
                                }
                                if (y == 7 && x == 13)
                                {
                                    Map6[y][x] = ' ';
                                    y += 1;
                                    Map6[y][x] = '*';
                                    star_delay=0;
                                }
                                if (y == 8 && x == 13)
                                {
                                    if(star_delay>1){
                                    Map6[y][x] = ' ';
                                    x -= 1;
                                    Map6[y][x] = '*';
                                    }else{
                                        star_delay+=delta_time;
                                    }
                                }
                        }
                        break;
                    case '@':
                    {
                        if (GetAsyncKeyState(VK_UP) != 0)
                        {
                            int y4 = (y-1);

                            switch(Map6[y4][x])
                            {
                                case ' ':
                                {
                                    Map6[y][x] = ' ';
                                    y -= 1;
                                    Map6[y4][x] = '@';
                                }break;
                                case '!':
                                    {
                                        Level = 7;
                                    }break;
                                    case '*':
                                    {
                                        Hp -= 20;
                                        Map6[y][x] = ' ';
                                        y -= 1;
                                        Map6[y4][x] = '@';
                                    }break;
                            }

                        }

                        if (GetAsyncKeyState(VK_DOWN) != 0)
                        {
                            int y4 = (y + 1);

                            switch(Map6[y4][x])
                            {
                            case ' ':
                                {
                                    Map6[y][x] = ' ';
                                    y += 1;
                                    Map6[y4][x] = '@';
                                }break;
                            case '!':
                                {
                                    Level = 7;
                                }break;
                                case '*':
                                    {
                                        Hp -= 20;
                                        Map6[y][x] = ' ';
                                        y -= 1;
                                        Map6[y4][x] = '@';
                                    }break;
                            }
                       }

                       if (GetAsyncKeyState(VK_RIGHT) != 0)
                       {
                           int x5 = (x + 1);

                           switch(Map6[y][x5])
                           {
                           case ' ':
                            {
                                Map6[y][x] = ' ';
                                x += 1;
                                Map6[y][x5] = '@';
                            }break;
                           case '!':
                            {
                                Level = 7;
                            }break;
                            case '*':
                                    {
                                        Hp -= 20;
                                        Map6[y][x] = ' ';
                                        x -= 1;
                                        Map6[y][x5] = '@';
                                    }break;
                           }
                       }
                       if (GetAsyncKeyState(VK_LEFT) != 0)
                       {
                           int x5 = (x - 1);

                           switch(Map6[y][x5])
                           {
                           case ' ':
                            {
                                Map6[y][x] = ' ';
                                x -= 1;
                                Map6[y][x5] = '@';
                            }break;
                           case '!':
                            {
                                Level = 7;
                            }break;
                            case '*':
                                    {
                                        Hp -= 20;
                                        Map6[y][x] = ' ';
                                        x -= 1;
                                        Map6[y][x5] = '@';
                                    }break;
                           }
                       }
                    }
                }
            }
        }
        Sleep(Gamespeed);
        while(Hp == 0)
            {
                system("cls");
                cout << "\n\n\n\n\n\n\n\n\n\n                              you died on level " << Level << "\n\n                             better luck next time.";
            }
    }

    return 0;
}
     }
                    }
                }
            }
            Sleep(Gamespeed);
        }
  • 2
    Сон держит текущую нить. Так что ожидается только. Вы использовали какие-либо темы, кроме основного?
  • 0
    нет, я использовал только основной
Показать ещё 6 комментариев
Теги:

2 ответа

0
Лучший ответ

Вы должны сделать что-то вроде этого

#include <iostream>
#include <windows.h>
#include <chrono>

using namespace std;

char Map[10][20] = {"###################",
                    "####    #########!#",
                    "####  # ######### #",
                    "####* # ######### #",
                    "#     # ######### #",
                    "# ##### ######### #",
                    "# ##### ######### #",
                    "# ##### ######### #",
                    "#@#####           #",
                    "###################" };

int Gamespeed = 100;
int Level = 1;
bool stopgame = false;
int Hp = 100;
int MaxHp = 100;

int main()
{
chrono::time_point<chrono::system_clock> current_time,last_time;
float delta_time,star_delay=0;
current_time=chrono::system_clock::now();
last_time=current_time;
    while(stopgame == false && Level == 1)
    {
   current_time=chrono::system_clock::now();
   delta_time=chrono::duration_cast<chrono::duration<float>>(current_time-last_time).count();
   last_time=current_time;
        system("cls");
        for (int y = 0; y < 10; y++)
        {
            cout << Map[y] << endl;
        }
        cout << "Hp: "<< Hp << "/" << MaxHp << endl;
        for (int y = 0; y<10; y++)
        {
            for(int x = 0; x<20; x++)
            {

                switch(Map[y][x])
                {
                    case '#':
                    {
                       Map[y][x] = 219;
                    }
                    break;
                    case '*':
                       if (y == 3)
                       {
                           Map[y][x] = ' ';
                           y -= 1;
                           Map[y][x] = '*';
                           star_delay=0;
                       }
                       if (y == 2)
                       {
                          if(star_delay>1){
                             Map[y][x] = ' ';
                             y -= 1;
                             Map[y][x] = '*';
                          }else{
                             star_delay+=delta_time;
                          }
                       break;
                    case '@':
                    {

                        if (GetAsyncKeyState(VK_UP) != 0)
                        {
                            int y2 = (y-1);

                            switch(Map[y2][x])
                            {
                                case ' ':
                                {
                                    Map[y][x] = ' ';
                                    y -= 1;
                                    Map[y2][x] = '@';
                                }break;
                                case '!':
                                    {
                                        Level = 2;
                                    }break;
                                    case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        y -= 1;
                                        Map[y2][x] = '@';
                                    }break;
                            }
                        }

                        if (GetAsyncKeyState(VK_DOWN) != 0)
                        {
                            int y2 = (y + 1);

                            switch(Map[y2][x])
                            {
                            case ' ':
                                {
                                    Map[y][x] = ' ';
                                    y += 1;
                                    Map[y2][x] = '@';
                                }break;
                            case '!':
                                {
                                    Level = 2;
                                }break;
                                case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        y -= 1;
                                        Map[y2][x] = '@';
                                    }break;
                            }
                       }

                       if (GetAsyncKeyState(VK_RIGHT) != 0)
                       {
                           int x2 = (x + 1);

                           switch(Map[y][x2])
                           {
                           case ' ':
                            {
                                Map[y][x] = ' ';
                                x += 1;
                                Map[y][x2] = '@';
                            }break;
                           case '!':
                            {
                                Level = 2;
                            }break;
                            case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        x -= 1;
                                        Map[y][x2] = '@';
                                    }break;
                           }
                       }
                       if (GetAsyncKeyState(VK_LEFT) != 0)
                       {
                           int x2 = (x - 1);

                           switch(Map[y][x2])
                           {
                           case ' ':
                            {
                                Map[y][x] = ' ';
                                x -= 1;
                                Map[y][x2] = '@';
                            }break;
                           case '!':
                            {
                                Level = 2;
                            }break;
                            case '*':
                                    {
                                        Hp -= 20;
                                        Map[y][x] = ' ';
                                        x -= 1;
                                        Map[y][x2] = '@';
                                    }break;
                           }
                       }
                    }
                }
            }
        }


       }
        Sleep(Gamespeed);
    cout<<"dt:"<<delta_time<<endl;
    cout<<"sd:"<<star_delay<<endl;
    }

}
  • 0
    спасибо за ваш ответ, но было много ошибок: «chrono» не называет тип, «current_time» не называет тип, «last_time» не называет тип, «current_time» не было объявлено в этой области » chrono не был объявлен, ожидаемое первичное выражение перед 'float', ожидаемое ';' до 'float', last_time 'не было объявлено в этой области, ожидается'; ' до '}' токена
  • 0
    Вы должны включить chrono #include <chrono>
Показать ещё 9 комментариев
0

Позвольте мне угадать, это в оконной программе (с циклом GetMessage/DispatchMessage), правильно? Здесь вы никогда не должны блокироваться ни с помощью Sleep(), ни с какой-либо другой продолжительной операцией. Это замораживает весь пользовательский интерфейс, так как без ввода клавиатуры или перерисовки между ними не происходит. То, что вы можете сделать, зависит от вашего дизайна, но простым способом является запуск таймера, который позже вызывается окном proc и где вы можете закончить движение.

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

  • 0
    Я добавил весь мой код выше
  • 0
    Хорошо, мое предположение было полностью неверным, у вас нет оконной программы, поэтому предложения, основанные на этом, тоже неверны.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню