Implementation des colonnes dans la lecture des fichiers + Ordonnaceur + calcul Colonnes + Lsitenenr VueController

src/VueControleur/VueControleurGyromite.java

@@ -54,6 +54,8 @@ public class VueControleurGyromite extends JFrame implements Observer {
                 case KeyEvent.VK_RIGHT : Controle4Directions.getInstance().setDirectionCourante(Direction.droite); break;
                 case KeyEvent.VK_DOWN : Controle4Directions.getInstance().setDirectionCourante(Direction.bas); break;
                 case KeyEvent.VK_UP : Controle4Directions.getInstance().setDirectionCourante(Direction.haut); break;
+                case KeyEvent.VK_NUMPAD4: modele.calculs.Colonne.getInstance().setDirectionColonne(Direction.action); break;
+                case KeyEvent.VK_NUMPAD1: modele.calculs.Colonne.getInstance().setDirectionColonne(Direction.action); break;
             }
         }
     };

src/modele/calculs/Colonne.java

@@ -1,9 +1,41 @@
 package modele.calculs;
 
+import modele.donnees.ElementDynamique;
+
 /**
  * A la reception d'une commande, toutes les cases (EntitesDynamiques) des colonnes se déplacent dans la direction définie
  * (vérifier "collisions" avec le héros)
  */
 public class Colonne extends RealisateurDeDeplacement {
-    protected boolean realiserDeplacement() { return false; } // TODO
+
+    private static Direction directionColonne = null;
+
+    private static Colonne c3d;
+
+    public static Colonne getInstance() {
+        if (c3d == null) {
+            c3d = new Colonne();
+        }
+        return c3d;
+    }
+
+    public static void setDirectionColonne(Direction directionColonne) {
+        Colonne.directionColonne = directionColonne;
+    }
+
+    protected boolean realiserDeplacement() {
+        boolean ret = false;
+        for(ElementDynamique e : lstEntitesDynamiques) {
+            if(directionColonne != null && e.avancerDirectionChoisie(((modele.donnees.GroupeColonne) e).getEtat() == 0 ? Direction.haut : Direction.bas)) {
+                ret = true;
+                ((modele.donnees.GroupeColonne) e).prochainEtat();
+            }
+        }
+        return ret;
+    }
+
+
+    public static void resetDirection() {
+        directionColonne = null;
+    }
 }

src/modele/calculs/IO/LecteurFichier.java

@@ -8,6 +8,7 @@ import modele.donnees.*;
 
 import java.awt.*;
 import java.io.*;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Scanner;
 
