Contrôle de version avec développement de jeux - Quand dois-je créer une succursale?

J'ai récemment commencé à utiliser Version Control avec mes projets (même si je travaille seul sur eux). Je trouve que cela donne un bon moyen de garder l'historique de l'ensemble du processus de développement (avec le suivi des problèmes) et me permet de garder des sauvegardes pour mes projets en cours de route.

Alors que je découvre lentement les fonctionnalités et les avantages de l'utilisation du contrôle de version, je suis coincé autour de l'idée de la branche. Quand dois-je le faire?

Est-ce que cela devrait être à chaque fois que je vais développer une nouvelle fonctionnalité, ou seulement de temps en temps quand j'atteins un certain jalon?

De toute évidence, la ramification est assez inutile lorsque vous travaillez seul, mais je préfère prendre de bonnes habitudes maintenant et m'y habituer.

Alors que je lisais le livre Game Coding Complete de Mike McShaffry (qui est un excellent livre d'ailleurs), je me suis totalement perdu lorsque l'auteur a recommandé de garder trois branches, quelque chose comme:

• Principal : Branche principale de développement où des changements réguliers sont effectués.
• Or : branche d'or où le dernier jalon atteint est conservé.
• Recherche : branche pour tester des choses qui pourraient avoir un impact négatif sur la branche principale (modification de composants importants du moteur de jeu, etc.).

Est-ce ainsi que c'est censé être? Comment ça marche vraiment dans le monde du développement de jeux avec de grandes équipes de développeurs?

Fondamentalement: quand branche-t-on (et fusionne-t-on) habituellement dans le développement de jeux?

La ramification dépend un peu du support VCS pour la fonctionnalité (c'est-à-dire: si le VCS le rend facile ou difficile).

Mais au minimum, vous voulez une branche pour chaque version de votre projet prise en charge de manière indépendante. Autrement dit, si vous avez "Game 2" et "Game 2 + Expansion" qui sont des produits distincts construits à partir de la même base de code, et que vous devez pouvoir corriger et publier des mises à jour, alors vous voulez avoir chacun de ces existent dans leur propre branche hors de la base de code principale, de sorte que les correctifs de la base de code principale peuvent être fusionnés dans chacun de ces produits indépendamment. (En règle générale, ces branches sont créées lorsque chaque produit est publié, ou peut-être quelques jours / semaines avant, si vous avez des personnes travaillant sur des choses dans la base de code que vous ne souhaitez pas sortir avec la version initiale)

Lorsque vous travaillez avec un VCS qui rend l'utilisation des branches délicate ou pénible (SourceSafe, svn, etc.), vous serez probablement plus heureux de maintenir une branche "release" pour chaque produit publié et de faire votre développement principal dans "trunk", fusionner les modifications de "trunk" dans les branches "release" si et quand vous avez besoin de publier des correctifs pour ces versions.

Si, d'autre part, vous travaillez avec l'un des nouveaux systèmes VCS qui sont construits autour de la ramification et de la fusion (git, Bazaar, Mercurial, etc.), alors vous serez probablement le plus heureux de faire votre développement en peu de temps -des branches "fonctionnelles" vivantes. Par exemple, si vous travaillez sur l'IA pathfinding, vous pouvez créer une branche "pathfinding" et y implémenter le code. Lorsque vous avez terminé, vous fusionnez cette branche dans votre tronc de développement principal et supprimez (éventuellement) la branche dans laquelle vous travailliez. L'avantage de cette approche est qu'elle vous permet de travailler sur plusieurs tâches simultanément, au lieu de devoir en terminer une. avant de commencer la suivante.

Dans mon projet actuel (utilisant git), j'ai cinq branches de fonctionnalités différentes actives en ce moment, travaillant sur différentes fonctionnalités. Deux d'entre eux sont des approches alternatives pour faire la même chose (pour le profilage), deux sont des idées expérimentales de mécanique de jeu, et l'un est un grand refactoriseur de mes systèmes d'IA, et est en fait cassé de telle manière que le code ne se compile pas correctement à présent. Mais il est engagé dans sa branche de fonctionnalités pour référence et pour la sauvegarde, et le fait qu'il soit cassé ne m'empêche pas de travailler sur les autres fonctionnalités; Ces autres branches de fonctionnalités (et le tronc de développement principal également) continuent de se compiler et de fonctionner correctement.

D'après mon expérience dans le développement de jeux professionnels en grande équipe, nous sommes toujours principalement coincés avec des systèmes de contrôle de version plus anciens (et pris en charge commercialement). Perforce est probablement le plus utilisé, suivi de Subversion. Partout où j'ai travaillé, nous avons eu une branche «tronc», puis une branche «version» distincte pour chaque livrable (jalon / démo / version / etc). Parfois, quelqu'un crée une branche personnelle pour certains changements énormes qu'il effectue ou teste, mais cela est extrêmement rare et concerne généralement des choses comme "convertir le jeu pour qu'il fonctionne avec cette bibliothèque de physique différente", qui peut ne pas réellement passer par le produit libéré.

Déjà une excellente réponse ci-dessus, mais une chose à noter est quand vous voulez créer une branche et quand vous voulez marquer.

La plupart des vcs vous permettent de baliser (parfois ils l'appellent étiquetage). Vous devez appliquer un tag à chaque fois que vous effectuez une construction majeure (soit pour un test de lecture, soit pour un test bêta, soit pour une fonctionnalité en cours). Si vous utilisez une sorte d'intégration continue (et vous devriez), le système CI doit baliser les builds réussies. Fondamentalement, chaque fois que vous faites quelque chose que vous voudrez peut-être revenir (soit pour créer une branche ou pour vérifier comment vous avez fait quelque chose dans cette version), créez une étiquette / étiquette. Ils sont généralement peu coûteux et simples à ajouter.

L'autre chose que je conseillerais fortement est de conserver vos ressources et votre code dans le même système de version. Avoir une branche (ou une balise) de code est complètement inutile si vous ne pouvez pas faire correspondre (puis brancher) les actifs. C'est l'une des principales raisons pour lesquelles les sociétés de jeux aiment Perforce - il est tout aussi heureux de stocker des fichiers d'art binaire que de stocker du code et (contrairement à git), il est compréhensible pour les types non techniques!

Oh et chaque fois que vous avez envie de vérifier les fichiers compilés dans votre arrêt VCS et de réfléchir à la façon dont vous pouvez éviter de le faire. D'après mon expérience, cela conduit presque toujours à des données incompatibles, à une source manquante (où, par exemple, une texture DDS compressée est archivée mais pas au format png source) et au chaos sur toute la ligne. Si vous avez un pipeline d'actifs mieux servi par les fichiers exportés mis en cache quelque part (de sorte que tout le monde ne régénère pas le même ensemble de fichiers), vous avez certainement un processus de création des actifs source dans votre VCS et de placement des fichiers exportés dans un cache (ou lecteur partagé, ou même un VCS distinct). Mais ne vérifiez pas ces fichiers exportés à la main - cela vous mordra (surtout si vous travaillez en équipe).

J'ai adoré ce livre et je le recommande à tous ceux qui ont des intérêts pertinents. Pour les projets indépendants, il n'y a pas vraiment besoin de créer de branche, sauf si vous avez besoin ou souhaitez créer des versions distinctes; comme un pour Android et un pour PC, ou quelque chose du genre.

Comme vous l'avez dit, si vous voulez reprendre de bonnes habitudes, j'irais avec l'approche de Mike. Cela a beaucoup de sens et c'est l'approche que j'utilise dans mes projets indie à deux.

Tout ce dont vous avez besoin pour pouvoir revenir en arrière et faire plus de travail devrait être branchable (mais pas nécessairement ramifié ... pour le moment).

La raison en est simple. Vous devez être en mesure d'émettre une version fixe de ce code, pas tout autre code, donc à ce moment-là, vous devez travailler sur une branche.

Les VCS sont différents. Certains - comme git - sont très faciles à créer à partir de n'importe quel commit à un moment ultérieur, d'autres - comme CVS - sont très lourds à utiliser plus tard.

Peut-être voulez-vous ouvrir une question sur stackoverflow, vous demandant comment travailler au mieux avec le système de contrôle de version que vous avez choisi? Si vous n'avez pas encore vraiment commencé avec beaucoup d'histoire, vous voudrez peut-être ouvrir une question décrivant votre façon de travailler et demander une recommandation du meilleur système de contrôle de version pour vous?