Modif nom package

src/modele/calculs/Colonne.java

@@ -0,0 +1,9 @@
+package modele.deplacements;
+
+/**
+ * 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
+}

src/modele/calculs/Controle4Directions.java

@@ -0,0 +1,55 @@
+package modele.deplacements;
+
+import modele.donnees.Entite;
+import modele.donnees.EntiteDynamique;
+
+/**
+ * Controle4Directions permet d'appliquer une direction (connexion avec le clavier) à un ensemble d'entités dynamiques
+ */
+public class Controle4Directions extends RealisateurDeDeplacement {
+    private Direction directionCourante;
+    // Design pattern singleton
+    private static Controle4Directions c3d;
+
+    public static Controle4Directions getInstance() {
+        if (c3d == null) {
+            c3d = new Controle4Directions();
+        }
+        return c3d;
+    }
+
+    public void setDirectionCourante(Direction _directionCourante) {
+        directionCourante = _directionCourante;
+    }
+
+    public boolean realiserDeplacement() {
+        boolean ret = false;
+        for (EntiteDynamique e : lstEntitesDynamiques) {
+            if (directionCourante != null)
+                switch (directionCourante) {
+                    case gauche:
+                    case droite:
+                        if (e.avancerDirectionChoisie(directionCourante))
+                            ret = true;
+                        break;
+
+                    case haut:
+                        // on ne peut pas sauter sans prendre appui
+                        // (attention, test d'appui réalisé à partir de la position courante, si la gravité à été appliquée, il ne s'agit pas de la position affichée, amélioration possible)
+                        Entite eBas = e.regarderDansLaDirection(Direction.bas);
+                        if (eBas != null && eBas.peutServirDeSupport()) {
+                            if (e.avancerDirectionChoisie(Direction.haut))
+                                ret = true;
+                        }
+                        break;
+                }
+        }
+
+        return ret;
+
+    }
+
+    public void resetDirection() {
+        directionCourante = null;
+    }
+}

src/modele/calculs/Direction.java

@@ -0,0 +1,14 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package modele.deplacements;
+
+/** Type énuméré des directions : les directions correspondent à un ensemble borné de valeurs, connu à l'avance
+ *
+ *
+ */
+public enum Direction {
+    haut, bas, gauche, droite
+}

src/modele/calculs/Gravite.java

@@ -0,0 +1,21 @@
+package modele.deplacements;
+
+import modele.donnees.Entite;
+import modele.donnees.EntiteDynamique;
+
+public class Gravite extends RealisateurDeDeplacement {
+    @Override
+    public boolean realiserDeplacement() {
+        boolean ret = false;
+
+        for (EntiteDynamique e : lstEntitesDynamiques) {
+            Entite eBas = e.regarderDansLaDirection(Direction.bas);
+            if (eBas == null || (eBas != null && !eBas.peutServirDeSupport())) {
+                if (e.avancerDirectionChoisie(Direction.bas))
+                    ret = true;
+            }
+        }
+
+        return ret;
+    }
+}

src/modele/calculs/IA.java

@@ -0,0 +1,5 @@
+package modele.deplacements;
+
+public class IA extends RealisateurDeDeplacement {
+    protected boolean realiserDeplacement() { return false; } // TODO
+}

src/modele/calculs/Jeu.java

