Comment visualiser les couches de parallaxe dans un éditeur de niveau?

9

Je fais un jeu 2D dans Unity, mais cela s'appliquerait à n'importe quel moteur de jeu 2D.

Si j'implémente la parallaxe multiplane avec des caméras orthographiques, il est difficile de disposer les sprites du calque d'arrière-plan et de savoir où ils s'aligneront avec les sprites des autres calques.

Mon premier réflexe a été d'utiliser plusieurs caméras, une pour chaque couche, et de réduire la vitesse de déplacement des caméras pour les couches d'arrière-plan. Cela évite d'avoir à déplacer tous les sprites d'arrière-plan à chaque image. Le problème est qu'un calque qui se déplace à mi-vitesse occupera la moitié de l'espace du calque principal lorsqu'il est affiché dans l'éditeur. Il est donc difficile de savoir où placer les sprites lorsque vous préparez le jeu. Le problème s'aggrave de façon exponentielle à mesure que vous augmentez le nombre de couches.

Comment puis-je contourner cela? J'ai essayé de mettre à l'échelle les calques de manière inversée en fonction de leur vitesse de déplacement prévue tout en travaillant avec eux dans l'éditeur. Cela place tous les sprites d'arrière-plan aux bons emplacements par rapport au calque principal, mais ils sont horriblement déformés.

Dois-je simplement le sucer et basculer constamment entre l'éditeur et le jeu en cours pour tester les arrière-plans de parallaxe?

2d map-editor parallax-scrolling TenFour04
la source
4
Quand j'ai fait un jeu comme celui-ci, je l'ai fait pour que vous puissiez faire glisser la caméra dans l'éditeur et voir comment la parallaxe fonctionnait. Cependant, je ne sais pas comment faire spécifiquement quelque chose comme ça dans Unity.
Tetrad

Réponses:

1

Je ne connais pas Unity, donc je ne peux pas vous aider avec des détails, mais il semble que ce dont vous avez besoin soit d'implémenter un moyen GUI pour affiner ces valeurs pendant l'exécution avec, par exemple, un ensemble de curseurs ou de champs numériques. Il serait assez simple d'implémenter des champs pour modifier les valeurs que vous déterminez (échelle, vitesse, etc.) pendant l'exécution, ce qui vous donne un retour immédiat. Pour le placement, vous pouvez utiliser des champs ou un placement manuel avec cliquer-glisser (ce qui peut être légèrement plus difficile à implémenter, mais beaucoup plus intuitif).

Cela vous donne un contrôle complet sans compiler et exécuter le code pour chaque petite fraction d'une modification. Lorsque vous arrivez enfin à une apparence dont vous êtes satisfait, utilisez ces valeurs dans votre liste de constantes. Si cela est trop intimidant en raison du nombre de variables que vous modifiez (par exemple, de nombreux emplacements de sprites à de nombreux niveaux), vous voudriez l'implémenter dans un éditeur de niveau, j'imagine, avec la même fonctionnalité de réglage manuel mais avec le résultat de la création et du stockage des données ajustées.

Attackfarm
la source
Oui, il semble que l'utilisation d'un éditeur de niveau soit la meilleure façon de le faire, que ce soit en codant le vôtre, ou dans mon cas avec Unity, en le configurant pour fonctionner avec l'éditeur existant. J'ai codé ma configuration de paralax avec un objet de caméra distinct pour chaque couche, et les caméras se déplacent chacune de manière appropriée par rapport à la caméra principale à chaque image. Utilisez ensuite [ExecuteInEditMode] pour les mettre à jour même lorsque la caméra principale est glissée dans l'éditeur. Je dois juste me rappeler de déplacer uniquement la caméra principale directement.
TenFour04
1

Une idée: je pense qu'un appareil photo pour la couche avant est suffisant. Le placement des sprites à une distance de celle du plan z et le lerpage de la distance vous donne une fraction sur laquelle déplacer ce calque arrière.

Par exemple, une distance d'objet de 10 par rapport à la caméra avant se déplace de 1/10 dans le calque d'arrière-plan. Un objet de distance 2 se déplacerait de 1/2 dans sa couche respective, etc.

Jason Coombes
la source