Bataille navale

[sc]

Bonjour,

Un vrai challenge pourrait être de créer une bataille navale à deux bateaux sous forme de tableau 5x10 du style suivant (les 1 étant les deux bateaux de longueur 3 et 2)

0001110000
0000000000
0000001000
0000001000
0000000000

La programmation devra être procédurale avec
Une procédure pour afficher le plateau de jeu.
Une procédure pour poser le bateau de longueur 3 : ici en 1,4,H (1ère ligne, 4ème colonne, horizontal)
Une procédure (ou la même) pour poser le bateau de longueur 2 : ici en 3,7,V (3ère ligne, 7ème colonne, vertical)
Une procédure pour jouer et répondre par "touché" ou "coulé"

Bon courage et poursuivez bien vos vacances !!!
(pensez bien à mettre votre code dans un spoliertempo, par exemple jusqu'au temps 1352020000 mais mettez une copie d'écran de l'éxécution du programme)

NB :
En java, la création et la manipulation d'un tableau se fait par exemple de la manière suivante :

Code: Tout sélectionner


int[][] tableau =
                    {
                        { 10, 20, 30, 40 } , // tableau [0] d'entiers
                        { 100, 110, 120, 130, 140, 150, 160 } // tableau [1] d'entiers
                    };
               
                System.out.println(tableau[0][0]); //affiche l'élément de la 0ème ligne et 1ème colonne
                System.out.println(tableau[1][2]); //affiche l'élément de la 1ème ligne et 2ème colonne
               
                tableau[1][2]=1500;                        //modifie  l'élément de la 1ème ligne et 2ème colonne
                System.out.println(tableau[1][2]); //affiche l'élément de la 1ème ligne et 2ème colonne
 

En Python, la manipulation est plus aisée, elle s'effectue ainsi :

Code: Tout sélectionner


tableau=[ [10,20,30,40] ,[100,110,120,130,140,150,160] ]
print(tableau[0][0])
print(tableau[1][2])
tableau[1][2]=1500
print(tableau[1][2])
 

[askolein]

C'est en effet un sacré challenge


Par contre le tableau est assez dur à comprendre..

[kilag]

bon ba bonne chance pour le faire

[askolein]

Donc, à la base, l'utilisateur ne sait pas où sont les bateaux, ils sont générés aléatoirement?

[kilag]

c'est un peut le but d'une bataille navale

[askolein]

J'ai terminé, c'est un programme très amusant !

J'ai tout bien structuré, commenté, c'est très simple à comprendre (à copier dans eclipse)
300 lignes de code !
-Un bel affichage
pose de bateaux ALEATOIRE !

DONC c'est vraiment complet !


Challenge Succesfull

Code: Tout sélectionner


import java.util.Scanner;


public class ddd {

        /**
         * @param args
         */
        ////////////////////////////////////// PROCEDURES /////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////PROCEDURES/////////////////////////////////////////////
       
       
        /////////////////////// AFFICHAGE du TABLEAU //////////////////
        static void show(int[][] tableau)
        {      
                        int affc=0;
                for(int i = 0; i<5; i++)                       
        {              
                       
                   System.out.print(affc+"-");  
                   affc=affc+1;
          for(int j = 0; j<10; j++)
          {              
            System.out.print((tableau[i][j]));  
          }
          System.out.println("");  
        }              
                                       
        }      
        ///////////////// PROCEDURE POSAGE BATEAU /////////////////////
        static void bateau(int[][] tableau ,int l, int c, String align)
        {      
                // Horizontal
                if(align=="H")
                {
                        for(int j=c; j<(c+3); j++)
                {    
                                tableau[l][j]=1;                       
                }
                }              
                // Vertical
        if(align=="V")
        {
                for(int i=l; i<(l+2); i++)
                {    
                                tableau[i][c]=1;
                }
        }
        }
        ///////////////// PROCEDURE TOUCHE ou COULE //////////////////
        static void tir(int[][] tableau,int[][] tjoueur,int l1,int c1)
        {      
                int count=0;
                // SI TOUCHE
                if(tableau[l1][c1]==1)
                {                      
                        System.out.println("\n|||||||||RESULTAT|||||||||||  ");    
                        System.out.println("\n |____Touché !____|\n");                        
                        tjoueur[l1][c1]=1;
                       
                        // Verification coulé
                        for(int c=0; c<10; c++) // Pour le bateau horizontal
                {                              
                                if(tjoueur[l1][c]==1)
                                {                                              
                                        count=count+1;                                 
                                        if(count==3) // si il y a 3 "1" sur une ligne, alors :Yeehaaa !
                                        {      
                                                System.out.println("\n|||||||||RESULTAT||||||||||");  
                                                System.out.println("\n------- Frégate à 3 Cases coulé !! --------\n");                                              
                                        }
                                }
                }
                        count=0;
                       
                        for(int l=0; l<5; l++) // Pour le bateau vertical
                {    
                                if(tjoueur[l][c1]==1)
                                {
                                        count=count+1;
                                        if(count==2) // si il y a 2 "1" sur une colonne, alors : BOUM
                                        {
                                                System.out.println("\n|||||||||RESULTAT||||||||||");    
                                                System.out.println("\n---- Destroyer à 2 Cases coulé !! ----\n");                                            
                                        }
                                }
                }
                        // FIN DE LA VERIFICATION
                }
                // SI PAS TOUCHE
                else
                {
                        System.out.println("\n|||||||||RESULTAT||||||||||");  
                        System.out.println("\n----Plouf ! Rien en vue captain !\n");  
                }
               
        }
        //////////////// FONCTION DE VERIFICATION DE FIN ////////////////
       
        static int fin(int[][] tjoueur) {
               
                int somme=0;
               
                for(int i = 0; i<5; i++)
        {    
          for(int j = 0; j<10; j++)
          {              
            somme=somme+tjoueur[i][j];
          }  
        }                      
                return(somme);
        }      
        ///////////////// FONCTION POUR EMPECHER LA POSE DE BATEAUX TROP PROCHES //////////////////
        static boolean test(int[][] tableau)
        {
        boolean test = false;
        int count=0;
       
        for(int i = 0; i<5; i++)
    {          
       
                for(int c=0; c<10; c++) // horizontal
        {                              
                        if(tableau[i][c]==1)
                        {                                              
                                count=count+1;                                 
                                if(count>3)
                                {                                      
                                        test=true;     
                                }
                               
                        }
                        else{
                                count=0;
                        }
        }
    }
                count=0;
        for(int c = 0; c<9; c++)
        {
                for(int l=0; l<5; l++) // vertical
        {    
                        if(tableau[l][c]==1)
                        {
                                count=count+1;
                                if(count>2)
                                {
                                        test=true;
                                }
                        }
                        else{
                                count=0;
                        }
        }
        }
                return(test);
        }
        //////////////////// FIN DES PROCEDURES et FONCTIONS//////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////////
       
        // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
         
       
       
        ////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////PROGRAMME PRINCIPAL//////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////////////////////////////
       
               
        public static void main(String[] args)
        {
                // TODO Auto-generated method stub
                @SuppressWarnings("resource")
                Scanner saisie = new Scanner(System.in);
               
                int[][] tableau=new int[5][10]; // tableau pour le plateau - à ne pas afficher
                int[][] tjoueur=new int[5][10]; // tableau vu par le joueur - à afficher
                int[][] tanti=new int[5][10]; // tableau pour recap les coups tirés. -eviter aussi de tirer au même endroit.
                //------Variables déclarées-----------
                int ligne;
                int colonne;
                int compteur=1;
                //posons nos bateaux ! 
               
                int bl=(int)( Math.random()*4);
                int bc=(int)( Math.random()*7);                        
                int bll=(int)( Math.random()*4);
                int bcc=(int)( Math.random()*7);
               
                bateau(tableau,bl,bc,"H");               
                bateau(tableau,bll,bcc,"V");
               
                // on a besoin de savoir avec déja 2 bateaux posés.
                       
                while(test(tableau)!=false || fin(tableau)<5) // si test=true, alors les bateaux sont alignés,
                {
                        if(test(tableau)!=false || fin(tableau)<5) // et si fin(tableau)<5, la somme du tableau est inférieure à 5, donc ils sont confondus.
                        {
                                tableau=new int[5][10]; // on reset le tableau, pour eviter l'ajout de bateaux
                               
                        }
                         bl=(int)( Math.random()*4); // on regénère tout.
                         bc=(int)( Math.random()*7);           
                         bll=(int)( Math.random()*4);
                         bcc=(int)( Math.random()*7);                  
                         
                         bateau(tableau,bl,bc,"H");              // on repose les bateaux
                         bateau(tableau,bll,bcc,"V");
                }
               
                               
                // affichons la situation initiale (tableau sans bateau) :     
                System.out.println("|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|\n||||||| TABLEAU DE BORD |||||||\n_______________________________\n\n  0123456789\n  ..........");
                show(tjoueur);
               
                /////////////////////////////////////TRAITEMENT//////////////////////////////////
                /////////////////////////////////////PRINCIPAL///////////////////////////////////
               
                while(fin(tjoueur)!=5)
                {
                       
                       
                        do{
                               
                                System.out.println("\n////////////// TIR n°"+compteur+" : Préparation \\\\\\\\\\\\");  
                               
                                //////////////
                                do{
                                        System.out.println("Saisissez la position verticale de votre tir (de 0 à 4 compris):");  
                                        ligne = saisie.nextInt();
                                }while(ligne<0 || ligne>4); // evitons que l'on tire hors du tableau ...
                       
                                ////
                               
                                do{
                                        System.out.println("Saisissez la position horizontale de votre tir (de 0 à 9 compris):");  
                                        colonne = saisie.nextInt();                    
                                }while(colonne>9 || colonne<0); // evitons de sortir du tableau ...
                       
                                //////////////
                               
                               
                                if(tanti[ligne][colonne]==1) // Evitons de tirer au même endroit, l'archarnement ne sert à rien :D
                                {
                                        System.out.println("Vous avez déjà tiré à cette position");
                                        if(tjoueur[ligne][colonne]==1) // Histoire de préciser si cette case était un bateau touchée
                                        {
                                                System.out.println("De plus vous y aviez touché un navire ennemi, Recommencez :");
                                        }
                                        else{
                                                System.out.println("Recommencez avec une nouvelle position à attaquer :");
                                        }
                                }
                       
                        }while(tjoueur[ligne][colonne]==1);   // pour eviter de tirer sur un bateau déja tiré
                        tanti[ligne][colonne]=1;
                        compteur=compteur+1;                                             //comptons le nombre de bombes
                        tir(tableau,tjoueur,ligne,colonne);     //tirons !
                        System.out.println("________________________________\n||||||| TABLEAU DE BORD  |||||||\n¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\n\n  0123456789\n  ..........");
                        show(tjoueur);                                                     //Affichons le resultat !           
                        System.out.println("\n/////Récapitulatif des tirs précédents : \n");
                        System.out.println("/X/X/X/X/X/X");
                        show(tanti);
                        System.out.println("/X/X/X/X/X/X");                    
                }              
               
               
                ////////////////////////////////////////////////////////////////////////////////
                ////////////////////////////////////FIN DU TRAITEMENT PRINCIPAL/////////////////
               
               
                    //////////////////////  BLABLA de fin /////////////////////////
                System.out.println("\n\n|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|");  
               
                System.out.println("////////////// Bravo CAPITAINE, vous avez éradiquée les forces navales ennemies \\\\\\\\\\\\");  
               
                // Histoire de s'amuser, des messages persos en fonction du nombre de missiles envoyés:
                // ( oui des missiles, c'est une bataille moderne ! :D )
                if(compteur<10)
                {
                        System.out.println("\n////////////// Grâce à vos talents de stratège, seulement "+(compteur-1)+" missiles ont suffit! \\\\\\\\\\\\\\");
                        System.out.println("////////////// Notre Nation vous est reconnaissante ! Vous êtes un héros \\\\\\\\\\\\\\");
                        // Si on y parvient en moins de 10 coups, c'est du talent.
                }
                else{
                       
                if(compteur<25 &amp;&amp; compteur>10)
                {
                        System.out.println("////////////// Il nous aura fallut du temps, et "+(compteur-1)+" missiles, mais vous y êtes parvenu ! \\\\\\\\\\\\\\");
                       
                }
                else{
                        System.out.println("////////////// Capitaine, Grace à "+(compteur-1)+" missiles, nous sommes victorieux ! \\\\\\\\\\\\\\");
                        System.out.println("////////////// Mais c'est un lourd cout pour notre nation, améliorez vous ! \\\\\\\\\\\\"+"\n|____________________________________________________________________________________| ");
                }
                System.out.println("////////////// AU REVOIR CAPITAINE !!");
                }
                ///// Enfin fini ! Merci pour ce Challenge super intéressant ! --la programmation, c'est mon truc :D --
        }

}

 

YEAH
Il n'est plus caché, car je pense que le suspens n'est plus necessaire

[askolein]

Suis je le last Man Standing?

[Valentin]

J'ai testé ton code ! je le trouve bien sympa ! mais comme je suis mauvais à la bataille navale...

Sinon je l'ai fait en partie mais j'ai pas encore fini ^^

[sc]

Bravo Beau travail.
Il reste désormais à améliorer un peu ta procédure bateau (les deux if à la suite ne sont pas très élégant)
et lui greffer une interface graphique (nous le verrons bientôt : avec le windowbuilder)

[askolein]

Merci

C'est vrai que l'on peux améliorer la pose des bateaux !


Et pour l'interface graphique, j'y ai pensé, j'ai regardé un peu sur internet, mais il nous manque pas mal de connaissance
C'est vrai qu'avec des fenêtres ça peux être vraiment bien.