Java (Android) lecture séquentielle de valeurs - Page 1

Coucou a tous,

Je continue de 'm'amuser' avec ce super langage...... Je viens réquerir votre aide, car j'aimerais savoir y aurait il une possibilité de faire une lecture séquentielle de valeurs de taille différentes ?

En gros pour ceux qui connaissent l'asm 68000 (Bien sur !) :

Valeurs : dc.w 4,4
dc.b "coucou"
dc.w 1,2,3,4,5,6,7,8,9

Il y a un moyen de le faire en Java sans devoir écrire une classe, faire ceci et cela ?

J'ai plusieurs valeurs que je dois lire, qui auraient des tailles différentes. Exemple, deux entiers, une chaine de caractère (Nom de fichier) puis quelques entiers.

Donc comment faire pour les déclarer (les initialisés) et ensuite les lire ?

GT plutot pour l'asm mais bon

Tu veux les lire depuis quelle source ?

Object[] vals = {4,4,"coucou",1,2,3,4,5,6,7,8,9};

for(Object o: vals) {
if(o instanceof Integer) {}
else if(o instanceof String) {}
}

?

ou bien

char[] ch = {4,4,'c','o','u','c','o','u',1,2,3,4,5,6,7,8,9}

les char sont des unsigned short en java.

?

