Hashiparmentier 0.4.0

data/lib/Hashiparmentier/Core/Hypothese.rb

@@ -0,0 +1,43 @@
+
+
+
+##
+# Auteur:: Brabant Mano
+# Version:: 0.1
+# Date:: 09/04/2020
+#
+#Cette classe représente une hypothèse (une sauvegarde de la grille à un certain moment)
+class Hypothese
+
+  #@grille => La grille supposé()
+
+
+  ##
+  #Ce constructeur permet de créer une nouvelle hyoothèse
+  #param::
+  # * grille La grille que l'on suppose
+  def Hypothese.creer(grille)
+    new(grille)
+  end
+
+  #:nodoc:
+  def initialize(grille)
+    @grille = Marshal.dump(grille) #copie profonde
+  end
+  #:doc:
+
+  ##
+  #Cette méthode permet d'afficher l'hypothèse
+  def to_s
+    @grille.to_s()
+  end
+
+  ##
+  #Cette méthode permet de récuperer la grille
+  #return::
+  # * La grille que l'on a supposé
+  def getGrille()
+    return Marshal.load(@grille)
+  end
+
+end

data/lib/Hashiparmentier/Core/Ile.rb

@@ -0,0 +1,330 @@
+
+
+require_relative "../Core/Case.rb"
+
+
+##
+# Auteur:: Brabant Mano
+# Version:: 0.1
+# Date:: 09/04/2020
+#
+#Cette classe représente les iles de la grille
+#
+#Hérite de Case
+class Ile < Case
+
+  #Cette constante représente l'une des directions dans laquelle peut se trouver un voisin
+  HAUT = 0
+
+  #Cette constante représente l'une des directions dans laquelle peut se trouver un voisin
+  DROITE = 1
+
+  #Cette constante représente l'une des directions dans laquelle peut se trouver un voisin
+  BAS = 2
+
+  #Cette constante représente l'une des directions dans laquelle peut se trouver un voisin
+  GAUCHE = 3
+
+  #Cette constante représente l'ensemble des directions dans laquelle peut se trouver un voisin
+  DIRECTIONS = [HAUT, DROITE, BAS, GAUCHE]
+
+  #@valeur => Le nombre de lien que doit possèder l'ile pour être valide
+  attr_reader :valeur
+
+  #@dernier => true si l'ile est la derniere ile séléctionnée
+  attr_accessor :dernier
+
+  #@nbPont => Le nombre de pont que possède l'ile dans chaque direction [HAUT, DROITE, BAS, GAUCHE]
+
+  include Comparable
+  private_class_method :new
+
+  ##
+  #Ce constructeur permet de créer une nouvelle ile
+  #param::
+  # * posX La position en abscisse
+  # * posY La position en ordonnée
+  # * nbLien Le nombre de lien que doit possèder l'ile pour être valide
+  # * grille La grille sur laquelle se trouve l'ile
+  def Ile.creer(posX, posY, nbLien, grille)
+    new(posX, posY, nbLien, grille)
+  end
+
+  #:nodoc:
+  def initialize(posX, posY, nbLien, grille)
+
+    super(posX, posY, grille)
+    @valeur = nbLien
+    @nbPont = [0, 0, 0, 0]
+    @dernier = false
+
+  end
+  #:doc:
+
+  ##
+  #Cette méthode permet de recuperer le nombre de lien nécéssaire pour être valide
+  #return::
+  # * Le nombre de lien nécéssaire pour être valide
+  def getValeur()
+      return @valeur
+  end
+
+  ##
+  #Cette méthode permet de recuperer le nombre de lien actuel
+  #return::
+  # * Le nombre de lien actuel
+  def getNombrePont()
+    return @nbPont[HAUT] + @nbPont[DROITE] + @nbPont[BAS] + @nbPont[GAUCHE]
+  end
+
+  ##
+  #Cette méthode permet d'ajouter un pont entre cette ile et une autre
+  #param::
+  # * ile L'autre ile
+  def ajouteNombrePont(ile)
+
+    for direction in DIRECTIONS
+      if(aVoisin?(direction))
+        if(getVoisin(direction) == ile)
+          @nbPont[direction] += 1
+          @nbPont[direction] %= (Pont::MAX_LIGNE + 1)
+        end
+      end
+    end
+
+  end
+
+  ##
+  #Cette méthode permet de retirer un pont entre cette ile et une autre
+  #param::
+  # * ile L'autre ile
+  def retireNombrePont(ile)
+
+    for direction in DIRECTIONS
+      if(aVoisin?(direction))
+        if(getVoisin(direction) == ile)
+          @nbPont[direction] += Pont::MAX_LIGNE
+          @nbPont[direction] %= (Pont::MAX_LIGNE + 1)
+        end
+      end
+    end
+
+  end
+
+  ##
+  #Cette méthode permet d'appeler clickOnIle de la grille dans laquelle se trouve l'ile
+  def clickOn()
+    @grille.clickOnIle(self)
+  end
+
+  ##
+  #Cette méthode permet de savoir si cette ile est la dernière ile séléctionné
+  #return::
+  # * true Si l'ile est la dernière séléctionné
+  # * false Sinon
+  def estDernierIle()
+    return @dernier
+  end
+
+
+
+  ##
+  #Cette méthode permet de savoir si l'ile est connécté à autant de pont que son objectif
+  #return::
+  # * true Si l'ile est connécté à autant de pont que son objectif
+  # * false Sinon
+  def estValide?()
+    return getNombrePont() == getValeur()
+  end
+
+
+  ##
+  #Cette méthode permet de savoir combien il reste de pont à connécter pour que l'ile soit valide
+  #return::
+  # * Combien il reste de pont à connécter pour que l'ile soit valide
+  def getCapaciteResiduelle()
+    return getValeur() - getNombrePont()
+  end
+
+  ##
+  #Cette méthode permet de savoir le nombre de ponts qui peuvent être connecté à l'ile
+  #return::
+  # * Le nombre de ponts qui peuvent être connecté à l'ile
+  def getNombreCheminDisponible()
+
+    ret = 0
+    for direction in DIRECTIONS
+      if(aVoisinDisponible?(direction))
+        voisin = getVoisin(direction)
+        ret += [2 - @grille.valeurPont(voisin, self), voisin.getCapaciteResiduelle()].min()
+      end
+    end
+    return ret
+
+  end
+
+  ##
+  #Cette méthode permet d'afficher l'ile dans un terminal
+  def to_s()
+    return getCapaciteResiduelle().to_s()
+  end
+
+  ##
+  #Cette méthode permet d'afficher les infos utiles de l'ile
+  def afficheInfo()
+    return @valeur, @posX, @posY, getCapaciteResiduelle()
+  end
+
+  ##
+  #Cette méthode permet de connaitre le nombre de directions dans laquelle on peut ajouter un pont
+  #return::
+  # * Le nombre de directions dans laquelle on peut ajouter un pont
+  def getNombreDirectionConstructible()
+
+    ret = 0
+    for direction in DIRECTIONS
+      if(aVoisinDisponible?(direction))
+        if(@grille.valeurPont(self, getVoisin(direction)) != Pont::MAX_LIGNE && getVoisin(direction).getCapaciteResiduelle > 0)
+          ret += 1
+        end
+      end
+    end
+    return ret
+
+  end
+
+  ##
+  #Cette méthode permet de connaitre le nombre de direction dans laquelle un voisin est disponible
+  #return::
+  # * Le nombre de direction dans laquelle un voisin est disponible
+  def getNombreDirectionDisponible()
+
+    ret = 0
+    for direction in DIRECTIONS
+      if(aVoisinDisponible?(direction))
+        ret += 1
+      end
+    end
+    return ret
+
+  end
+
+  ##
+  #Cette méthode permet de comparer des iles entre-elles
+  #param::
+  # * autre L'autre ile à comparer
+  #return::
+  # * 0 si les iles sont égales
+  # * un nombre négatif si la première ile est inférieure à la deuxième
+  # * un nombre positif si la première ile est supérieure à la deuxième
+  def <=>(autre)
+
+    return 1 if(!autre.estIle?())
+    return @valeur <=> autre.valeur if(@valeur != autre.valeur)
+    return @posX <=> autre.posX if(@posX != autre.posX)
+    return @posY <=> autre.posY if(@posY != autre.posY)
+    return 0
+
+  end
+
+  ##
+  #Cette méthode permet de connaitre un voisin dans une direction
+  #param::
+  # * direction La direction dans laquelle on cherche le voisin
+  #return::
+  # * Le voisin dans cette direction s'il existe
+  # * raiseException Sinon
+  def getVoisin(direction)
+
+    indiceX, indiceY = getIncrementDirection(direction)
+    indiceAddX = indiceX
+    indiceAddY = indiceY
+    until(@grille.sortLimite?(@posX + indiceX, @posY + indiceY) || @grille.getCase(@posX + indiceX, @posY + indiceY).estIle?())
+      indiceX += indiceAddX
+      indiceY += indiceAddY
+    end
+    posX = @posX + indiceX
+    posY = @posY + indiceY
+    if(@grille.sortLimite?(posX, posY))
+      raise("Cette ile n'a pas de voisins dans cette direction : " + direction.to_s())
+    else
+      return @grille.getCase(posX, posY)
+    end
+
+  end
+
+  ##
+  #Cette méthode permet de savoir si l'ile a un voisin dans une direction
+  #param::
+  # * direction La direction dans laquelle on cherche le voisin
+  #return::
+  # * true Si l'ile a un voisin dans cette direction
+  # * false Sinon
+  def aVoisin?(direction)
+
+    begin
+      return getVoisin(direction).estIle?()
+    rescue => e
+      #puts e.message()
+      return false
+    end
+
+  end
+
+  private def getIncrementDirection(direction)
+
+    if(direction == Ile::HAUT)
+      indiceX = -1
+      indiceY = 0
+    elsif (direction == Ile::BAS)
+      indiceX = 1
+      indiceY = 0
+    elsif (direction == Ile::GAUCHE)
+      indiceX = 0
+      indiceY = -1
+    elsif (direction == Ile::DROITE)
+      indiceX = 0
+      indiceY = 1
+    else
+      raise("La direction n'est pas bonne")
+    end
+    return indiceX, indiceY
+
+  end
+
+
+  ##
+  #Cette méthode permet de savoir si l'ile a un voisin disponible dans une direction (s'il n'a pas de pont qui les sépares)
+  #param::
+  # * direction La direction dans laquelle on cherche le voisin
+  #return::
+  # * true Si l'ile a un voisin disponible dans cette direction
+  # * false Sinon
+  def aVoisinDisponible?(direction)
+
+    begin
+      ile2 = self.getVoisin(direction)
+      return @grille.routeDisponible?(self, ile2)
+    rescue => e
+      #puts e.message()
+      return false
+    end
+
+  end
+
+  ##
+  #Cette méthode retourne vrai
+  #return::
+  # * true
+  def estIle?()
+    return true
+  end
+
+  ##
+  #Cette méthode permet de remettre à zéro l'ile
+  def raz
+    @nbPont = [0, 0, 0, 0]
+    @dernier = false
+  end
+
+end

