Hashiparmentier 0.4.0

data/lib/Hashiparmentier/Core/Pile.rb

@@ -0,0 +1,85 @@
+
+##
+# Auteur:: Brabant Mano
+# Version:: 0.1
+# Date:: 09/04/2020
+#
+#Cette classe représente une pile
+class Pile
+
+  #@indice => La position dans la pile
+  attr_reader :indice
+
+  include Enumerable
+
+  private_class_method :new
+
+  ##
+  #Ce constructeur permet de créer une nouvelle pile
+  #param::
+  # * max Le nombre maximum d'élément dans la pile ("infini" par defaut)
+  def Pile.creer(max = 0)
+    new(max)
+  end
+
+  #:nodoc:
+  def initialize(max)
+
+    @actions = Array.new()
+    @max = max
+
+  end
+  #:doc:
+
+  ##
+  #Cette méthode permet de d'empiler un élément
+  #param::
+  # * element L'élément à empiler
+  def empiler(element)
+
+    if(@max > 0)
+      if(@actions.length < @max)
+        @actions.push(element)
+      end
+    else
+      @actions.push(element)
+    end
+    return self
+
+  end
+
+  ##
+  #Cette méthode permet de dépiler le dernier élément
+  #return::
+  # * L'élément dépilé
+  # * raiseException Si la pile est vide
+  def depiler
+
+    if(self.empty?())
+      raise("La pile est vide")
+    else
+      return @actions.pop()
+    end
+
+  end
+
+  ##
+  #Cette méthode permet de savoir si la pile est vide ou non
+  #return::
+  # * true Si la pile est vide
+  # * false Sinon
+  def empty?()
+    return @actions.empty?()
+  end
+
+  ##
+  #Cette méthode permet d'itérer sur tous les éléments de la pile
+  def each
+
+    @actions.each do |hyp|
+       yield hyp
+     end
+
+  end
+
+end

data/lib/Hashiparmentier/Core/Pont.rb

