Mise à jour de la console sans scintillement - c++

Ah, cela ramène au bon vieux temps. J'ai fait des choses similaires dans le lycée 🙂

Vous allez rencontrer des problèmes de performances. Console d'e/S, en particulier sur Windows, est lente. Très, très lent (parfois plus lent que l'écriture sur le disque, même). En fait, vous allez vite devenir étonné de voir comment beaucoup plus de travail que vous pouvez le faire sans que cela n'affecte la latence de votre boucle de jeu, depuis le I/O aura tendance à dominer tout le reste. Donc, la règle d'or est tout simplement de réduire le montant de l'I/O que vous faites, au-dessus de tout le reste.

Tout d'abord, je suggère de se débarrasser de la system("cls") et de le remplacer avec les appels à la réelle console Win32 sous-système de fonctions qui cls d'enveloppe (docs):

#define NOMINMAX
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>

void cls()
{
    //Get the Win32 handle representing standard output.
    //This generally only has to be done once, so we make it static.
    static const HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    CONSOLE_SCREEN_BUFFER_INFO csbi;
    COORD topLeft = { 0, 0 };

    //std::cout uses a buffer to batch writes to the underlying console.
    //We need to flush that to the console because we're circumventing
    //std::cout entirely; after we clear the console, we don't want
    //stale buffered text to randomly be written out.
    std::cout.flush();

    //Figure out the current width and height of the console window
    if (!GetConsoleScreenBufferInfo(hOut, &csbi)) {
        //TODO: Handle failure!
        abort();
    }
    DWORD length = csbi.dwSize.X * csbi.dwSize.Y;

    DWORD written;

    //Flood-fill the console with spaces to clear it
    FillConsoleOutputCharacter(hOut, TEXT(' '), length, topLeft, &written);

    //Reset the attributes of every character to the default.
    //This clears all background colour formatting, if any.
    FillConsoleOutputAttribute(hOut, csbi.wAttributes, length, topLeft, &written);

    //Move the cursor back to the top left for the next sequence of writes
    SetConsoleCursorPosition(hOut, topLeft);
}

En effet, au lieu de redessiner l'ensemble de la "trame" à chaque fois, vous êtes beaucoup mieux de dessin (ou de les effacer, en les écrasant avec un espace) les caractères à la fois:

//x is the column, y is the row. The origin (0,0) is top-left.
void setCursorPosition(int x, int y)
{
    static const HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    std::cout.flush();
    COORD coord = { (SHORT)x, (SHORT)y };
    SetConsoleCursorPosition(hOut, coord);
}

//Step through with a debugger, or insert sleeps, to see the effect.
setCursorPosition(10, 5);
std::cout << "CHEESE";
setCursorPosition(10, 5);
std::cout 'W';
setCursorPosition(10, 9);
std::cout << 'Z';
setCursorPosition(10, 5);
std::cout << "     ";  //Overwrite characters with spaces to "erase" them
std::cout.flush();
//Voilà, 'CHEESE' converted to 'WHEEZE', then all but the last 'E' erased

Noter que ceci élimine le scintillement, aussi, puisqu'il n'est plus besoin de vider complètement l'écran avant de redessiner -- vous pouvez simplement changer ce qui doit changer sans intermédiaire, de clair, de sorte que l'image précédente est mis à jour incrémentielle, persistant jusqu'à ce qu'il est complètement à jour.

Je vous suggérons d'utiliser un double-buffering technique: Avoir un tampon en mémoire que représente le "courant" de l'état de l'écran de la console, initialement peuplée par des espaces. Alors un autre tampon, qui représente la "prochaine" de l'état de l'écran. Votre jeu de logique de mise à jour va modifier "à côté" de l'état (exactement comme il le fait avec votre battleField tableau pour le moment). Quand vient le temps de dessiner le cadre, ne pas effacer tout d'abord. Au lieu de cela, passer par les deux tampons en parallèle, et d'écrire seulement les changements partir de l'état précédent (le "courant" de la mémoire tampon au niveau de ce point contient de l'état précédent). Ensuite, copiez les "à côté" de la mémoire tampon dans le "courant" de la mémoire tampon pour la configuration de votre image suivante.

char prevBattleField[MAX_X][MAX_Y];
std::memset((char*)prevBattleField, 0, MAX_X * MAX_Y);

//...