data/lib/Hashiparmentier/Core/Jeu.rb

@@ -0,0 +1,177 @@
+
+
+##
+# Auteur Brabant Mano, Serelle Erwan
+# Version 0.1 : Date : 07/02/2020
+
+
+require_relative "../Core/Grille.rb"
+require_relative "../Core/Aide.rb"
+require_relative "../Core/Sauvegarde.rb"
+require_relative "../Core/Compte.rb"
+#require_relative "../Core/Checkpoint.rb"
+require_relative "../Core/DonnerTechnique.rb"
+require_relative "../Core/VerifierGrille.rb"
+require_relative "../Core/Action.rb"
+require_relative "../Core/Hypothese.rb"
+require_relative "../Core/Chrono.rb"
+
+#require_relative '../class/JeuUI.rb'
+
+##
+#Cette classe permet de s'occuper du déroulement d'une partie
+class Jeu
+
+    private_class_method :new
+
+    @compte #le compte Darcula
+    @grille #la grille ou se deroule la partie
+    @grilleSolution #la grille complétée
+    @tech #objet qui fournit des aides techniques
+    @verif # objet qui vérifie la grille
+    @checkpoints #objet qui gere les hypotheses
+    @jeuUI
+    @scoreCourant
+
+    attr_accessor :grille
+
+    #Ce constructeur permet de creer un nouveau Jeu
+    #
+    #:arg: difficulte
+    #:arg: tailleGrille : Entier
+    #:arg: compte : Compte
+    def Jeu.creer(difficulte, tailleGrille, compte, jeuUI, labelChrono, labelScore)
+        new(difficulte, tailleGrille, compte, jeuUI, labelChrono, labelScore)
+    end
+
+    #:nodoc:
+    def initialize(difficulte, tailleGrille, compte, jeuUI, labelChrono, labelScore)
+        @labelChrono = labelChrono
+        @labelScore = labelScore
+        @grille = chargerGrille(difficulte, tailleGrille, compte)
+        @jeuUI = jeuUI
+        @compte = compte
+        @scoreCourant = 500 * tailleGrille
+        @labelScore.set_label(@scoreCourant.to_s)
+        @checkpoints = Pile.creer()
+        @verifGrille = VerifierGrille.creer(@grille)
+        @donnerTech = DonnerTechnique.creer(@grille)
+        @chronoGrille = Chrono.new(self,  @labelChrono)
+        @threadChrono = Thread.new{@chronoGrille.lancerChrono()}
+    end
+    #:doc
+
+    ##
+    #charge une grille pour une partie
+    #:arg: difficulte
+    #:arg: tailleGrille : Entier
+    #:arg: compte : Compte
+    #@return Grille
+    def chargerGrille(difficulte, tailleGrille, compte)
+        lst = Sauvegarde.liste(compte, tailleGrille, difficulte)
+        if(lst.count() == 0)
+            raise("Y a pas de sauvegarde")
+        end
+        lst.each_with_index do |s, index|
+          print "\n", index, ":", "\n"
+          s.getGrille().afficheToi()
+        end
+        res = -1
+        while(res < 0 || res >= lst.length)
+          res = gets.chomp().to_i()
+        end
+        return lst[res].getGrille()
+    end
+
+    ##
+    #algorithme du jeu
+    #:arg: grille : Grille
+    #:arg: compte : Compte
+    #@return win : Boolean
+    def lanceToi()
+        win = false #T'es mauvais Jack
+        @jeuUI.AfficherGrille()
+        while(!win)
+            @grille.afficheToi
+
+            case action()
+            when 1
+              begin
+                ile2 = demandeCoord()
+                @grille.clickOnIle(ile2)
+              rescue => e
+                puts "Erreur : " +  e.message()
+              end
+              self.modifScore(-1000)
+            when 2
+                @grille.undo()
+            when 3
+                @grille.redo()
+            when 4
+                Sauvegarde.recuperer(@compte, @grille).setGrille(@grille).sauvegarder()
+            when 5
+                @grille.creerHypothese()
+            when 6
+                @grille.valideHypothese()
+            when 7
+                @grille.supprimeHypothese(self)
+            when 8
+                @verifGrille.aider()
+            when 9
+                @donnerTech.aider()
+            else
+                #puts "puts"
+            end
+        end
+    end
+
+
+
+    ##
+    #affichage de l'aide
+    #:arg: aide : String
+    def afficherAide(aide)
+      puts aide
+    end
+
+    def modifScore(val)
+        @scoreCourant += val
+        @labelScore.set_label(@scoreCourant.to_s)
+    end
+
+    ##
+    #decide de l'action du joueur
+    #@return Entier
+    def action
+        puts "1 : pose/supprime un pont\n"
+        puts "2 : undo\n"
+        puts "3 : redo\n"
+        puts "4 : Sauvegarder la grille\n"
+        puts "5 : Creer hypothese\n"
+        puts "6 : Valider hypothese\n"
+        puts "7 : Supprimer hypothese\n"
+        puts "8 : Verifier grille\n"
+        puts "9 : Donner technique\n"
+        return gets.chomp.to_i
+    end
+
+    ##
+    #demande des coordonnées à l'utilisateur pour la sélection d'une case dans la grille
+    #@return Case
+    def demandeCoord
+        puts "Saisir coordonnées d'une ile :"
+        puts "coordonnée en x : "
+        x = gets.chomp.to_i
+        puts "coordonnée en y : "
+        y = gets.chomp.to_i
+        if(@grille.sortLimite?(x, y))
+          raise("Les coordonnée ne sont pas correctes")
+        end
+        if(!@grille.getCase(x, y).estIle?())
+          raise("La case n'est pas une ile")
+        end
+        return @grille.getCase(x, y)
+    end
+
+
+end