@@ -0,0 +1,300 @@
+
+
+require_relative "../Core/Case.rb"
+require_relative "../Core/Couleur.rb"
+
+##
+# Auteur:: Brabant Mano
+# Version:: 0.1
+# Date:: 09/04/2020
+#
+#Cette classe représente les ponts du Hashi
+#
+#Hérite de Case
+class Pont < Case
+
+  #Cette constante représente l'une des directions que peut prendre un pont(Seulement quand valeur du pont = 0)
+  NULLE = 0
+
+  #Cette constante représente l'une des directions que peut prendre un pont(Pont horizontal)
+  HORIZONTAL = 1
+
+  #Cette constante représente l'une des directions que peut prendre un pont(Pont vertical)
+  VERTICAL = 2
+
+
+  #Cette constante représente le nombre maximum de ligne pour un pont
+  MAX_LIGNE = 2
+
+
+  include Comparable
+
+  #@valeur => Valeur du pont(nombre de trait)
+  attr_reader :valeur
+
+  #@direction => Direction du pont (NULLE, HORIZONTAL, VERTICAL)
+  attr_reader :direction
+
+  #@surbrillance => Booléen pour l'affichage, si égal à true le pont sera affiché en surbrillance
+  attr_accessor :surbrillance
+
+  #@directionSurbrillance => La direction dans laquelle le pont en surbrillance est dirigé
+  attr_accessor :directionSurbrillance
+
+  #@marque => Booléen pour l'affichage, si égal à true le pont sera affiché en surbrillance rouge
+  attr_accessor :marque
+
+  #@couleurPont => La couleur que prendrait le pont s'il est modifié
+  attr_reader :couleurPont
+
+  #@couleurPontCourante => La couleur du pont
+  attr_reader :couleurPontCourante
+
+  #:nodoc:
+  def Pont.verifieDirection(direction) #privée
+    return true if([NULLE, HORIZONTAL, VERTICAL].include?(direction))
+    return false
+  end
+  #:doc:
+
+
+  private_class_method :new
+
+  ##
+  #Ce constructeur permet de créer un nouveau pont
+  #param::
+  # * posX La position sur l'axe des abscisse
+  # * posY La position sur l'axe des ordonnées
+  # * grille La grille sur laquelle se trouve le pont
+  def Pont.creer(posX, posY, grille)
+      Pont.construit(posX, posY, grille, NULLE, 0)
+  end
+
+  ##
+  #Ce constructeur permet de créer un nouveau pont avec des valeurs
+  #param::
+  # * posX La position sur l'axe des abscisse
+  # * posY La position sur l'axe des ordonnées
+  # * grille La grille sur laquelle se trouve le pont
+  # * direction La direction du pont
+  # * valeur La taille du pont
+  def Pont.construit(posX, posY, grille, direction, valeur)
+
+      if(Pont.verifieDirection(direction))
+        new(posX, posY, grille, direction, valeur)
+      else
+        new(posX, posY, grille, NULLE, 0)
+      end
+
+  end
+
+
+  #:nodoc:
+  def initialize(posX, posY, grille, direction, valeur)
+
+    super(posX, posY, grille)
+    @valeur = valeur
+    @direction = direction
+    @surbrillance = false
+    @marque = false
+    @directionSurbrillance = NULLE
+    @couleurPont = Couleur::JAUNE
+    @couleurPontCourante = Couleur::JAUNE
+
+  end
+  #:doc:
+
+  ##
+  #Cette méthode permet de modifier la couleur que devrais prendre le pont s'il est modifié
+  #ainsi que sa couleur courante si elle était la même que la couleur après modification
+  #
+  #Utilisé par les hypothèses
+  #param::
+  # * couleurPont La nouvelle couleur
+  def redoCouleurPont(couleurPont)
+    if(@couleurPont == @couleurPontCourante)
+      @couleurPontCourante = couleurPont
+    end
+    @couleurPont = couleurPont
+  end
+
+  ##
+  #Cette méthode permet de modifer la couleur la couleur que devrais prendre le pont s'il est modifié
+  #param::
+  # * couleurPont La nouvelle couleur
+  def undoCouleurPont(couleurPont)
+    @couleurPont = couleurPont
+  end
+
+  ##
+  #Cette méthode permet de simuler un "clic" sur le pont
+  def clickOn()
+    @grille.clickOnPont(self)
+  end
+
+  ##
+  #Cette méthode permet de remettre à zéro le pont
+  def raz()
+
+    @valeur = 0
+    @direction = NULLE
+    @surbrillance = false
+    @marque = false
+    @directionSurbrillance = NULLE
+
+  end
+
+  ##
+  #Cette méthode permet de comparer des ponts entre-eux
+  #param::
+  # * autre L'autre pont à comparer
+  #return::
+  # * 0 si les ponts sont égaux
+  # * un nombre négatif si le premier pont est inférieur au deuxième
+  # * un nombre positif si le premier pont est supérieur au deuxième
+  def <=>(autre)
+
+    return 1 if(!autre.estPont?())
+    return @direction <=> autre.direction if(@direction != autre.direction)
+    return @valeur <=> autre.valeur if(@valeur != autre.valeur)
+    return 0
+
+  end
+
+  ##
+  #Cette méthode permet d'afficher le pont dans un terminal
+  def to_s()
+
+    ret = " "
+    if(@surbrillance)
+      ret = "P"
+    end
+    if(@direction == HORIZONTAL)
+      if(@valeur == 1)
+        ret = "-"
+      elsif(@valeur == 2)
+        ret = "="
+      end
+    elsif(@direction == VERTICAL)
+      if(@valeur == 1)
+        ret = "|"
+      elsif(@valeur == 2)
+        ret = "\""
+      end
+    end
+    if(@marque)
+      ret = "R"
+    end
+    return ret
+
+  end
+
+
+  private def modifValeur(direction, valeur)
+      #print "Couleur Pont : ", @couleurPontCourante, @couleurPont, "\n"
+      demarquer()
+      if(@direction != NULLE)
+          #On modifie la valeur du pont si la direction donné est la bonne
+          if(@direction == direction)
+              @valeur = (@valeur + valeur) % (MAX_LIGNE + 1)
+              if(@valeur == 0)
+                  @direction = NULLE
+              end
+              @couleurPontCourante = @couleurPont
+              ret = true
+          end
+          ret = false
+      #On crée un nouveau pont
+      elsif(@direction == NULLE)
+          @direction = direction
+          @valeur = valeur
+          @couleurPontCourante = @couleurPont
+          ret = true
+      end
+      #puts "apres"
+      #print "Couleur Pont : ", @couleurPontCourante, @couleurPont, "\n"
+      return ret
+  end
+
+  private def modifSurbrillance(direction, valeur)
+    if(@direction != NULLE)
+      if(@direction == direction)
+        @surbrillance = valeur
+        @directionSurbrillance = direction
+        return true
+      end
+      return false
+    elsif(@direction == NULLE)
+      @surbrillance = valeur
+      @directionSurbrillance = direction
+      return true
+    end
+  end
+
+  ##
+  #Cette méthode permet d'augmenter la valeur du pont
+  #param::
+  # * direction La direction dans laquelle on veut augmenter le pont
+  #Si le pont que l'on augmente avait 2 trait alors le pont disparait
+  #return::
+  # * true Si la valeur à été modifié
+  # * false Sinon
+  def augmenteValeur(direction)
+      return modifValeur(direction, 1)
+  end
+
+  ##
+  #Cette méthode permet de diminuer la valeur du pont
+  #param::
+  # * direction La direction dans laquelle on veut diminuer le pont
+  #Si le pont que l'on diminue n'avait pas de trait alors un pont à deux trait apparait
+  #return::
+  # * true Si la valeur à été modifié
+  # * false Sinon
+  def diminueValeur(direction)
+      return modifValeur(direction, MAX_LIGNE)
+  end
+
+  ##
+  #Cette méthode permet de mettre en surbrillance le pont
+  #param::
+  # * direction La direction dans laquelle on veut mettre en surbrillance le pont
+  #return::
+  # * true Si le pont a été mis en surbrillance
+  # * false Sinon
+  def metSurbrillance(direction)
+      return modifSurbrillance(direction, true)
+  end
+
+  ##
+  #Cette méthode permet de diminuer la valeur du pont
+  #param::
+  # * direction La direction dans laquelle on veut enlever la surbrillance
+  #return::
+  # * true Si la valeur n'est plus en surbrillance
+  # * false Sinon
+  def supprSurbrillance(direction)
+      return modifSurbrillance(direction, false)
+  end
+
+  ##
+  #Cette méthode permet de modifier le marquage du pont quand il est faux
+  def marquer()
+    @marque = true
+  end
+
+  ##
+  #Cette méthode permet de modifier le marquage du pont quand il est valide
+  def demarquer()
+    @marque = false
+  end
+
+  ##
+  #Cette méthode retourne vrai
+  #return::
+  # * true
+  def estPont?()
+    return true
+  end
+
+end

