Ajout de channel

src/Main.java

@@ -1,24 +1,24 @@
 import connexion.Channel;
+import connexion.Reseau;
 import environnements.*;
 import game.Terminal;
 import personnages.*;
 import types.Item;
 
 public class Main {
-    public static void main(String[] args) {
+    public static void main(String[] args) throws InterruptedException {
         Personnage.n = 2;
 
         Map map = new Map(20, 20);
 
         Personnage[] personnages = new Personnage[] {
             new Player(new int[] {0, 0}, "Philippe Etchebest"),
-            new Channel(map, "23", "24")
         };
 
         
         // map.addObjects(Item.FRAISE, 0, 0);
         // map.addObjectsRandomize(new Item[] {Item.FRAISE}, 1);
 
-        new Terminal(map, personnages).run("24");
+        new Terminal(map, personnages).run(new String(), new String());
     }
 }

src/connexion/Channel.java

@@ -10,33 +10,22 @@ import personnages.Personnage;
 public class Channel extends Personnage {
     private Reseau reseau;
     private static Reseau adversaire;
+    private String channel;
 
     private Map map;
 
     public Channel(Map map, String channel, String autreChannel) {
-        super(new int [] {map.getGrid()[0].length, map.getGrid().length});
+        super(new int [] {map.getGrid()[0].length - 1, map.getGrid().length - 1});
 
         this.map = map;
         this.name = autreChannel;
 
+        this.channel = channel;
+
         reseau = new Reseau(channel);
         adversaire = new Reseau(autreChannel);
     }
 
-
-    public Grid[][] getInverseGridChannel() {
-        Grid[][] grid = map.getInverseGrid();
-        Grid[][] inverseGrid = new Grid[grid.length][grid[0].length];
-    
-        for (int j = grid.length - 1; j >= 0; j--) {
-            for (int i = grid[j].length - 1; i >= 0; i--) {
-                inverseGrid[j][i] = grid[j][grid[j].length - 1 - i];
-            }
-        }
-    
-        return inverseGrid;
-    }
-
     /**
      * Méthode permettant l'envoi de message, grâce à celle de Réseau
      * @param String contenant la direction voulue
@@ -59,27 +48,30 @@ public class Channel extends Personnage {
      * @return Mouvement
      */
     public Mouvement conversionMouvement(String s){
-        if (s.equals("U") || s.equals("u")){
+        if (s != null) {
-            return Mouvement.HAUT;
+            if (s.equals("U") || s.equals("u")){
-        }else if (s.equals("D") || s.equals("d")){
+                return Mouvement.HAUT;
-            return Mouvement.BAS;
+            }else if (s.equals("D") || s.equals("d")){
-        }else if (s.equals("L") || s.equals("l")){
+                return Mouvement.BAS;
-            return Mouvement.GAUCHE;
+            }else if (s.equals("L") || s.equals("l")){
-        }else if (s.equals("R") || s.equals("r")){
+                return Mouvement.GAUCHE;
-            return Mouvement.DROITE;
+            }else if (s.equals("R") || s.equals("r")){
+                return Mouvement.DROITE;
+            }
         }
+
         return null;
     } 
 
     private static String conversionString(Mouvement mouvement){
         if (mouvement == Mouvement.HAUT) {
-            return "U";
-        } else if (mouvement == Mouvement.BAS) {
             return "D";
+        } else if (mouvement == Mouvement.BAS) {
+            return "U";
         } else if (mouvement == Mouvement.GAUCHE) {
-            return "L";
-        } else if (mouvement == Mouvement.DROITE) {
             return "R";
+        } else if (mouvement == Mouvement.DROITE) {
+            return "L";
         }
         return null;
     }
@@ -93,10 +85,13 @@ public class Channel extends Personnage {
      */
     @Override
     public boolean round(Map map, String channel){
-        int[] coordinate=this.getHeadCoordinate();
+        Mouvement mouvement;
 
-        this.moveSnake(conversionMouvement(recupererMessage()));
+        System.out.println("Attente de l'autre joueur.");
-        
+        while ((mouvement = conversionMouvement(recupererMessage())) == null) reseau.reconnexion(this.channel);
+        this.moveSnake(mouvement);
+
+        int[] coordinate=this.getHeadCoordinate();
         if (map.isGameOver(coordinate) || this.applyEffects(map.getEffect(coordinate))){
             return true;
         }

src/connexion/Reseau.java

@@ -42,6 +42,7 @@ import static java.util.Arrays.copyOfRange;
     */
     public Reseau(String channel) {
         this.CHANNEL = channel;
+
         this.wordArrayList = new ArrayList<String>();
         this.newerWordArrayList = new ArrayList<String>();
 
@@ -112,10 +113,17 @@ import static java.util.Arrays.copyOfRange;
      * @return il renvoie le {@link ArrayList} de la liste
      */
     public ArrayList<String> searchContentSorted() {
-        ArrayList<String> localNewerArrayList = this.searchContent();
+        ArrayList<String> notsorted;
-        if (this.getArrayContent().isEmpty()) this.addContentToContent(localNewerArrayList);
+
-        else this.searchDuplicates(localNewerArrayList);
+        if ((notsorted = this.searchContent()) != null) {
-        return this.wordArrayList;
+            ArrayList<String> localNewerArrayList = new ArrayList<>(notsorted);
+
+            if (this.getArrayContent().isEmpty()) this.addContentTonewerArrayList(localNewerArrayList);
+            else this.searchDuplicates(localNewerArrayList);
+            return this.wordArrayList;
+        }
+
+        return null;
     }
 
     /**
@@ -129,7 +137,7 @@ import static java.util.Arrays.copyOfRange;
     */
     public ArrayList<String> searchArrayListNotSorted() {
         ArrayList<String> localNewerArrayList = this.searchContent();
-        this.addContentToContent(localNewerArrayList);
+        this.addContentTonewerArrayList(localNewerArrayList);
         return this.wordArrayList;
     }
 
@@ -193,7 +201,7 @@ import static java.util.Arrays.copyOfRange;
         }
     }
 
-    private void addContentToContent(ArrayList<String> localArrayList) {
+    private void addContentTonewerArrayList(ArrayList<String> localArrayList) {
         int arrayListLength = this.getArrayContent().size();
 
         this.newerWordArrayList.clear();

src/game/Terminal.java

@@ -1,33 +1,71 @@
 package game;
 
+import connexion.Channel;
 import display.Display;
 import environnements.Map;
 import personnages.Personnage;
 
+
+/**
+ * cette classe permet en tout de tout lancer dans le jeu,
+ * un tournoi local ou un tournoi multijoueur en ligne grâce
+ * au site donnée par l'université.
+ * 
+ * <p> Pour lancer en local, vous devez juste lancer le programme 
+ * en faisant :
+ * 
+ * <pre><code> 
+ * new Terminal(new Map(...), new Personnage[] {...}).run();
+ * </code></pre>
+ * 
+ * Pour lancer en Multijoueur, vous devez lancer en faisant :
+ * 
+ * <pre><code> 
+ * new Terminal(new Map(...), new Personnage[] {...}).run("channeluser", "channeladversaire"); 
+ * </code></pre>
+ */
 public class Terminal {
     Map map;
     Personnage[] personnages;
 
-    private void placePersonnages() {
+    private void placePersonnages(Personnage[] personnages) {
         for(Personnage personnage : personnages) {
             map.placePersonnages(personnage);
         }
     }
 
+    /** 
+     * <p> Pour lancer en local, vous devez juste lancer le programme 
+     * en faisant :
+     * 
+     * <pre><code> 
+     * new Terminal(new Map(...), new Personnage[] {...}).run();
+     * </code></pre>
+     * 
+     * Pour lancer en Multijoueur, vous devez lancer en faisant :
+     * 
+     * <pre><code> 
+     * new Terminal(new Map(...), new Personnage[] {...}).run("channeluser", "channeladversaire"); 
+     * </code></pre>
+     */
     public Terminal(Map map, Personnage[] personnages) {
         this.personnages = personnages;
         this.map = map;
     }
 
-    public void run(String channel) {
+    public void run(String channel, String channelAdversaire) {
         int i = 0;
+        Personnage[] personnageChannel = new Personnage[] {
+            personnages[0], 
+            new Channel(map, channel, channelAdversaire)
+        };
 
         while(true) {
-            for(Personnage personnage : personnages) {
+            for(Personnage personnage : personnageChannel) {
                 Display.clearTerminal();
 
                 map.placeObjects();
-                placePersonnages();
+                placePersonnages(personnageChannel);
 
                 Display.printInformation(i++, personnage);
                 Display.printMap(map.addEdges());
@@ -41,4 +79,27 @@ public class Terminal {
             }
         }
     }
+
+    public void run() {
+        int i = 0;
+
+        while(true) {
+            for(Personnage personnage : personnages) {
+                Display.clearTerminal();
+
+                map.placeObjects();
+                placePersonnages(personnages);
+
+                Display.printInformation(i++, personnage);
+                Display.printMap(map.addEdges());
+                
+                if(personnage.round(map, null)) {
+                    Display.clearTerminal();
+                    System.out.println(personnage.getName() + " à perdu!");
+                    return;
+                }
+                map.clearMap();
+            }
+        }
+    }
 }