(squalyl > tu es sûr que l'autoboxing vers object ça marche ? #humfus#)


GT Turbo > Mmmm là tu as écrit tes données mais tu veux faire quoi en les parcourant ? En assembleur tu considérerais que toutes tes données font la même taille ? (1 octet ?)

Si c'est pour les lire dans un flux (fichier, réseau, ...), la classe DataInputStream est probablement ce que tu recherches (et DataOutputSteam pour y écrire). Il faut que tu construise l'objet en passant en paramètre le flux (par exemple FileInputStream pour un fichier) que tu souhaites utiliser.

Merci beaucoup les amis.

Je bosse sur un jeu, chaque niveau est décrit par sa taille en x et y (Deux premiers paramètres), un nom de fichier (D'ou les caractères, avec une taille fixe donc pas de soucis) puis le numéro des tiles (nombre qui est variable mais qui vaut donc x*y (Les premiers paramètres).

J'en profite vu qu'il y a des personnes compétentes ici (Explications dans le P.S. ).

J'ai plusieurs niveaux (C'est la grande classe n'est ce pas ) enfin pas encore c'est pour cela que je vous pose cette question. Je voudrais donc avoir un 'bordel' comme décrit tout a l'heure pour chaque niveau, mais pour tous les stocker donc pas de soucis. Mais si je veux accèder directement a un niveau (Enfin son descripteur va t'on dire) le plus simple c'est quoi ?

Peux t'on faire une liste de pointeur comme ?

Liste_niveaux : dc.l Niveau1, niveau2, niveau3, etc...

Niveau1: dc.w 8,8
dc.b "niveau1"
dc.w 2,3,4,5*

ou c'est pas possible ? Il y a plus simple en java ?

Zero : bonne question ces données risquent de finir dans un fichier (pas sur a 100% encore), mais pour l'instant déjà dans le prog principal.



GT Enfin aidé !!

P.S. : je suis inscrit sur deux forums de dev se terminant par Android, chaque fois que j'ai posé une question dessus, je me suis auto répondu O_o Alors quand un de ces forums vous envoie un email vous demandant ce qu'il faudrait faire pour améliorer le forum. Tu hésite a répondre, pour éviter les insultes.

Yaronet le seul forum français ou il y aurait des personnes compétentes ?

La recommendation d'Uther est à mon avis la plus pertinente. Et oui j'espère bien que tu vas finir par mettre ça dans un fichier, les niveaux dans le code c'est très bof. Pas pratique pour s'y retrouver, ou éditer avec des outils externes (éditeur de niveau que tu vas bientôt coder n'est-ce pas ? ). N'oublie pas qu'en Java ton programme est de toute façon composé de plusieurs fichiers, zippés dans un JAR, donc c'est très facile d'ajouter une ressource. Et après Le DataInputStream est ce qu'il te faut pour lire/écrire.

Dans mon jeu que tu as pu voir à la RGC si tu t'es baladé, les données prennent la forme d'une arborescence composée d'images et de fichiers JSON décrivant les niveaux, les animations, etc. ainsi le tout peut donc être édité depuis un éditeur de niveau externe, uploadé sur un FTP (la version iPhone le télécharge et l'extrait en local, pour rapidement voir les modifs), et mon pote qui est graphiste peut faire un certain nombre de tests et modifications sans avoir besoin de toucher au code. Enfin, si nécessaire il sera possible ensuite de faire un "compilateur+linker" qui lit ces JSON et crée un gros binaire à inclure dans le code, histoire d'être très rapide à traiter et pouvoir fonctionner sur une ancienne machine.

Oui les niveaux 'hardcode' dans le jeu c'est pas terrible, m'ai je voudrais déjà essayer en 'dur' pour d'abord essayer. L'assembleur est mon langage ou je suis le plus a l'aise, j'aurais dans ce cas de figure je l'aurais fait direct dans un fichier. surtout que dans ce cas de figure, le fichier chargé en mémoire, l'accès aurait été exactement le même que coder en dur dans le prog.

C'est juste que je suis vraiment un débutant dans ce langage, et c'est mon premier langage orienté objet, et aussi le premier langage que je fais ou j'uilise du code des autres (librairies, etc...).

Parfois j'ai l'impression d'essayer d'aprendre un langage cyrillique avec un dico écrit en allemand, tellement cela change pour moi.

Oui je vais voir avec Datainputstream. Ca colle très bien avec mes besoins. Moi tu vois faut encore que je crée un fichier pour faire les essais, donc que j'écrive une classe qui me génère le fichier, et donc double source d'erreurs possibles, car après faudra que je cherche si problème il y a (enfin non problèmes il y aura car c'est mon code ), si cela vient de la génération du fichier ou de la lecture.

Je sais que pour beaucoup d'entre vous ca doit ètre simple, mais je viens d'un 'monde' ou je codais des démos, ou même un debugger était inutilisable, les approches sont a l'opposés, les techniques aussi etc...

Merci pour votre compréhension

GT Pas super a l'aise en Java

Je te l'accorde. Procède par étape pour éviter les ennuis.
1ère étape : tu crées un fichier (comme un fichier source). Tu peux y mettre du texte, les classes permettent de lire ça aussi (je crois qu'il te faut un Scanner).
2ème étape : tu fais en sorte de l'inclure au JAR. Tu peux vérifier si ça a marché en dézippant le JAR (c'est juste l'extension qui change).
3ème étape : tu essaies de te débrouiller pour ouvrir le fichier (il te faudra trouver son nom, il faut passer par le ClassLoader et getResource de mémoire)
4ème étape : une fois que tu as un DataInputStream en main (donc pas d'exception s'étant produite avant) tu es bon pour faire joujou avec.

C'est plus chiant que faire dans le code en effet, par contre une fois que tu l'as fait tu seras content

Sinon tu te fais une classe Level qui stocke tout et tu sérialises :

import java.io.Serializable ;


public class Level
   implements Serializable
{
   public Level( String name,
                 int[][] tiles )
   {
      this.name= name ;
      this.tiles= tiles ;
   }


   int getWidth()
   {
      return tiles[0].length ;
   }
   int getHeight()
   {
      return tiles.length ;
   }

   int getTile( int x, int y )
   {
      return tiles[y][x] ;
   }


   @Override
   public String toString()
   {
      StringBuilder sb= new StringBuilder() ;
      sb.append(name).append('\n')
        .append("width: ").append(getWidth()).append('\n')
        .append("height: ").append(getHeight()).append('\n') ;
      for ( int[] row : tiles ) {
         for ( int tileNum : row ) {
            sb.append(tileNum).append(" ") ;
         }
         sb.append('\n') ;
      }
      return sb.toString() ;
   }

   String name ;
   int[][] tiles ;
}

public class BinSerializer
{
   /**
    * Sérialise un object quelconque dans un byte array
    * @param serializableObject l'object à sérialiser
    * @return le byte array ou <code>null</code> en cas de problème
    *
    */
   public static <T extends Serializable>
   byte[] serializeToBytesArray( T serializableObject )
   {
      ByteArrayOutputStream baos= null ;
      ObjectOutputStream oos= null ;
      try {
         baos= new ByteArrayOutputStream() ;
         oos= new ObjectOutputStream(baos) ;
         oos.writeObject(serializableObject) ;
         oos.flush() ;
         return baos.toByteArray() ;
      }
      catch ( IOException ioe ) {
         ioe.printStackTrace() ;
         return null ;
      }
      finally {
         try {
            if ( oos != null ) {
               oos.close() ;
            }
            if ( baos != null ) {
               baos.close() ;
            }
         }
         catch ( IOException ioe ) {
            ioe.printStackTrace() ;
         }
      }
   }


   /**
    * Déserialise un object à partir d'un byte array
    * @param ba le byte array qui correspond à l'objet sérialisé
    * @return l'object ou <code>null</code> en cas de problème
    *
    */
   public static Object unSerializeFromBytesArray( byte[] ba )
   {
      final ByteArrayInputStream bais= new ByteArrayInputStream(ba) ;
      ObjectInputStream ois= null ;
      try {
         ois= new ObjectInputStream(bais) ;
         return ois.readObject() ;
      }
      catch ( IOException e ) {
         e.printStackTrace() ;
         return null ;
      }
      catch ( ClassNotFoundException e ) {
         e.printStackTrace() ;
         return null ;
      }
      finally {
         try {
            if ( ois != null )
               ois.close() ;
            bais.close() ;
         }
         catch ( IOException ioe ) {
            ioe.printStackTrace() ;
         }
      }
   }
}

public class GTTurbo
{
   public static void main( String[] args )
         throws IOException
   {
      File f= new File(System.getenv("USERPROFILE"), "level.gtt") ;

      byte[] serializedLevel ;
      if ( !f.exists() ) {
         Level l ;
         {
            //Création du niveau
            int[][] tiles= new int[][]{
               {1, 2, 3, 12},
               {4, 5, 3, 13},
               {3, 1, 6, 42},
            } ;
            l= new Level("my first level", tiles) ;
         }

         //Sauvegarde du niveau (via une sérialisation)
         serializedLevel= BinSerializer.serializeToBytesArray(l) ;

         //Tu fais ce que tu veux de ton serializedlevel, par exemple tu l'écris dans un fichier
         BufferedOutputStream bos= null ;
         try {
            bos= new BufferedOutputStream(new FileOutputStream(f))  ;
            bos.write(serializedLevel) ;
         }
         finally {
            if ( bos != null ) {
               bos.close() ;
            }
         }
      }
      else {
         serializedLevel= new byte[(int)f.length()] ;
      }



      //Et tu peux le relire après :
      BufferedInputStream bis= null ;
      try {
         bis= new BufferedInputStream(new FileInputStream(f)) ;
         bis.read(serializedLevel) ;
      }
      finally {
         if ( bis != null ) {
            bis.close() ;
         }
      }


      Level myLevel= (Level)BinSerializer.unSerializeFromBytesArray(serializedLevel) ;

      System.out.println(myLevel.getTile(3, 0)) ;
      System.out.println(myLevel.toString()) ;
   }
}

Merci a tous, pour votre aide, vos conseils.

Pen 2, merci beaucoup de tout m'écrire, tu avais trop de temps libre


En tout cas je confirme, sur Yaronet il y a des personnes compétentes !!!


Merci a tous

GT Epaté !!

(C'est surtout que j'avais déjà du code sous la main, c'était pas long d'adapter le reste )

Au passage, tu peux sérialiser en XML aussi, c'est toujours bon à savoir.
Dans ce cas, tu peux utiliser les mécanismes fournis en standard, mais je conseille xstream (http://xstream.codehaus.org/ ), c'est terriblement efficace et ne pose aucune contrainte sur les classes à sérialiser (mais j'ignore si ça passerait sur android)

Sinon, il faut quand même dire que la sérialisation c'est peut-être un peu bourrin dans le sens ou tu n'as aucun contrôle sur le format de fichier, donc bon... (attention lors de l'évolution de la classe Level par exemple !)
Mais si tu t'en moques, c'est très pratique