La meilleure façon de créer une carte pour un jeu 2D?

Je m'excuse pour le "meilleur" mot-clé subjectif.

Mon ami et moi avons commencé à créer un jeu d'aventure 2D. Ce sera de haut en bas dans le style de pokemon ou zelda (juste la perspective). Nous avons discuté des méthodes de création d'une grande carte du monde que le joueur peut parcourir sans épuiser les capacités de mémoire de notre machine.

Notre première impulsion a été de créer une grande carte et un cercle autour du lecteur dans lequel le contenu sera chargé. Nous avons pensé que cela ne durerait pas longtemps et avons décidé de partitionner la carte en sections. Tout d'abord, nous avions quatre grandes sections, mais nous avons réalisé que nous pouvions simplement le décomposer en plusieurs petites sections.

J'ai joué du Zelda de la SNES et j'ai vu que, pendant le déplacement d'une carte, le contenu pouvait être chargé à ce moment-là. Ce que je veux dire, c'est qu'au lieu de simplement vérifier une zone rectangulaire pour les données à charger, nous sectionnons simplement la carte en plusieurs petits morceaux qui chargent et déchargent les données lorsque nous passons d'une partie de carte à une partie de carte.

Aujourd'hui, il m'a dit qu'il voulait créer une carte de tableau simplement 2D [LARGEUR] [HAUTEUR] qui contient des données sur chaque grille du jeu et est une opération de sauvegarde constante sur le disque pour les données dont nous n'avons pas besoin.

Je ne suis pas sûr de ces idées et j'ai pensé que je pourrais l'aimer ici. Tout lien, ressource ou tutoriel sur le sujet serait grandement apprécié ainsi que des réponses directes à notre question sur la manière de le faire efficacement.

Tout d'abord, estimez la taille de votre carte. Ne vous contentez pas de supposer qu'un "grand monde" ne restera pas dans la mémoire. De nos jours, une carte occupant plus de 10 Mo en mémoire est tout à fait acceptable, et vous pouvez farcir BEAUCOUP en 10 Mo dans un monde 2D simple basé sur des tuiles.

Si vous avez un monde vraiment vaste, la solution la plus robuste est en effet d'utiliser des morceaux de carte. Divisez votre monde en morceaux de taille fixe (disons, 64x64). Charger des morceaux à la volée pendant que le joueur se déplace, en gardant au moins un morceau chargé dans toutes les directions (c'est-à-dire charger le morceau dans lequel se trouve le joueur et tous ses voisins).

En ce qui concerne le déchargement de morceaux, vous pouvez choisir entre plusieurs stratégies. Le déchargement rapide signifie que vous déchargez et enregistrez sur le disque tous les morceaux au moment où le joueur se déplace suffisamment loin; mais vous pouvez également retarder le déchargement pour améliorer les performances (économiser des morceaux, comme tout accès au disque, est une opération coûteuse).

Personnellement, je construisais la carte en utilisant un éditeur de tuiles désigné comme TileEd . Cette approche présente plusieurs avantages:

• Utilise moins de ressources. Il vous suffit de charger une feuille de tuiles et un fichier de données avec des index pour créer une carte potentiellement infinie.
• Étant donné que votre carte sera divisée en très petits morceaux (selon la taille de votre mosaïque), vous pouvez facilement ajouter / supprimer des lignes / colonnes pendant que le personnage se déplace dans le monde.
• Avoir un fichier de données qui décrit votre carte vous permet également d'ajouter facilement des informations sur le terrain. Cela permet différents types de tuiles comme des murs ou des lacs (c'est-à-dire des obstacles) ou un marécage où le mouvement du personnage pourrait être ralenti ...
• Enfin, une carte basée sur des tuiles est également beaucoup plus facile à modifier et à modifier plus tard, car vous pouvez toujours lancer l'éditeur, modifier certaines choses et enregistrer un nouveau fichier de données.

Je vous suggère d'éviter de charger des morceaux de la carte pendant le jeu pour éviter tout décalage. Comme mentionné précédemment, cela ne devrait pas être nécessaire car vous pourrez probablement conserver la feuille de tuiles en mémoire. Lorsque le personnage entre dans une autre partie du "monde", vous pouvez échanger la feuille de tuiles avec une autre (par exemple, des tuiles neige remplacées par des tuiles désert).

Blitting les tuiles à l'écran est probablement le moyen le plus rapide pour rendre votre carte. Je ne connais pas SFML, mais à partir des documents sur leur site, vous devriez regarder dans la Spriteclasse ou utiliser la Copyfonction de la Imageclasse.

Mise à jour: je viens de lire certains des documents SFML et vous devez absolument utiliser Drawableou Spriteau lieu de manipuler des images pour des raisons de performances. Apparemment, il existe un chargeur SFML en mosaïque . C'est probablement un bon moyen de faire fonctionner rapidement quelque chose.

Commencez par faire de la carte la taille requise pour raconter l'histoire que vous souhaitez que le jeu raconte. Testez sur la machine avec les spécifications minimales requises pour que les gens puissent jouer à votre jeu. S'il est trop lent, profilez et optimisez.

À mon avis, il est préférable d'utiliser un tableau 2D de carreaux individuels. Vous pouvez avoir la grande carte entière en un seul tableau 2D et ne dessiner que la partie qui doit être affichée à un moment donné. Voici un exemple d'utilisation d'un tableau de cartes 2D avec la bibliothèque de jeux HTML5 tabageos (tbgs.js); http://actiontad.com/tabageosHTML5/Examples/BlitMathCameraAndTravelers/

À moins que vous ne planifiiez de reconstruire Ultima-Online (Fallout 3 ou Oblivion), il n'y a aucune raison pour que le monde soit transparent. Baldur's Gate et Icewind Dale sont deux jeux qui viennent à l'esprit qui implémentent des cartes efficaces qui ne nuisent pas au gameplay.

Certes, vous avez beaucoup plus de puissance de calcul qu'eux, donc les écrans de chargement devraient être minimes, mais même Fallout et Oblivion ont des écrans de chargement pour certaines choses.

Tout ce que je peux vous dire, c'est que pour moi, j'écris une petite bibliothèque Obj-C pour l'iPhone qui prend un jeu de tuiles 32x32 et le dessine dans un NSImage. J'obtiens environ 10fps de cette façon, et je devrais probablement utiliser OpenGL, mais je n'ai besoin de redessiner que si le personnage sort du rectangle.

Vous devez diviser la carte en 9 tailles d'écran (pour moi, ce sont des blocs de 960 x 640) donc si le personnage sort du bloc central, je redessine les 9 écrans en une grande image (environ 1,2 Mo - donne beaucoup de sous la limite de 20 Mo sur iPhone 3G). Cela se produit assez lentement (beaucoup plus lentement que 10 images par seconde), de sorte que le nouveau dessin n'est pas perceptible pendant la lecture.

Je vais probablement passer à OpenGL ES à un moment donné, mais pour l'instant cela fonctionne bien.

[ÉDITER]

Permettez-moi de clarifier.

L'algorithme de dessin pour l'arrière-plan de 9 écrans prend 0,1 seconde (10fps à plat). À moins que votre joueur ne puisse parcourir un écran entier en moins d'un dixième de seconde, le redessin devrait être imperceptible pendant le jeu.