Comment vérifier qu'un PC de joueur répond à vos exigences

La vérification de la spécification du système de l'utilisateur s'assurera que, tous les utilisateurs qui peuvent exécuter votre jeu, le feront fonctionner sans problème, et que ceux qui ne pourront pas le faire fonctionner, verront quelque chose d'utile. Un jeu qui plante ou, pire encore, plante le système des joueurs qui essaient de le lancer, sans aucune raison valable, va les décourager d'essayer de nouveau, et ce qui est pire, ils pourraient même aller sur Twitter et dénigrer votre jeu. Un joueur, propageant de mauvaises nouvelles sur votre jeu, est suffisant pour dissuader de nombreux autres joueurs potentiels.

Si le joueur reçoit un message d'erreur bien pensé et instructif en cas d'échec, il saura qui contacter, et comment. Le message d'erreur pourrait même les conseiller sur ce qu'ils doivent faire avant de vous appeler, par exemple acheter une meilleure carte graphique, ou supprimer certains programmes pour libérer de l'espace, ou même changer leur résolution d'affichage. S'ils ne sont pas informés à l'avance, ils devront contacter quelqu'un. Ce quelqu'un pourrait être vous, et c'est votre temps qu'ils prennent alors qu'il serait mieux utilisé à produire plus de jeux.

Vérifier les capacités à l'avance permettra de réduire la quantité de plantages qu'un joueur pourrait rencontrer si sa machine n'est pas tout à fait à la hauteur. Comme indiqué plus haut, un jeu qui plante est une mauvaise chose, mais pire que cela, un plantage complet du système (par exemple, le passage en mode plein écran sans solution facile de s'en sortir) pourrait corrompre d'autres données sur la machine de l'utilisateur, causant des dommages ainsi que du mécontentement.

Vous pouvez vérifier la taille de mémoire vive sur Windows en utilisant la fonction GlobalMemoryStatusEx(), qui vous dira, entre autres, la quantité de mémoire libre et totale, ainsi que la quantité de fichiers d'échange libre et totale :

const ONE_GIG = 1073741824;
  MEMORYSTATUSEX status;
  ZeroMemory(&status);
  status.dwLength = sizeof(status);
  GlobalMemoryStatusEx(&status);
  if (status.ullTotalPhys < ONE_GIG) {
    MessageBox(0, "You don't have enough RAM, 1GB is needed", "Epic Fail", MB_OK);
    exit(0);
  }

Vous pouvez vérifier la taille de la RAM vidéo en utilisant DXGI, puis en fonction du résultat vous pouvez charger des textures en basse résolution pour réduire l'utilisation de mémoire, ou vous pourriez dire purement et simplement au joueur d'acheter une nouvelle carte graphique. Je préfère la première de ces deux options dans la mesure du possible, car elle donne une expérience plus conviviale. Vous ne devez abandonner que lorsque vous avez épuisé toutes les possibilités. Le code pour détecter RAM vidéo est relativement simple :

#include <iostream>
#include <string>
#include <d3d11.h>

int main()
{
        HRESULT hr;
        D3D_FEATURE_LEVEL FeatureLevel; 

        // Create DXGI factory to enumerate adapters
        CComPtr<IDXGIFactory1> DXGIFactory;

        hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&DXGIFactory); 
        if(SUCCEEDED(hr))
        {
                CComPtr<IDXGIAdapter1> Adapter;

                hr = DXGIFactory->EnumAdapters1(0, &Adapter);
                if(SUCCEEDED(hr))
                {
                        CComPtr<ID3D11Device> Device;
                        CComPtr<ID3D11DeviceContext> Context;

                        hr = D3D11CreateDevice(Adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0, D3D11_SDK_VERSION, &Device, &FeatureLevel, &Context);

                        if(SUCCEEDED(hr))
                        {
                                DXGI_ADAPTER_DESC adapterDesc;
                                Adapter->GetDesc(&adapterDesc);

                                std::wstring Description = adapterDesc.Description;
                                INT64 VideoRam = adapterDesc.DedicatedVideoMemory;
                                INT64 SystemRam = adapterDesc.DedicatedSystemMemory;
                                INT64 SharedRam = adapterDesc.SharedSystemMemory;

                                std::wcout << L"***************** GRAPHICS ADAPTER DETAILS ***********************";
                                std::wcout << L"Description adaptateur: " << Description;
                                std::wcout << L"Mémoire vidéo dédiée: " << VideoRam;
                                std::wcout << L"Mémoire système dédiée: " << SystemRam;
                                std::wcout << L"Mémoire système partagée: " << SharedRam;
                                std::wcout << L"PCI ID: " << Description;
                                std::wcout << L"niveau de fonctionnalité: " << FeatureLevel;
                        }
                }
        }
}

