Structure des données d'une carte

[Angelblade]

Bonjour à tous, je suis ce forum depuis quelques temps sans m'être présenté ou avoir posté de message et puis ca y je me lance
Je m'adresse à vous, connaisseur, dans l'espoir que vous puissiez m'aider sur un point technique.

Actuellement je sauvegarde mes cartes en json selon cette structure:

Code :

{
     nom:'Carte',
     largeur:3,
     hauteur:3,  
     cellules:[
          [2,2,2,0,0,0,1,1,1], // couche0
          [3,3,3,3,3,3,3,3,3] // couche1
     ]
}

Il faut comprendre la structure des cellules comme ceci:

La première dimensions du tableau correspond à la couche, il y a donc ici 2 couches
Ensuite le tableau contient des valeurs les unes à la suite des autres.
Ma carte est donc représenté en couche 0 par une ligne de 2, puis 0, puis 1. (la carte fait 3x3 donc toutes les 3 valeurs on a une ligne)

L'avantage de cette structure est qu'elle peut s'écrire:

Code :

cellules:[
     [2x3,0x3,1x3],
     [3x9]
];

Et avec une fonction simple on récupère le tableau original, ce qui diminue la taille du fichier.
De plus lorsqu'on dessine la carte il est très utile de récupérer toutes les cellules d'une couche.

Cependant une autre structure très sympathique s'écrit:

Code :

cellules:[
     [[2,3], [2,3], [2,3]], // ligne0
     [[0,3], [0,3], [0,3]], // ligne1
     [[1,3], [1,3], [1,3]], // ligne2
]

Permet d'accéder à une cellule particulière d'une manière très logique

Code :

funtion getCell(x,y,z){
     return cellules[x][y][z];
}

Cette structure est visuellement parlante, plus pratique à manipuler et évite des calculs pour retrouver les coordonnées.
Cependant pour dessiner la carte couche par couche ca augmente le temps de traitement et la compression des données est moins facile.

Si vous avez pu me suivre jusque ici, auriez vous encore le courage de me dire ce que vous en pensez?

Amicalement, Angelblade.

[php_addict]

Cependant pour dessiner la carte couche par couche ca augmente le temps de traitement et la compression des données est moins facile.

pourquoi est ce lent? tu dessines tes carte comment et avec quoi?

[Akira777]

Pour ma part, je trouve que JSON est déjà une bonne idée.
En revanche, j'aurais fait un tableau par couche, couche de fond, couche obstacle, couche "toit" (on peut passer dessous) et couche événement...!

Après c'est vrai que c'est pas forcément le plus léger.

[Angelblade]

Je dessine la carte par Javascript via la balise Canvas.
Je présuppose que le rendu de la carte seras plus lent puisque la structure de données n'est pas orienté pour récupérer les cellules d'une couche.

Dans un cas je récup mes cellules présente dans une couche directement par cellules[couche].
Dans l'autre je dois aller la chercher en bouclant coordonée par coordonée sur cellules[x][y][couche].

Mais au final ce n'est peut être pas beaucoup plus long.

Concernant ton post akira777, la première solution, que j'utilise actuellement est justement orienté par couche.
La couche 0 est le sol, ensuite le décor puis le toit (en simplifiant) et enfin les couche 3 celles des évènements.
Cependant comme une carte peut n'avoir que très peu d'évènement et qu'ils sont hautement configurable j'avais pensé à ceci:

Code :

{
     nom:'Carte',
     largeur:3,
     hauteur:3,  
     cellules: /*mes cellules*/
     events: /*mes évènements*/
}

Les évènements pourrait avoir trois formes:

Code :

// un objet ou chaque clé est la cellule, chaque valeur l'évènement
events:{
     0:{type:'pnj'}, // évènement en cellule 0
     5:{type:'monster'}
}

// plus lourd: un tableau où l'event à comme propriété la cellule où il est
events:[
     {cell:0,type:'pnj'},
     {cell:5,type:'monster'}
]

// encore plus lourd: l'event indique ses coordonées sur la map
events:[
     {x:0,y:0,type:'pnj'},
     {x:2,y:1,type:'monster'}
]

Ce que je me demande c'est la structure que je dois privilégier pour les cellules: une structure par couche ou une structure par coordonées?

Et pour les cellules comme pour les events: Dois-je sauvegarder la cellule (un nombre) ou des coordonées x,y

[Roworll]