data/lib/Hashiparmentier/Core/Sauvegarde.rb

@@ -0,0 +1,176 @@
+
+
+require_relative "../Core/Compte.rb"
+require_relative "../Core/Grille.rb"
+require "active_record"
+
+##
+# Auteur:: Brabant Mano
+# Version:: 0.1
+# Date:: 09/04/2020
+#
+#Cette classe permet de sauvegarder dans une base de données la progression d'un joueur sur une grille et de faire des recherches sur les sauvegardes
+class Sauvegarde < ActiveRecord::Base
+
+
+  #@grille => Contient la grille que l'utilisateur a commencé à remplir
+
+  validates :grille, presence: true
+
+
+
+  #@compte => Contient le compte auquel appartient la sauvegarde
+  belongs_to :compte
+
+  validates :compte, presence: true
+
+
+  ##
+  #Cette méthode permet de supprimer toutes les sauvegardes dans la base de donnée
+  def Sauvegarde.razAllSauvegarde()
+    Sauvegarde.delete_all()
+  end
+
+  ##
+  #Cette méthode permet de créer un sauvegarde pour un ensemble de grille
+  #param::
+  # * compte Le compte pour lequel on va créer les sauvegardes
+  # * grilles Un tableau qui contient les grilles à sauvegarder
+  def Sauvegarde.creerAll(compte, grilles)
+
+    grilles.each do |g|
+      Sauvegarde.creer(compte, g).sauvegarder()
+    end
+
+  end
+
+
+  private_class_method :new
+
+  ##
+  #Cette méthode permet de creer une grille pour un compte
+  #param::
+  # * compte Le compte auquel la sauvegarde est lié
+  # * grille La grille auquel la sauvegarde est lié
+  #return::
+  # * raiseException Si le compte possède déjà une sauvegarde de cette grille
+  def Sauvegarde.creer(compte, grille)
+
+    begin
+      temp = Marshal.dump(grille).force_encoding("ISO-8859-1").encode("UTF-8")
+      Marshal.load(temp)
+    rescue
+      temp = YAML.dump(grille)
+    end
+    new(:compte => compte, :grille => temp, :taille => grille.tailleX(), :difficulte => grille.difficulte(), :meilleurScore => 0)
+
+  end
+
+  ##
+  #Cette méthode permet de recupérer la sauvegarde d'un compte pour une grille
+  #param::
+  # * compte Le compte auquel la sauvegarde est lié
+  # * grille La grille auquel la sauvegarde est lié
+  #return::
+  # * La sauvegarde si elle existe
+  # * nil Sinon
+  def Sauvegarde.recuperer(compte, grille)
+
+    liste = Sauvegarde.listeCompte(compte)
+    liste.each do |s|
+      if(s.getGrille().memeSolution(grille))
+        return s
+      end
+    end
+    return nil
+
+  end
+
+  ##
+  #Cette méthode permet de connaitre les sauvegardes d'un joueur
+  #param::
+  # * compte Le compte du joueur
+  #return::
+  # * Le tableau des sauvegardes du compte
+  def Sauvegarde.listeCompte(compte)
+    return Sauvegarde.where(compte: compte).to_a()
+  end
+
+  ##
+  #Cette méthode permet de connaitre les sauvegardes d'un joueur pour les grilles d'une certaine taille et d'une certaine difficulté
+  #param::
+  # * compte Le compte du joueur
+  # * taille La taille de la grille
+  # * difficulte La difficulte de la grille
+  #return::
+  # * Le tableau des sauvegardes du compte de taille et difficulté données
+  def Sauvegarde.liste(compte, taille, difficulte)
+    return Sauvegarde.where(compte: compte, taille: taille, difficulte: difficulte).to_a()
+  end
+
+  ##
+  #Cette méthode permet d'enregistrer la sauvegarde
+  #return::
+  # * true Si la sauvegarde est efféctué
+  # * false Sinon
+  def sauvegarder()
+    return self.save()
+  end
+
+  ##
+  #Cette méthode permet de recupérer la grille de la sauvegarde
+  #return::
+  # * La grille sauvegardé
+  def getGrille()
+
+    begin
+      return Marshal.load(self.grille)
+    rescue
+      return YAML.load(self.grille)
+    end
+
+  end
+
+  ##
+  #Cette méthode permet de modifier la grille enregistrée
+  #param::
+  # * grille La nouvelle grille
+  def setGrille(grille)
+
+    begin #Active record peut enregistrer du TEXT avec UTF-8 uniquement
+      temp = Marshal.dump(grille).force_encoding("ISO-8859-1").encode("UTF-8") #on force donc la chaine en UTF-8
+      Marshal.load(temp) #à condition que l'on puisse la recharger sans exception
+    rescue
+      temp = YAML.dump(grille) #Sinon on enregistre avec YAML qui est plus lent
+    end
+    self.grille = temp
+    return self
+
+  end
+
+  ##
+  #Cette méthode permet de recupérer le meilleur score associé à la grille enregistré
+  #return::
+  # * Le score de la sauvegarde
+  def getScore()
+    return self.meilleurScore
+  end
+
+  ##
+  #Cette méthode permet de modifier le meilleur score associé à la grille enregistré
+  #param::
+  # * score Le nouveau score
+  def setScore(score)
+
+    self.meilleurScore = score
+    return self
+
+  end
+
+  ##
+  #Cette méthode permet d'afficher une sauvegarde
+  def to_s()
+      return "#{self.compte} : #{self.getGrille()}"
+  end
+
+end