feat: 💩 on avance dans jeu

.gitignore

@@ -1 +1,2 @@
 .metadata
+*.class

.vscode/settings.json

@@ -2,4 +2,13 @@
     "files.associations": {
         "*.game": "json"
     },
-}
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/CVS": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true,
+        "**/*.class": true
+    }
+}

enigme.game

@@ -63,8 +63,8 @@
         "lieu_in": "Énigme",
         "lieu_out": "Succès",
         "ouvert": "(true)",
-        "visible": "(Réussite==1)",
+        "visible": "(Réussite)",
-        "obligatoire": "(false)",
+        "obligatoire": "(true)",
         "connaissances_gift": [],
         "objets_gift": [],
         "objets_conso": [],
@@ -79,8 +79,8 @@
         "lieu_in": "Énigme",
         "lieu_out": "Échec",
         "ouvert": "(true)",
-        "visible": "(tentatives==0)",
+        "visible": "(tentatives == 0)",
-        "obligatoire": "(false)",
+        "obligatoire": "(true)",
         "connaissances": [],
         "objets": [],
         "objets_conso": [],
@@ -121,23 +121,22 @@
   "Personnes": [
     {
       "nom": "Sphinx",
-      "visible": "(true)",
+      "visible": "(!Reussite && tentative > 0)",
       "obligatoire": "(true)",
       "interactions": [
         {
           "visible": "(true)",
           "connaissances": [],
           "objets_recus": [],
+          "objets_conso": [],
           "actions": [
             {
               "visible": "(true)",
               "connaissances": [
                 "Réussite"
               ],
-              "objets_gift": [],
+              "objets_recus": [],
-              "objets_conso": [
+              "objets_conso": []
-                "tentative"
-              ]
             },
             {
               "visible": "(true)",

enigme.java/Action.java

@@ -1,20 +1,35 @@
+import java.util.List;
+
 public class Action {
-    Boolean visible;
+    Condition visible;
     List<Connaissance> connaissances;
     List<Objet> objetsRecus;
     List<Objet> objetsConso;
     Condition finInterraction;
+    List<Description> descriptions;
 
     public Action(
-            Boolean visible,
+            Condition visible,
             List<Connaissance> connaissances,
             List<Objet> objetsRecus,
             List<Objet> objetsConso,
-            Condition finInterraction) {
+            Condition finInterraction,
+            List<Description> descriptions) {
         this.visible = visible;
-        this.connaissancesGift = connaissances;
+        this.connaissances = connaissances;
         this.objetsRecus = objetsRecus;
         this.objetsConso = objetsConso;
         this.finInterraction = finInterraction;
+        this.descriptions = descriptions;
+    }
+
+    @Override
+    public String toString() {
+        for (Description d : this.descriptions) {
+            if (d.condition.evaluer()) {
+                return d.toString();
+            }
+        }
+        return "No desc";
     }
 }

enigme.java/Chemin.java

@@ -1,9 +1,11 @@
+import java.util.List;
+
 public class Chemin {
     Lieu lieuIn;
     Lieu lieuOut;
-    Boolean ouvert;
+    Condition ouvert;
-    Boolean visible;
+    Condition visible;
-    Boolean obligatoire;
+    Condition obligatoire;
     List<Connaissance> connaissancesRecus;
     List<Objet> objetsRecus;
     List<Objet> objetsConso;
@@ -12,9 +14,9 @@ public class Chemin {
     public Chemin(
             Lieu lieuIn,
             Lieu lieuOut,
-            Boolean ouvert,
+            Condition ouvert,
-            Boolean visible,
+            Condition visible,
-            Boolean obligatoire,
+            Condition obligatoire,
             List<Connaissance> connaissancesRecus,
             List<Objet> objetsRecus,
             List<Objet> objetsConso,
@@ -30,4 +32,14 @@ public class Chemin {
         this.descriptions = descriptions;
 
     }
+
+    @Override
+    public String toString() {
+        for (Description d : descriptions) {
+            if (d.condition.evaluer()) {
+                return d.toString();
+            }
+        }
+        return "No desc";
+    }
 }

enigme.java/Condition.java

@@ -1,13 +1,16 @@
+import java.util.List;
+import java.util.ArrayList;
+
 public class Condition {
 
-    String condition;
     List<ConditionEt> conditionEts;
 
     public Condition(
-            String condition,
+            ConditionEt... conditionEts) {
-            List<ConditionEt> conditionEts) {
+        this.conditionEts = new ArrayList<>();
-        this.condition = condition;
+        for (ConditionEt c : conditionEts) {
-        this.conditionEts = conditionEts;
+            this.conditionEts.add(c);
+        }
     }
 
     public Boolean evaluer() {

enigme.java/ConditionBoolean.java

@@ -1,7 +1,7 @@
 public class ConditionBoolean implements ConditionTest {
     Boolean bool;
 
-    public ConditionObjet(Boolean bool) {
+    public ConditionBoolean(Boolean bool) {
         this.bool = bool;
     }
 

enigme.java/ConditionEt.java

@@ -1,9 +1,15 @@
+import java.util.List;
+import java.util.ArrayList;
+
 public class ConditionEt {
 
     List<ConditionTest> conditionTests;
 
-    public ConditionEt(ConditionTest[] conditionTests) {
+    public ConditionEt(ConditionTest... conditionTests) {
-        this.conditionTests = conditionTests;
+        this.conditionTests = new ArrayList<>();
+        for (ConditionTest c : conditionTests) {
+            this.conditionTests.add(c);
+        }
     }
 
     public Boolean evaluer() {

enigme.java/Connaissance.java

@@ -1,14 +1,26 @@
+import java.util.List;
+
 public class Connaissance {
     String nom;
     Condition visible;
-    Description description;
+    List<Description> descriptions;
 
-    public Objet(
+    public Connaissance(
             String nom,
             Condition visible,
-            Description description) {
+            List<Description> descriptions) {
         this.nom = nom;
         this.visible = visible;
-        this.description = description;
+        this.descriptions = descriptions;
+    }
+
+    @Override
+    public String toString() {
+        for (Description d : this.descriptions) {
+            if (d.condition.evaluer()) {
+                return this.nom + ": " + d;
+            }
+        }
+        return "No desc";
     }
 }

enigme.java/Explorateur.java

@@ -1,4 +1,4 @@
-import java.util.ArrayList;
+import java.util.List;
 
 public class Explorateur {
     int taille;
@@ -13,4 +13,17 @@ public class Explorateur {
         this.connaissances = connaissances;
         this.objets = objets;
     }
+
+    @Override
+    public String toString() {
+        String txt = new String();
+        for (Objet c : this.objets) {
+            txt.concat(c.toString());
+        }
+        for (Connaissance c : this.connaissances) {
+            txt.concat(c.toString());
+        }
+        return txt;
+    }
+
 }

enigme.java/Interaction.java

@@ -1,3 +1,5 @@
+import java.util.List;
+
 public class Interaction {
     Condition visible;
     List<Connaissance> connaissances;
@@ -17,4 +19,17 @@ public class Interaction {
         this.objetsConso = objetsConso;
         this.actions = actions;
     }
+
+    @Override
+    public String toString() {
+        String res = "";
+        int k = 0;
+        for (Action a : i.actions) {
+            if (a.visible.evaluer()) {
+                res += k + " " + a + "\n";
+                k++;
+            }
+        }
+        return super.toString();
+    }
 }

enigme.java/Jeu.java

@@ -1,3 +1,6 @@
+import java.io.InputStreamReader;
+import java.io.BufferedReader;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -22,6 +25,99 @@ public class Jeu {
         this.transformations = transformations;
     }
 
+    void jouer() {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+
+        Lieu lieu = null;
+        for (Lieu l : territoire.lieux) {
+            if (l.depart.evaluer()) {
+                lieu = l;
+                break;
+            }
+        }
+
+        while (!lieu.fin.evaluer()) {
+            System.out.println(Jeu.explorateur);
+            boolean reverifier_interraction = true;
+            while (reverifier_interraction) {
+                reverifier_interraction = false;
+                for (Personne p : lieu.personnes) {
+                    if (p.visible.evaluer() && p.obligatoire.evaluer()) {
+                        for (Interaction i : p.interractions) {
+                            if (i.visible.evaluer()) {
+                                boolean arreter_interraction = false;
+                                while (!arreter_interraction) {
+                                    List<Action> actions_choix = new ArrayList<>();
+                                    for (Action a : i.actions) {
+                                        if (a.visible.evaluer()) {
+                                            actions_choix.add(a);
+                                        }
+                                    }
+                                    int choix = 0;
+                                    try {
+                                        choix = Integer.parseInt(reader.readLine());
+                                    } catch (NumberFormatException e) {
+                                        continue;
+                                    } catch (IOException e) {
+                                        e.printStackTrace();
+                                    }
+                                    Action a = actions_choix.get(choix);
+                                    for (Connaissance c : a.connaissances) {
+                                        if (!Jeu.explorateur.connaissances.contains(c)) {
+                                            Jeu.explorateur.connaissances.add(c);
+                                        }
+                                    }
+                                    for (Objet o : a.objetsRecus) {
+                                        Jeu.explorateur.objets.add(o);
+                                    }
+                                    for (Objet o : a.objetsConso) {
+                                        Jeu.explorateur.objets.remove(o);
+                                    }
+
+                                    arreter_interraction = a.finInterraction.evaluer();
+                                }
+                            }
+                        }
+                        reverifier_interraction = true;
+                    }
+                }
+            }
+
+            boolean chemin_pris = false;
+            for (Chemin c : territoire.chemins) {
+                if (c.lieuIn == lieu) {
+                    if (c.visible.evaluer() && c.obligatoire.evaluer() && c.ouvert.evaluer()) {
+                        lieu = c.lieuOut;
+                        chemin_pris = true;
+                    }
+                }
+            }
+
+            if (!chemin_pris) {
+                List<Chemin> chemins_choix = new ArrayList<>();
+                for (Chemin c : territoire.chemins) {
+                    if (c.lieuIn == lieu) {
+                        if (c.visible.evaluer() && c.ouvert.evaluer()) {
+                            chemins_choix.add(c);
+                            System.out.println(c);
+                        }
+                    }
+                }
+                int choix = 0;
+                try {
+                    choix = Integer.parseInt(reader.readLine());
+                } catch (NumberFormatException e) {
+                    continue;
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                lieu = chemins_choix.get(choix).lieuOut;
+            }
+        }
+
+        System.out.println("FIN : " + lieu.nom);
+    }
+
     public static void main(String[] args) {
 
         // raccourcis "true" "false"
@@ -37,20 +133,28 @@ public class Jeu {
                 1,
                 vraie,
                 new ArrayList<>());
-
         jeu_objets.add(tentative_objet);
 
         // "Connaissances" : [
 
         List<Connaissance> jeu_connaissances = new ArrayList<>();
 
-        Connaissance reussite_connaissance = new Connaisssance(
+        Connaissance reussite_connaissance = new Connaissance(
                 "Réussite",
                 vraie,
                 new ArrayList<>());
-
         jeu_connaissances.add(reussite_connaissance);
 
+        // Conditions
+
+        Condition condition0 = new Condition(new ConditionEt(
+                new ConditionConnaissance(reussite_connaissance, true),
+                new ConditionObjet(tentative_objet, ">", 0)));
+        Condition condition1 = new Condition(new ConditionEt(
+                new ConditionObjet(tentative_objet, ">", 0)));
+        Condition condition2 = new Condition(new ConditionEt(
+                new ConditionConnaissance(reussite_connaissance, true)));
+
         // "Transformations" : [
 
         List<Transformation> transformations = new ArrayList<>();
@@ -58,12 +162,18 @@ public class Jeu {
         // "Explorateur" : [
 
         int explorateur_tailleInventaire = 3;
+
         List<Objet> explorateur_inventaire = new ArrayList<>();
+        explorateur_inventaire.add(tentative_objet);
+        explorateur_inventaire.add(tentative_objet);
+        explorateur_inventaire.add(tentative_objet);
+
         List<Connaissance> explorateur_connaissances = new ArrayList<>();
+
         Jeu.explorateur = new Explorateur(
                 explorateur_tailleInventaire,
-                explorateur_inventaire,
+                explorateur_connaissances,
-                explorateur_connaissances);
+                explorateur_inventaire);
 
         // "Personnes" : [
 
@@ -71,47 +181,58 @@ public class Jeu {
 
         List<Interaction> sphinx_interactions = new ArrayList<>();
 
-        List<Action> sphinx_interactions_actions = new ArrayList<>();
+        List<Action> sphinx_interaction_actions = new ArrayList<>();
+
+        List<Connaissance> connaissances_action_reussite = new ArrayList<>();
+
+        connaissances_action_reussite.add(reussite_connaissance);
 
         Action action_reussite = new Action(
                 vraie,
-                new ArrayList<>().add("Réussite"),
+                connaissances_action_reussite,
                 new ArrayList<>(),
                 new ArrayList<>(),
-                vraie);
+                vraie,
-
+                new ArrayList<>());
         sphinx_interaction_actions.add(action_reussite);
 
+        List<Objet> objets_action_echec = new ArrayList<>();
+
+        objets_action_echec.add(tentative_objet);
+
         Action action_echec = new Action(
                 vraie,
                 new ArrayList<>(),
                 new ArrayList<>(),
-                new ArrayList<>().add(tentative_objet),
+                objets_action_echec,
-                vraie);
+                vraie,
-
+                new ArrayList<>());
         sphinx_interaction_actions.add(action_echec);
 
         Interaction sphinx_interaction = new Interaction(
                 vraie,
                 new ArrayList<>(),
                 new ArrayList<>(),
-                sphinx_interactions_actions);
+                new ArrayList<>(),
+                sphinx_interaction_actions);
         sphinx_interactions.add(sphinx_interaction);
 
-        Personne sphinx = new Personne(
+        Personne sphinx_personne = new Personne(
                 "Sphinx",
-                vraie,
+                condition0,
                 vraie,
                 sphinx_interactions);
+        jeu_personnes.add(sphinx_personne);
 
-        jeu_personnes.add(sphinx);
+        // "Territoire" : {
 
         List<Lieu> lieux = new ArrayList<>();
 
         List<Personne> debut_personnes = new ArrayList<>();
+        debut_personnes.add(sphinx_personne);
 
-        Lieu debut = new Lieu(
+        Lieu enigme = new Lieu(
-                "Départ",
+                "Énigme",
                 faux,
                 vraie,
                 faux,
@@ -119,10 +240,9 @@ public class Jeu {
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>());
+        lieux.add(enigme);
 
-        lieux.add(debut);
+        Lieu succes = new Lieu(
-
-        Lieux succes = new Lieu(
                 "Succès",
                 faux,
                 faux,
@@ -131,10 +251,9 @@ public class Jeu {
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>());
-
         lieux.add(succes);
 
-        Lieux echec = new Lieu(
+        Lieu echec = new Lieu(
                 "Échec",
                 faux,
                 faux,
@@ -143,39 +262,34 @@ public class Jeu {
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>());
-
         lieux.add(echec);
 
         List<Chemin> chemins = new ArrayList<>();
 
         Chemin enigme_succes = new Chemin(
-                debut,
+                enigme,
                 succes,
-                faux,
                 vraie,
-                faux,
+                condition1,
+                vraie,
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>());
-
         chemins.add(enigme_succes);
 
         Chemin enigme_echec = new Chemin(
-                debut,
+                enigme,
                 echec,
-                faux,
                 vraie,
-                faux,
+                condition2,
+                vraie,
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>(),
                 new ArrayList<>());
-
         chemins.add(enigme_echec);
 
-        // "Territoire" : {
-
         Territoire territoire = new Territoire(
                 lieux,
                 chemins);
@@ -184,9 +298,11 @@ public class Jeu {
                 territoire,
                 jeu_objets,
                 jeu_connaissances,
-                personnes,
+                jeu_personnes,
                 transformations);
 
+        jeu.jouer();
+
     }
 
 }

enigme.java/Lieu.java

@@ -1,8 +1,10 @@
+import java.util.List;
+
 public class Lieu {
     String nom;
-    Boolean deposable;
+    Condition deposable;
-    Boolean depart;
+    Condition depart;
-    Boolean fin;
+    Condition fin;
     List<Personne> personnes;
     List<Description> descriptions;
     List<Objet> objets;
@@ -10,9 +12,9 @@ public class Lieu {
 
     public Lieu(
             String nom,
-            Boolean deposable,
+            Condition deposable,
-            Boolean depart,
+            Condition depart,
-            Boolean fin,
+            Condition fin,
             List<Personne> personnes,
             List<Description> descriptions,
             List<Objet> objets,

enigme.java/Objet.java

@@ -1,17 +1,29 @@
+import java.util.List;
+
 public class Objet {
     String nom;
     int taille;
     Condition visible;
-    Description description;
+    List<Description> descriptions;
 
     public Objet(
             String nom,
             int taille,
             Condition visible,
-            Description description) {
+            List<Description> descriptions) {
         this.nom = nom;
         this.taille = taille;
         this.visible = visible;
-        this.description = description;
+        this.descriptions = descriptions;
+    }
+
+    @Override
+    public String toString() {
+        for (Description d : this.descriptions) {
+            if (d.condition.evaluer()) {
+                return this.nom + ": " + d;
+            }
+        }
+        return "No desc";
     }
 }

enigme.java/Personne.java

@@ -1,14 +1,16 @@
+import java.util.List;
+
 public class Personne {
     String nom;
     Condition visible;
     Condition obligatoire;
-    List<Interraction> interractions;
+    List<Interaction> interractions;
 
     public Personne(
             String nom,
             Condition visible,
             Condition obligatoire,
-            List<Interraction> interractions) {
+            List<Interaction> interractions) {
         this.nom = nom;
         this.visible = visible;
         this.obligatoire = obligatoire;

enigme.java/Territoire.java

@@ -1,3 +1,5 @@
+import java.util.List;
+
 public class Territoire {
     List<Lieu> lieux;
     List<Chemin> chemins;

enigme.java/Transformation.java

@@ -1,3 +1,5 @@
+import java.util.List;
+
 public class Transformation {
     Condition possible;
     List<Objet> objetsSources;

workspace/game/bin/xtext/Game.xtext

@@ -96,12 +96,14 @@ Interaction:
     '"visible"' ':' visible=Condition ','
     '"connaissances"' ':' '[' (connaissances+=Nom (connaissances+=Nom)*)? ']' ','
     '"objets_recus"' ':' '[' (objetsRecus+=Nom (objetsRecus+=Nom)*)? ']' ','
+    '"objets_conso"' ':' '[' (objetsConso+=Nom (objetsRecus+=Nom)*)? ']' ','
     '"actions"' ':' '[' (actions+=Action)+ ']' ','
   '}'
 ;
 
 Action:
   '{'
+  '"Description"' ':' '[' descriptions+=Description (descriptions+=Description)* ']' ','
     '"visible"' ':' visible=Condition ','
     '"connaissances"' ':' '[' (connaissances+=Nom (connaissances+=Nom)*)? ']' ','
     '"objets_recus"' ':' '[' (objetsRecus+=Nom (objetsRecus+=Nom)*)? ']' ','

workspace/game/src/xtext/Game.xtext

@@ -96,12 +96,14 @@ Interaction:
     '"visible"' ':' visible=Condition ','
     '"connaissances"' ':' '[' (connaissances+=Nom (connaissances+=Nom)*)? ']' ','
     '"objets_recus"' ':' '[' (objetsRecus+=Nom (objetsRecus+=Nom)*)? ']' ','
+    '"objets_conso"' ':' '[' (objetsConso+=Nom (objetsRecus+=Nom)*)? ']' ','
     '"actions"' ':' '[' (actions+=Action)+ ']' ','
   '}'
 ;
 
 Action:
   '{'
+  '"Description"' ':' '[' descriptions+=Description (descriptions+=Description)* ']' ','
     '"visible"' ':' visible=Condition ','
     '"connaissances"' ':' '[' (connaissances+=Nom (connaissances+=Nom)*)? ']' ','
     '"objets_recus"' ':' '[' (objetsRecus+=Nom (objetsRecus+=Nom)*)? ']' ','