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

En général, lorsque vous écrivez votre jeu, vous n'effectuez qu'une très petite réflexion initiale au sujet des spécifications système. Le schéma habituel de pensée pourrait être : « Bien, ça tourne sur mon système, donc je publierai cela comme spécifications minimales ou recommandées dans un fichier readme ou sur mon site web ».

Cependant, que va faire votre jeu si le PC du joueur ne répond pas à vos attentes ?Cet article va souligner quelles sortes de choses vous devez vérifier et quand ?

Cet article est orienté Windows et DirectX, car c'est ma plateforme de prédilection. Les concepts sont transférables aux autres plateformes et structures, cependant le code source, que je donne, ne l'est pas.

3 commentaires Donner une note à l'article (5)

Article lu   fois.

Les deux auteur et traducteur

Traducteur :

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Pourquoi devrais-je même essayer de détecter les spécifications système ?

I-A. Cela donne une bonne impression

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.

I-B. Cela réduit le support

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.

I-C. Cela aide à la stabilité du système

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.

II. Comment et quand détecter les spécifications système ?

Vous devriez tenter de détecter les spécifications du système chaque fois que votre jeu se lance. Cela devrait être fait de préférence avant qu'aucun système ne soit correctement initialisé, de sorte que Windows soit toujours dans un état où l'utilisateur peut cliquer correctement les messages d'erreur et revenir à ce qu'il faisait avant d'essayer de lancer votre jeu.

Dans mon propre jeu, j'ai divisé la détection des spécifications du système en plusieurs classes, dont chacune est responsable de la détection de l'état d'un sous-système. Chacune est appelée à son tour, avec des vérifications simples faites en premier, car certains systèmes dépendent des autres pour fonctionner.

Il est préférable de laisser le code qui vérifie les spécifications du système jusqu'au dernier moment dans votre jeu, car vous ne saurez qu'à la fin quelles sont les spécifications dont votre jeu aura besoin (elles sont susceptibles de changer de façon répétée au cours du développement).

Les sous-systèmes importants à vérifier sont :

  • mémoire vive - est-elle suffisante pour faire fonctionner le jeu ?
  • vitesse CPU - le CPU est-il assez rapide ? Est-il multicœurs ?
  • espace disque dur - est-il suffisant pour enregistrer les fichiers de jeu et autres données que vous pourriez y mettre ?
  • vitesse disque dur - votre jeu va-t-il s'effondrer lorsque vous chargerez des ressources depuis le disque dur ?
  • vitesse GPU et mémoire vidéo - les performances graphiques de la machine sont-elles suffisantes ?
  • connexion réseau - y a-t-il une connexion réseau ? Internet est-il disponible, par exemple pour rechercher des mises à jour ?
  • version Windows - la version de Windows est-elle suffisamment à jour pour faire ce que vous voulez faire ?

Je vais couvrir une partie de ces vérifications dans cet article et vous dire où vous pourrez trouver le code pour les autres, en effet, couvrir toutes les possibilités que vous pourriez vouloir vérifier est au-delà de la portée de cet article, car beaucoup de choses sont spécifiques au système.

II-A. Vérification de la quantité de mémoire vive

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 :

 
Sélectionnez
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);
  }

II-B. Vérification de la quantité de mémoire graphique

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 :

 
Sélectionnez
#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.

II-C. Détection de la version de Windows

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.

 
Sélectionnez
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);
}

Attention, lorsque vous utilisez cette fonction ! Vous ne pouvez pas l'utiliser pour détecter si le joueur utilise Windows 8.1, mais seulement pour détecter Windows 8.0.

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.

II-D. Détection de l'espace utilisable du disque dur

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 :

 
Sélectionnez
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.

II-E. Détecter la vitesse CPU

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.

III. Conclusion

Le conseil donné ci-dessus devrait vous aider à détecter efficacement les spécifications du PC du joueur. C'est, bien évidemment, juste un morceau d'un très gros iceberg, et, une fois, que vous avez commencé à détecter différentes métriques du système de votre joueur, vous devrez continuer à penser aux autres choses que vous devez réellement vérifier. Pourtant, ne vous laissez pas embarquer, car il est facile d'être distrait à détecter de potentiels cas marginaux, plutôt que de travailler sur le jeu lui-même.

IV. Remerciements

Cet article est une traduction autorisée dont le texte original peut être trouvé sur GameDev.net.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2015 Craig Edwards. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.