La variable FeatureLevel est également utile ici, car elle vous présente quelles fonctionnalités de la carte graphique sont véritablement supportées par votre PC.

La détection de la version de Windows peut être importante lorsque vous souhaitez ne supporter que certains types d'installation. Par exemple, vous pourriez ne pas vouloir que votre joueur lance le jeu sur un serveur, ou bien vous pourriez vouloir vous assurer, avant que votre jeu essaie d'accéder à DirectX, que le système d'exploitation ne soit pas Windows XP ou une version plus ancienne si cela peut avoir un impact sur votre jeu.

La détection de la version de Windows est très simple et peut être effectuée en utilisant la fonction win32 GetVersionEx.

WindowsVersion::WindowsVersion() : Checkable("windows/version")
{
    OSVERSIONINFOEX vi;
    ZeroMemory(&vi, sizeof(OSVERSIONINFOEX));
    vi.dwOSVersionInfoSize = sizeof(vi);
    GetVersionEx((LPOSVERSIONINFO)&vi);

    vMajor = vi.dwMajorVersion;
    vMinor = vi.dwMinorVersion;
    spMajor = vi.wServicePackMajor;
    spMinor = vi.wServicePackMinor;

    Build = vi.dwBuildNumber;
    Platform = vi.dwPlatformId;
    ProductType = vi.wProductType;
}

bool WindowsVersion::IsServer()
{
    return (ProductType == VER_NT_DOMAIN_CONTROLLER || ProductType == VER_NT_SERVER);
}

bool WindowsVersion::IsGreaterThanXP()
{
    return (Platform == VER_PLATFORM_WIN32_NT && vMajor >= 6);
}

Ceci, parce que la fonction retourne seulement le plus récent numéro de version si votre fichier exécutable contient le bon manifeste. Si vous voulez détecter cette version, vous devez utiliser, à la place, la dernière Version helper API du SDK Windows 8.1. Si tout ce que vous souhaitez faire est de détecter Windows XP, ou n'importe quelle version plus ancienne que Windows 8.0, alors GetVersionEx fera correctement le travail.

La détection de l'espace utilisable du disque dur est relativement simple, et peut être effectuée via la fonction GetDiskFreeSpaceEx. Vous devez toujours éviter la fonction plus simple GetDiskFreeSpace, qui s'applique au nombre de clusters plutôt qu'au nombre d'octets libres, demandant alors plus de travail pour obtenir une réponse simple au lieu de, juste, renvoyer une simple valeur sur 64 bits que vous pouvez tester.
L'utilisation de cette fonction est très simple :

INT64 userbytes;
  INT64 totalbytes;
  INT64 systembytes;
  BOOL res = GetDiskFreeSpaceEx(L".", (PULARGE_INTEGER)&userbytes, (PULARGE_INTEGER)&totalbytes, (PULARGE_INTEGER)&systembytes);
  std::cout << "Your disk has " << userbytes << " bytes available for use.";

Notez la différence entre userbytes (octets utilisateur) et systembytes (octets système) dans l'exemple ci-dessus. La valeur userbytes est la quantité d'espace disque disponible pour l'utilisateur courant, car l'espace disque peut être limité par un quota. La valeur systembytes est l'espace total ignorant les quotas, disponible pour tous les utilisateurs. Par conséquent, vous devriez, habituellement, vérifier le premier champ du résultat.

Il existe de nombreuses façons de détecter la vitesse CPU. Parmi les plus communes, on trouve :

• utiliser WMI (Windows Management Instrumentation) pour lire les informations Win32_Processor - c'est ma méthode préférée ;
• utiliser le code machine CPUID instruction à travers une instruction assembleur inline - c'est moins portable, mais précis ;
• utiliser une boucle d'attente pour calculer la vitesse CPU - façon principalement dépréciée, car il est extrêmement difficile d'obtenir une information correcte sur des systèmes d'exploitation multitâches, et non recommandée à l'extérieur du code du noyau.

Sur la plupart des systèmes modernes, vous rencontrerez plus probablement des problèmes de manque de mémoire vive, ou l'absence d'une bonne carte graphique avant de rencontrer des problèmes de performance CPU. Votre parcours peut varier, mais basé sur ma propre expérience, passez moins de temps sur la détection de la vitesse CPU et plus de temps sur les autres facteurs, car la vitesse CPU est grandement affectée par tout ce qui tourne sur le système au moment du test et combien d'échange mémoire le système peut être amené à effectuer.