@@ -20,6 +21,9 @@ public class LecteurFichier {
         Gravite r_g = new Gravite();
         modele.calculs.IA r_ia = new modele.calculs.IA();
         Controle4Directions r_c = Controle4Directions.getInstance();
+        modele.calculs.Colonne r_col = new modele.calculs.Colonne();
+
+        HashMap<Integer, GroupeColonne> colonnes = new HashMap<>();
 
         try {
             File fileMap = new File(path);
@@ -51,6 +55,19 @@ public class LecteurFichier {
                         r_i.addEntiteDynamique(b);
                         _jeu.addEntite(b, x, y);
                         break;
+                    case 'B':
+                        Colonne c = new Colonne(_jeu);
+                        _jeu.addEntite(c, x, y);
+
+                        if (colonnes.containsKey(x))
+                            colonnes.get(x).add(c);
+                        else {
+                            GroupeColonne cols = new GroupeColonne();
+                            colonnes.put(x, cols);
+                            cols.add(c);
+                            r_col.addEntiteDynamique(cols);
+                        }
+                        break;
                     case '\n':
                         y++;
                         x = -1;
@@ -68,6 +85,7 @@ public class LecteurFichier {
         _jeu.getOrdonnanceur().add(r_c);
         _jeu.getOrdonnanceur().add(r_ia);
         _jeu.getOrdonnanceur().add(r_i);
+        _jeu.getOrdonnanceur().add(r_col);
 
         return map;
     }

src/modele/calculs/Jeu.java

@@ -11,9 +11,11 @@ import modele.calculs.Gravite;
 import modele.calculs.IO.LecteurFichier;
 import modele.calculs.Ordonnanceur;
 import modele.donnees.*;
+import modele.donnees.Colonne;
 import modele.donnees.Menu;
 
 import java.awt.*;
+import java.util.ArrayList;
 import java.util.HashMap;
 
 /** Actuellement, cette classe gère les postions
@@ -92,7 +94,7 @@ public class Jeu {
             map.put((ElementDynamique) e, new Point(x, y));
         mapInit.put(e, new Point(x, y));
 
-        if(e instanceof Heros) hector = (Heros) e;
+        if(e instanceof Heros && hector == null) hector = (Heros) e;
     }
     
     /** Permet par exemple a une entité  de percevoir sont environnement proche et de définir sa stratégie de déplacement
@@ -123,33 +125,40 @@ public class Jeu {
         Point pCible = pCourant;
 
 
-        if(d != null)
+        if(d != null) {
             pCible = calculerPointCible(pCourant, d);
-        
+        }
-        if (contenuDansGrille(pCible) && objetALaPosition(pCible) == null && e instanceof Entite) { // a adapter (collisions murs, etc.)
+        if (e instanceof Colonne) { // Si c'est un colonne
-            // compter le déplacement : 1 deplacement horizontal et vertical max par pas de temps par entité
+            if(deplacerColonne((Colonne) e, pCourant, d))
+                retour = true;
+        } else if (contenuDansGrille(pCible) && e instanceof Entite) { // a adapter (collisions murs, etc.)
             Entite ent = (Entite) e;
+            if(objetALaPosition(pCible) == null) {
+                // compter le déplacement : 1 deplacement horizontal et vertical max par pas de temps par entité
 
-            switch (d) {
+                switch (d) {
-                case bas:
+                    case bas:
-                case haut:
+                    case haut:
-                    if (cmptDeplV.get(ent) == null) {
+                        if (cmptDeplV.get(ent) == null) {
-                        cmptDeplV.put(ent, 1);
+                            cmptDeplV.put(ent, 1);
 
-                        retour = true;
+                            retour = true;
-                    }
+                        }
-                    break;
+                        break;
-                case gauche:
+                    case gauche:
-                case droite:
+                    case droite:
-                    if (cmptDeplH.get(ent) == null) {
+                        if (cmptDeplH.get(ent) == null) {
-                        cmptDeplH.put(ent, 1);
+                            cmptDeplH.put(ent, 1);
-                        retour = true;
+                            retour = true;
 
-                    }
+                        }
-                    break;
+                        break;
-            }
+                }
-            if (retour) {
+                if (retour) {
-                deplacerEntite(pCourant, pCible, ent);
+                    deplacerEntite(pCourant, pCible, ent);
+                }
+            } else if((d == Direction.haut || d == Direction.bas) && objetALaPosition(pCible) instanceof Decor) {
+                killPlayer(ent);
             }
         } else if (e instanceof modele.donnees.Items) {
             retour = true;
@@ -158,6 +167,41 @@ public class Jeu {
 
         return retour;
     }
+
+    private void killPlayer(Entite e) {
+        System.out.println("Techniquement le joueur est mort");
+    }
+
+    private boolean deplacerColonne(Colonne c, Point pCible, Direction d) {
+        ArrayList<ElementDynamique> aDeplacer = new ArrayList<ElementDynamique>();
+        boolean deplctPossible = true;
+
+        for(int i = 0; i < 2; i++) {
+            pCible = calculerPointCible(pCible, d);
+            ElementPhysique ep = objetALaPosition(pCible);
+            if (ep instanceof Decor) {
+                deplctPossible = false;
+                break;
+            } else if (ep instanceof ElementDynamique && ep.peutEtreEcrase())
+                aDeplacer.add((ElementDynamique) ep);
+            else if (ep instanceof Colonne) {
+                break;
+            }
+        }
+
+        if(deplctPossible) {
+            for (ElementDynamique eD : aDeplacer) {
+                for(int i = 0; i < 2; i++) {
+                    eD.avancerDirectionChoisie(d);
+                    cmptDeplV.put((ElementPhysique) eD, null);
+                }
+            }
+
+            deplacerEntite(map.get(c), pCible, (Entite) c);
+        }
+
+        return deplctPossible;
+    }
     
     
     private Point calculerPointCible(Point pCourant, Direction d) {
@@ -234,13 +278,13 @@ public class Jeu {
         Point dest = map.get(cible);
         return orig.distance(dest);
     }
+
     public Ordonnanceur getOrdonnanceur() {
         return ordonnanceur;
     }
 
     // PARTIE MANIPULATION MENU
-    public synchronized boolean updateMenu(Direction d) {
+    public boolean updateMenu(Direction d) {
-        System.out.println("Mis a jour du menu");
         switch (getState()) {
             case 0:
                 if (d == Direction.action)

src/modele/calculs/Ordonnanceur.java

@@ -54,6 +54,7 @@ public class Ordonnanceur extends Observable implements Runnable {
                     }
 
                     Controle4Directions.getInstance().resetDirection();
+                    Colonne.resetDirection();
                     break;
             }