Techniques de débogage en temps réel

Il n'y a rien de tel que la routine de modification d'une variable, la compilation de code qui prend quelques minutes, l'exécution du code, la prise de conscience que votre modification était dans la mauvaise direction et la répétition du processus.

Je voudrais commencer à interagir avec ma logique de jeu pendant qu'une session est en cours. De quelles façons avez-vous géré cela?

Je serais ouvert à entendre des solutions pour iOS, C / C ++ et C # / XNA.

Je viens de découvrir cela pour les développeurs iOS -

AsyncSocket
Vous configurez un serveur dans votre application et vous vous y connectez via un terminal. Vous pouvez ensuite remonter les commandes à distance et commencer à manipuler les variables en temps réel. Assez lisse.

• Article de blog Mystery Coconut Games à ce sujet
• Page de codes Google pour AsyncSocket

L'intégration d'un langage entièrement interprété peut vous permettre de réécrire des éléments de jeu très, très facilement à la volée.

Python, Lua, etc. peuvent tous être utilisés expressément pour cela. Angel Engine peut probablement servir d'exemple.

Le chargement à chaud est un autre élément à vérifier (en gros, un événement est déclenché vous indiquant qu'un actif a changé - un fichier de configuration, un élément artistique, etc. - et vous l'exécutez à travers une série de conditionneurs qui le modifient pour le format final avant de remplacer l'existant par le nouveau.

J'ai travaillé avec un moteur de prototypage rapide qui utilisait le chargement à chaud et c'était un plaisir.

Eh bien, en ce qui concerne C ++, C # et C # avec XNA, Visual Studio dispose d'excellents outils de débogage - suspendre l'application en temps réel à tout moment dans le code, voir les valeurs affectées aux variables à tout moment, parcourir les appels de fonction , analysez la pile d'appels, etc. De plus, des outils comme Pix et CLR Profiler rendent le développement avec DirectX (Pix) et les langages basés sur CLR (CLR Profiler) excellents.

De plus, une partie particulièrement utile du travail avec les jeux est que nous avons cette zone géante pour écrire du texte de débogage, des graphiques, etc. Les graphiques en temps réel de l'utilisation de la mémoire, le nombre d'objets / sommets dessinés, la fréquence d'images, etc. sont des choses courantes à dessiner à l'écran.

En C / C ++, une astuce simple est de mettre votre tweakable dans une variable statique, de déclencher un point d'arrêt, de changer le statique dans le débogueur et il reste persistant jusqu'à la sortie.

La journalisation HTTP est d'une grande aide et n'est pas difficile à mettre en place et à exécuter. Vous pouvez même utiliser Google App Engine comme un moyen rapide de le faire fonctionner. Les données sont toujours utiles.

Les scripts et XML peuvent être rechargés à la volée et ne nécessitent aucune réinitialisation. Laissez-les échouer sans arrêter le jeu. Cela donne beaucoup de pouvoir aux artistes, testeurs et designers.

Menu de débogage dans le jeu Un menu de débogage simple dans le jeu que vous pouvez générer en tant qu'enfant et geler le jeu avec les curseurs du moteur et les curseurs du jeu. Vous permettant de modifier les numéros de clé lors de l'exécution et peut-être d'effectuer une ou deux fonctions de débogage ou des vidages d'informations.

J'aime aussi les sockets ASYNC comme mentionné dans la réponse de David

Facile à utiliser Votre équipe de jeux doit être en mesure d'ajouter à ces outils et de les utiliser très facilement, sinon ils ne seront tout simplement pas utilisés.

Je sais que Sean James l'a déjà dit . Mais sérieusement, Visual Studio (en particulier les outils de débogage) est formidable pour cela.

Je n'utilise pas beaucoup le C ++ de nos jours, donc je ne sais pas dans quelle mesure ceux-ci s'appliquent ici. Mais pour C # (y compris dans C # Express) vous avez:

• Modifier et continuer - où vous pouvez apporter des modifications en gros à votre logique de jeu.
• La fenêtre de surveillance - où vous pouvez facilement voir et modifier des variables.

Et cela pourrait vous couper le souffle (ça m'a fait exploser quand je l'ai découvert):

• La fenêtre immédiate - où vous pouvez taper et exécuter / évaluer du code arbitraire .

La fenêtre immédiate est en fait assez difficile à trouver (elle se trouve dans le menu Debug / Windows).

Le seul inconvénient majeur de l'utilisation du débogueur Visual C # est qu'il n'aime pas changer les constvaleurs. Donc, je fais généralement mes valeurs liées au gameplay staticpendant que je les ajuste.

(Aussi: avoir deux moniteurs aide beaucoup.)

Maintenant, je dois admettre que la méthode ci-dessus implique de suspendre votre application, ce qui peut être insuffisant pour quelques choses particulièrement délicates.

Dans ces rares occasions, ce que je fais (dans XNA) est de simplement pirater un peu de code (probablement en utilisant Edit et Continue, comme ci-dessus) pour récupérer Keyboard.GetState().IsKeyDown()(en fait, j'ai un wrapper plus facile à taper pour cela) et ajuster le valeur par touches. Rien de plus compliqué ne vaut l'effort.

Dans la pratique, ce que je trouve généralement beaucoup plus important est de pouvoir visualiser (plutôt que modifier) ​​les valeurs en temps réel. Pour cela, j'ai une jolie petite classe qui peut tamponner des lignes et du texte à dessiner à la fin du cadre. Il est également utile pour le prototypage rapide.

(Et, encore une fois, c'est agréable de pouvoir "éditer et continuer" ces visualisations au moment de l'exécution.)

_{(source: andrewrussell.net )}
( d'ici )

Je crains de ne pas avoir de "belle" source à publier pour le moment (peut-être plus tard). Mais il s'agit essentiellement d'une liste de lignes (pour cette bibliothèque de lignes rondes ) et de chaînes (pour SpriteBatch intégré à XNA). Faites-le public staticquelque part et dessinez tout avec une transformation appropriée pour que tout apparaisse dans "l'espace du monde" (puis effacez les listes pour la prochaine image).

Écrire un système de réflexion simple pour C / C ++ est assez trivial. De cette façon, vous pouvez parcourir toutes vos variables dans le jeu (que ce soit avec un outil réseau, un clavier ou un joypad) et les modifier selon le contenu de votre cœur. Cela fonctionne pour moi, mais toutes les réponses ci-dessus sont également valables.

Modifié pour ajouter: ce fil est maintenant sur le réglage, pas le débogage selon le titre du fil.

Une solution que j'ai vue dans plusieurs studios est une application de débogage externe qui s'attache à votre programme en utilisant le réseau. Cette application affiche des variables exposées spécifiques et vous permet de les modifier en temps réel. L'ajout de nouvelles variables consiste à ajouter des macros au code du jeu.

La configuration initiale des macros côté jeu, du protocole serveur / client (les solutions que j'ai vues juste sérialiser le XML en avant et en arrière) et l'écriture du client, est importante. Cependant, c'est extrêmement utile, d'autant plus que l'utilisation du réseau pour la communication signifie que vous pouvez travailler sur n'importe quelle plate-forme.

Liez le chargement et la lecture de la variable dans un fichier texte et lancez-le à l'aide d'une liaison de touches ou d'une commande spécifique à partir de la console.