for (int y = 0; y != MAX_Y; ++y)
{
    for (int x = 0; x != MAX_X; ++x)
    {
        if (battleField[x][y] == prevBattleField[x][y]) {
            continue;
        }
        setCursorPosition(x, y);
        std::cout << battleField[x][y];
    }
}
std::cout.flush();
std::memcpy((char*)prevBattleField, (char const*)battleField, MAX_X * MAX_Y);

Vous pouvez même aller plus loin et lot pistes de changements en un seul appel d'e/S (ce qui est nettement moins cher que de nombreux appels à caractère individuel écrit, mais toujours proportionnellement plus cher, le plus de caractères sont écrites).

//Note: This requires you to invert the dimensions of `battleField` (and
//`prevBattleField`) in order for rows of characters to be contiguous in memory.
for (int y = 0; y != MAX_Y; ++y)
{
    int runStart = -1;
    for (int x = 0; x != MAX_X; ++x)
    {
        if (battleField[y][x] == prevBattleField[y][x]) {
            if (runStart != -1) {
                setCursorPosition(runStart, y);
                std::cout.write(&battleField[y][runStart], x - runStart);
                runStart = -1;
            }
        }
        else if (runStart == -1) {
            runStart = x;
        }
    }
    if (runStart != -1) {
        setCursorPosition(runStart, y);
        std::cout.write(&battleField[y][runStart], MAX_X - runStart);
    }
}
std::cout.flush();
std::memcpy((char*)prevBattleField, (char const*)battleField, MAX_X * MAX_Y);

En théorie, ce qui sera beaucoup plus rapide que la première boucle; toutefois, dans la pratique, il ne sera probablement pas faire une différence depuis std::cout est déjà mise en mémoire tampon écrit de toute façon. Mais c'est un bon exemple (et un modèle commun qui se montre beaucoup quand il n'y a pas de tampon dans le système sous-jacent), je l'ai donc inclus de toute façon.

Enfin, notez que vous pouvez réduire votre sommeil à 1 milliseconde. Windows ne peut pas vraiment dormir pour moins de 10-15ms de toute façon, mais il empêchera votre cœur de PROCESSEUR d'atteindre 100% d'utilisation avec un minimum de latence additionnelle.

Remarque que ce n'est pas du tout le mode de "vrais" jeux de faire des choses; ils sont presque toujours effacer la mémoire tampon et de redessiner tout à chaque image. Ils n'obtenez pas de scintillement, car ils utilisent l'équivalent d'un double-tampon sur la carte graphique, dans le cas où l'image reste visible jusqu'à ce que le nouveau cadre est complètement terminé.

Bonus: Vous pouvez changer la couleur d'un de 8 différentes couleurs du système, et l'arrière-plan, trop:

void setConsoleColour(unsigned short colour)
{
    static const HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    std::cout.flush();
    SetConsoleTextAttribute(hOut, colour);
}

//Example:
const unsigned short DARK_BLUE = FOREGROUND_BLUE;
const unsigned short BRIGHT_BLUE = FOREGROUND_BLUE | FOREGROUND_INTENSITY;

std::cout << "Hello ";
setConsoleColour(BRIGHT_BLUE);
std::cout << "world";
setConsoleColour(DARK_BLUE);
std::cout << "!" << std::endl;

OriginalL'auteur Cameron

Une méthode consiste à écrire les données mises en forme d'une chaîne de caractères (ou tampon), puis bloquer l'écriture de la mémoire tampon de la console.

De chaque appel d'une fonction a une surcharge. Essayez d'aller en faire plus d'une fonction. À votre Sortie, cela pourrait signifier beaucoup de texte par sortie demande.

Par exemple:

static char buffer[2048];
char * p_next_write = &buffer[0];
for (int y = 0; y < MAX_Y; y++)
{
    for (int x = 0; x < MAX_X; x++)
    {
        *p_next_write++ = battleField[x][y];
    }
    *p_next_write++ = '\n';
}
*p_next_write = '
static char buffer[2048];
char * p_next_write = &buffer[0];
for (int y = 0; y < MAX_Y; y++)
{
for (int x = 0; x < MAX_X; x++)
{
*p_next_write++ = battleField[x][y];
}
*p_next_write++ = '\n';
}
*p_next_write = '\0'; //"Insurance" for C-Style strings.
cout.write(&buffer[0], std::distance(p_buffer - &buffer[0]));
'; //"Insurance" for C-Style strings.
cout.write(&buffer[0], std::distance(p_buffer - &buffer[0]));

Opérations d'e/S sont chers (exécution-sage), de sorte que la meilleure utilisation est de maximiser la quantité de données par demande de produits.

OriginalL'auteur Thomas Matthews