Si la taille de ta carte est figée, ne changera jamais et est toujours affichée dans son entièreté, un nombre suffira.
Si au contraire ta carte risque de s'agrandir, et/ou est affichée en partie, les coordonnées x/y me semblent plus indiquées.

[Angelblade]

Exact.

Effectivement je dessine partiellement la carte mais j'ai réglé le problème en déplacant les coordonées d'autant que mon écran de jeu est décalé du coin haut gauche de la carte.
Je ne vois pas dans quel cas on peut avoir besoin de changer les dimensions d'une carte mais sait-on jamais.
Et puis ca me parait plus maléable de récupérer une cellule par data[x][y][z] que par data[z][y*largeur+x]

Sachant que c'est plus lourd à stocker avec coordonées je pourrais garder la cellule comme format de stockage.
J'aurais plus qu'à convertir les cellules en coordonées à l'ouverture de la carte.

Je gagne en taille, je perds en processeur (et en clarté?), le compromis est-t-il intéréssant à vos yeux?

[Roworll]

Je ne vois pas dans quel cas on peut avoir besoin de changer les dimensions d'une carte mais sait-on jamais.

Tout simplement un changement de rayon/champ de vision.

Je gagne en taille, je perds en processeur (et en clarté?), le compromis est-t-il intéréssant à vos yeux?

La taille est toujours appréciable dans les échanges même si dans ce cas ça se limite à quelques objets JSON.

Le coté Processeur est variable car il dépendra exclusivement du client.
Pour juger de l'impact du script, tu n'as pas d'autres choix que de tester sur des machines équipées de processeurs plus modestes. Par exemple, j'ai des scripts qui trainent sur mon PC au boulot mais qui sont quasi instantanés sur ma machine perso. Si le temps d'exécution sur une machine bas de gamme est acceptable, je ne vois pas de soucis.

Enfin, pour la clarté, tant que tu sais lire, maintenir et au cas échéant partager ton code, ça ne pose pas plus de problèmes que ça. Si tu as au contraire l'impression de monter une usine instable, il serait plus sage de trouver une solution plus solide.

[Angelblade]

Tout simplement un changement de rayon/champ de vision.

Imaginons si j'ai une vue aérienne et/ou que je dézoome?

Je ne pense pas avoir besoin de ça vu ma façon de faire: Je charge une carte dans son intégralité et le seul cas ou je change de dimensions c'est quand je change aussi de carte.
Si je veux afficher une portion plus importante de la carte je diminue l'échelle de mon dessin et j'augmente le nombre de cellule que j'affiche en largeur/hauteur.

Ma question a trouvé réponse, je pense que je vais opter pour ce format de stockage:

Code :

{
     name:'Carte',
     largeur:3,
     grid:[
          [1x3, 12x3, 9x3], // couche 0
          [6x9], // couche 1
          [nullx9] // couche 2
     ],
     events:{
          0:{type:'pnj'},
          5:{type:'monster'}
     }
}

Et ce format pour l'utilisation

Code :

{
     grid:[
          [[1,6,null], [1,6,null], [1,6,null]], // ligne 0
          [[12,6,null], [12,6,null], [12,6,null]], // ligne 1
          [[9,6,null], [9,6,null], [9,6,null]], // ligne 2
     ],
     events:[
          {origin:0, type:'pnj', x:0,y:0}, // origin indique la cellule ou était l'event au début
          {origin:5, type:'monster', x:2,y:1}
     ]
}

Si un jour ce post peut aider quelqu'un à trouver sa structure ben tant mieux.
Merci pour votre aide, si vous avez des remarques complémentaire n'hésitez pas.

[Akira777]

Sincèrement, j'aurais même pensé à ne pas fixer les dimensions d'une carte. Pourquoi serait-elle carrée ?

Une map du genre :

Code :

#############                                    #######
#############                                    #######
######################################            ######
######################################            ######
######################################            ######
######################################            ######
##################################################
##################################################
##################################################
##################################################
                                          #############################
                                          #############################
                                          #############################
                                                                          #############
                                                                          #############
                                                                          #############

Edit : Bon c'est mal sorti mais vous voyez le genre xD

[Angelblade]

J'y ai pas du tout pensé... o_O

J'ai créé un éditeur de carte et je vois mal comment géré des formes autres que carré.
Pour moi c'est un peu comme sous photoshop ton cadre reste carré même si dedans tu ne dessine qu'une partie.