Config Azure Cloud

.github/workflows/main_pacmanwebapp.yml

@@ -0,0 +1,53 @@
+# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+
+name: Build and deploy JAR app to Azure Web App - pacmanwebapp
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Java version
+        uses: actions/setup-java@v1
+        with:
+          java-version: '17'
+
+      - name: Build with Maven
+        run: mvn clean install
+
+      - name: Upload artifact for deployment job
+        uses: actions/upload-artifact@v3
+        with:
+          name: java-app
+          path: '${{ github.workspace }}/target/*.jar'
+
+  deploy:
+    runs-on: windows-latest
+    needs: build
+    environment:
+      name: 'Production'
+      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
+
+    steps:
+      - name: Download artifact from build job
+        uses: actions/download-artifact@v3
+        with:
+          name: java-app
+
+      - name: Deploy to Azure Web App
+        id: deploy-to-webapp
+        uses: azure/webapps-deploy@v2
+        with:
+          app-name: 'pacmanwebapp'
+          slot-name: 'Production'
+          package: '*.jar'
+          publish-profile: ${{ secrets.AZUREAPPSERVICE_PUBLISHPROFILE_5A7719FB4BD34FEC986840EF0C861E96 }}

pom.xml

@@ -30,6 +30,10 @@
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
 
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-messaging</artifactId>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-websocket</artifactId>

src/main/java/Classes/Boule.java

@@ -1,10 +1,15 @@
 package Classes;
 