@@ -0,0 +1,175 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package modele.donnees;
+
+import modele.deplacements.Controle4Directions;
+import modele.deplacements.Direction;
+import modele.deplacements.Gravite;
+import modele.deplacements.Ordonnanceur;
+
+import java.awt.Point;
+import java.util.HashMap;
+
+/** Actuellement, cette classe gère les postions
+ * (ajouter conditions de victoire, chargement du plateau, etc.)
+ */
+public class Jeu {
+
+    public static final int SIZE_X = 20;
+    public static final int SIZE_Y = 10;
+
+    // compteur de déplacements horizontal et vertical (1 max par défaut, à chaque pas de temps)
+    private HashMap<Entite, Integer> cmptDeplH = new HashMap<Entite, Integer>();
+    private HashMap<Entite, Integer> cmptDeplV = new HashMap<Entite, Integer>();
+
+    private Heros hector;
+
+    private HashMap<ElementPhysique, Point> map = new  HashMap<ElementPhysique, Point>(); // permet de récupérer la position d'une entité à partir de sa référence
+    private ElementPhysique[][] grilleEntites = new ElementPhysique[SIZE_X][SIZE_Y]; // permet de récupérer une entité à partir de ses coordonnées
+
+    private Ordonnanceur ordonnanceur = new Ordonnanceur(this);
+
+    public Jeu() {
+        initialisationDesEntites();
+    }
+
+    public void resetCmptDepl() {
+        cmptDeplH.clear();
+        cmptDeplV.clear();
+    }
+
+    public void start(long _pause) {
+        ordonnanceur.start(_pause);
+    }
+    
+    public Entite[][] getGrille() {
+        return grilleEntites;
+    }
+    
+    public Heros getHector() {
+        return hector;
+    }
+    
+    private void initialisationDesEntites() {
+        hector = new Heros(this);
+        addEntite(hector, 2, 1);
+
+        Gravite g = new Gravite();
+        g.addEntiteDynamique(hector);
+        ordonnanceur.add(g);
+
+        Controle4Directions.getInstance().addEntiteDynamique(hector);
+        ordonnanceur.add(Controle4Directions.getInstance());
+
+        // murs extérieurs horizontaux
+        for (int x = 0; x < 20; x++) {
+            addEntite(new Mur(this), x, 0);
+            addEntite(new Mur(this), x, 9);
+        }
+
+        // murs extérieurs verticaux
+        for (int y = 1; y < 9; y++) {
+            addEntite(new Mur(this), 0, y);
+            addEntite(new Mur(this), 19, y);
+        }
+
+        addEntite(new Mur(this), 2, 6);
+        addEntite(new Mur(this), 3, 6);
+    }
+
+    private void addEntite(ElementPhysique e, int x, int y) {
+        grilleEntites[x][y] = e;
+        map.put(e, new Point(x, y));
+    }
+    
+    /** Permet par exemple a une entité  de percevoir sont environnement proche et de définir sa stratégie de déplacement
+     *
+     */
+    public Entite regarderDansLaDirection(Entite e, Direction d) {
+        Point positionEntite = map.get(e);
+        return objetALaPosition(calculerPointCible(positionEntite, d));
+    }
+    
+    /** Si le déplacement de l'entité est autorisé (pas de mur ou autre entité), il est réalisé
+     * Sinon, rien n'est fait.
+     */
+    public boolean deplacerEntite(Entite e, Direction d) {
+        boolean retour = false;
+        
+        Point pCourant = map.get(e);
+        
+        Point pCible = calculerPointCible(pCourant, d);
+        
+        if (contenuDansGrille(pCible) && objetALaPosition(pCible) == null) { // a adapter (collisions murs, etc.)
+            // compter le déplacement : 1 deplacement horizontal et vertical max par pas de temps par entité
+            switch (d) {
+                case bas:
+                case haut:
+                    if (cmptDeplV.get(e) == null) {
+                        cmptDeplV.put(e, 1);
+
+                        retour = true;
+                    }
+                    break;
+                case gauche:
+                case droite:
+                    if (cmptDeplH.get(e) == null) {
+                        cmptDeplH.put(e, 1);
+                        retour = true;
+
+                    }
+                    break;
+            }
+        }
+
+        if (retour) {
+            deplacerEntite(pCourant, pCible, e);
+        }
+
+        return retour;
+    }
+    
+    
+    private Point calculerPointCible(Point pCourant, Direction d) {
+        Point pCible = null;
+        
+        switch(d) {
+            case haut: pCible = new Point(pCourant.x, pCourant.y - 1); break;
+            case bas : pCible = new Point(pCourant.x, pCourant.y + 1); break;
+            case gauche : pCible = new Point(pCourant.x - 1, pCourant.y); break;
+            case droite : pCible = new Point(pCourant.x + 1, pCourant.y); break;     
+            
+        }
+        
+        return pCible;
+    }
+    
+    private void deplacerEntite(Point pCourant, Point pCible, ElementPhysique e) {
+        grilleEntites[pCourant.x][pCourant.y] = null;
+        grilleEntites[pCible.x][pCible.y] = e;
+        map.put(e, pCible);
+    }
+    
+    /** Indique si p est contenu dans la grille
+     */
+    private boolean contenuDansGrille(Point p) {
+        return p.x >= 0 && p.x < SIZE_X && p.y >= 0 && p.y < SIZE_Y;
+    }
+    
+    private ElementPhysique objetALaPosition(Point p) {
+        Entite retour = null;
+        
+        if (contenuDansGrille(p)) {
+            retour = grilleEntites[p.x][p.y];
+        }
+        
+        return retour;
+    }
+
+    public Ordonnanceur getOrdonnanceur() {
+        return ordonnanceur;
+    }
+}

src/modele/calculs/Ordonnanceur.java

@@ -0,0 +1,53 @@
+package modele.deplacements;
+
+import modele.donnees.Jeu;
+
+import java.util.ArrayList;
+import java.util.Observable;
+
+import static java.lang.Thread.*;
+
+public class Ordonnanceur extends Observable implements Runnable {
+    private Jeu jeu;
+    private ArrayList<RealisateurDeDeplacement> lstDeplacements = new ArrayList<RealisateurDeDeplacement>();
+    private long pause;
+    public void add(RealisateurDeDeplacement deplacement) {
+        lstDeplacements.add(deplacement);
+    }
+
+    public Ordonnanceur(Jeu _jeu) {
+        jeu = _jeu;
+    }
+
+    public void start(long _pause) {
+        pause = _pause;
+        new Thread(this).start();
+    }
+
+    @Override
+    public void run() {
+        boolean update = false;
+
+        while(true) {
+            jeu.resetCmptDepl();
+            for (RealisateurDeDeplacement d : lstDeplacements) {
+                if (d.realiserDeplacement())
+                    update = true;
+            }
+
+            Controle4Directions.getInstance().resetDirection();
+
+            if (update) {
+                setChanged();
+                notifyObservers();
+            }
+
+            try {
+                sleep(pause);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+}

src/modele/calculs/RealisateurDeDeplacement.java

@@ -0,0 +1,15 @@
+package modele.deplacements;
+
+import modele.donnees.EntiteDynamique;
+
+import java.util.ArrayList;
+
+/**
+Tous les déplacement sont déclenchés par cette classe (gravité, controle clavier, IA, etc.)
+ */
+public abstract class RealisateurDeDeplacement {
+    protected ArrayList<EntiteDynamique> lstEntitesDynamiques = new ArrayList<EntiteDynamique>();
+    protected abstract boolean realiserDeplacement();
+
+    public void addEntiteDynamique(EntiteDynamique ed) {lstEntitesDynamiques.add(ed);};
+}