+import java.util.List;
+
 public class Boule {
     private Point position;
+    private boolean superBoule ;
+
+    public Boule(Point position, boolean superBoule ) {
 
-    public Boule(Point position) {
         this.position = position;
+        this.superBoule = superBoule;
     }
 
     public Point getPosition() {
@@ -14,4 +19,12 @@ public Point getPosition() {
     public void setPosition(Point position) {
         this.position = position;
     }
+
+
+    public int getScore() {
+        int points = 25 ;
+        return points;
+    }
+
+
 }

src/main/java/Classes/DirectionWrapper.java

@@ -0,0 +1,36 @@
+package Classes;
+
+public class DirectionWrapper{
+    private String direction;
+
+
+    public DirectionWrapper(String direction){
+        this.direction = direction;
+    }
+    public int getDirection() {
+        return convertStringToInt(direction);
+    }
+
+    public void setDirection(String direction) {
+        this.direction = direction;
+    }
+
+    // Convertit la direction recu en JSON en int
+    public int convertStringToInt(String direction){
+        switch (direction) {
+            case "0":
+                return 0;
+            case "1":
+                return 1;
+            case "2":
+                return 2;
+            case "3":
+                return 3;
+            case "-1":
+                return -1;
+            default:
+                throw new IllegalArgumentException("La direction doit être l'une des valeurs suivantes : -1, 0, 1, 2, 3");
+        }
+    }
+
+}

src/main/java/Classes/Fantome.java

@@ -1,13 +1,168 @@
 package Classes;
 
-public abstract class Fantome extends Personnage {
+import java.util.Random;
+
+public class Fantome extends Personnage {
     private ModeFantome mode;
 
+    private Game game;
+
+    private char caseEcrasee;
+
+
+    public Fantome(Point position, Game game) {
+        super(position);
+        this.game = game;
+    }
+
     public Fantome(Point position, Direction direction, ModeFantome mode) {
         super(position, direction);
         this.mode = mode;
     }
 
+    public void deplacer(char[][] terrain) {
+        Random random = new Random();
+        int direction;
+
+        Point position = getPosition();
+        int positionX = position.getPositionX();
+        int positionY = position.getPositionY();
+        int directionSave = 5;
+        int anciennePositionX = positionX;
+        int anciennePositionY = positionY;
+//        char ancienContenu = this.game.getTerrain()[anciennePositionX][anciennePositionY];
+
+        System.out.println("Postion Fantome "+ position.getPositionX() +" "+position.getPositionY());
+
+//         Choisir une direction aléatoire (0 pour haut, 1 pour droite, 2 pour bas, 3 pour gauche)
+        do {
+
+            direction = random.nextInt(4);
+             directionSave = direction;
+            System.out.println("Direction aléatoirement choisi: "+direction);
+        } while (!peutSeDeplacer(terrain, direction, positionX, positionY));
+
+//            direction = random.nextInt(4);
+//            System.out.println("Direction aléatoirement choisi: "+direction);
+//            if(!peutSeDeplacer(terrain, direction, positionX, positionY)){
+
+//        if (this.game.modeSansMurIsActive()) {
+//            direction = (random.nextBoolean()) ? 0 : 2; // Choisir aléatoirement entre haut (0) et bas (2)
+//        } else {
+//            // Choisir une direction aléatoire (0 pour haut, 1 pour droite, 2 pour bas, 3 pour gauche)
+//            do {
+//                direction = random.nextInt(4);
+//                System.out.println("doWHile et direction: " + direction);
+//            } while (!peutSeDeplacer(terrain, direction, positionX, positionY));
+//        }
+
+        // Déplacer le fantôme dans la direction choisie
+        switch (direction) {
+            case 0:
+                // Déplacer vers le haut
+                System.out.println("Fantome: Déplacement autorisé Vers le haut");
+                position.setPositionX(position.getPositionX() - 1);
+                break;
+            case 1:
+                // Déplacer vers la droite
+                System.out.println("Fantome: Déplacement autorisé vers la droite");
+                position.setPositionY(position.getPositionY() + 1);
+                break;
+            case 2:
+                // Déplacer vers le bas
+                System.out.println("Fantome: Déplacement autorisé vers le bas");
+                position.setPositionX(position.getPositionX() + 1);
+                break;
+            case 3:
+                // Déplacer vers la gauche
+                System.out.println("Fantome: Déplacement autorisé vers la gauche");
+                position.setPositionY(position.getPositionY() - 1);
+                break;
+        }
+
+
+/*
+        char nouveauContenu = terrain[position.getPositionX()][position.getPositionY()];
+        if (estUnBonus(nouveauContenu)) {
+            caseEcrasee = nouveauContenu;
+        } else {
+            caseEcrasee = '.'; // Si la nouvelle position n'est pas un bonus, réinitialisez caseEcrasee
+        }
+*/
+        terrain[anciennePositionX][anciennePositionY] = '.';
+        terrain[position.getPositionX()][position.getPositionY()] = 'F'; // Nouvelle position avec le fantôme
+//        this.game.getTerrain()[anciennePositionX][anciennePositionY] = ancienContenu;   // Restaurer le bonus à l'ancienne position du fantôme
+
+        System.out.println("Postion Fantome après maj "+ position.getPositionX() +" "+ position.getPositionY());
+
+    }
+
+    private boolean peutSeDeplacer(char[][] terrain, int direction, int positionX, int positionY) {
+        // Nouvelles coordonnées après le déplacement
+        int newX = positionX;
+        int newY = positionY;
+
+        switch (direction) {
+            case 0:
+                newX--; // Déplacement vers le haut
+                System.out.println("Fantome Vers le haut");
+                break;
+            case 1:
+                newY++; // Déplacement vers la droite
+                System.out.println("Fantome Vers le droite");
+                break;
+            case 2:
+                newX++; // Déplacement vers le bas
+                System.out.println("Fantome Vers le bas");
+                break;
+            case 3:
+                newY--; // Déplacement vers la gauche
+                System.out.println("Fantome Vers le gauche");
+                break;
+            default:
+                return false; // Direction non valide
+        }
+
+//        // Vérifier les limites de la grille
+//        if (newX < 0 || newX >= this.game.getTerrain().length || newY < 0 || newY >= this.game.getTerrain()[0].length) {
+//            System.out.println("Fantome a atteint la limite de grille " + direction);
+//            System.out.println("Valeur de NewX = "+newX);
+//            System.out.println("TabX valeur = "+terrain[0].length);
+//            System.out.println("Valeur de NewY = "+newY);
+//            System.out.println("TabY valeur = "+terrain.length);
+//
+//            return false; // En dehors de la grille
+//        }
+
+        // Vérifier s'il y a un mur à la nouvelle position
+        if (terrain[newX][newY] == 'M') {
+            System.out.println("Collision Fantome avec un MUR");
+            return false; // Mur présent
+        }
+
+        if (terrain[newX][newY] == 'P') {
+            // Collision avec un fantôme, perdre une vie
+            System.out.println("Collision avec un Pacman");
+            this.game.getPacMan().perdreVies();
+            return true;
+        }
+/*
+        if(estUnBonus(this.game.getTerrain()[newX][newY])){
+            caseEcrasee = this.game.getTerrain()[newX][newY];
+            System.out.println("Case écraser "+ caseEcrasee );
+        }
+*/
+
+        return true; // Déplacement autorisé
+    }
+
+/*
+
+    private boolean estUnBonus(char contenu) {
+        return contenu == 'o' || contenu == 'O' || contenu == 'B' || contenu == 'C' || contenu == 'K';
+    }
+    */
+
     public ModeFantome getMode() {
         return mode;
     }
@@ -32,7 +187,12 @@ public void manger() {
         // Comportement de devenir mangé par Pac-Man
     }
 
-    @Override
+
     public void deplacer() {
     }
+
+    @Override
+    public void mourir() {
+
+    }
 }

src/main/java/Classes/Fruit.java

@@ -1,5 +1,7 @@
 package Classes;
 
+import java.util.List;
+
 public class Fruit {
     private TypeFruit type;
     private Point position;
@@ -24,22 +26,28 @@ public Point getPosition() {
     public void setPosition(Point position) {
         this.position = position;
     }
+    // Méthode pour obtenir l'objet Fruit à une position spécifique dans la liste de fruits
+
+    public int getPointsFruit() {
 
-    public int getScore() {
-        // Implémentez la logique pour obtenir le nombre de points associés à ce fruit
-        // Par exemple, en utilisant une correspondance entre le type de fruit et les points
         int points = 0;
         switch (type) {
             case CERISE:
                 points = 100; // Exemple de points pour une cerise
                 break;
-            case ORANGE:
+            case BANANE:
                 points = 200; // Exemple de points pour une orange
                 break;
-            // Ajoutez d'autres cas pour les différents types de fruits
+
+            case KIWI :
+                points = 300;
+
+                break;
             default:
                 points = 0; // Par défaut, aucun point
         }
         return points;
     }
+
+
 }