hashi-ruby 1.0.0

data/bin/assets/Matcha-dark-aliz/index.theme

@@ -0,0 +1,12 @@
+[Desktop Entry]
+Type=X-GNOME-Metatheme
+Name=Matcha-dark-aliz
+Comment=A dark modern design theme
+Encoding=UTF-8
+
+[X-GNOME-Metatheme]
+GtkTheme=Matcha-dark-aliz
+MetacityTheme=Matcha-dark-aliz
+IconTheme=Qogir-manjaro
+CursorTheme=Breeze_cursors
+ButtonLayout=menu:minimize,maximize,close

data/bin/db/Difficulte.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+# Classe Difficulte de la base de données
+class Difficulte < ActiveRecord::Base
+	has_many :grille_dbs
+
+	def to_s
+		"<Difficulte> difficulte : '#{niveau}'"
+	end
+end

data/bin/db/GestionBase.rb

@@ -0,0 +1,334 @@
+#Fonction de gestion de la base de données
+require "rubygems"
+require "active_record"
+require_relative "Joueur"
+require_relative "GrilleDb"
+require_relative "Joue"
+require_relative "Difficulte"
+require_relative "Mode"
+require_relative "PhrasesAventure"
+
+# Classe permettant la récupérations d'informations de la Base de données vers le programme grâce au joueur ou aux grilles
+class GestionBase
+	# Ajoute un joueur à la base de données
+	#
+	# === Paramètres
+	#
+	# * +pseudo+ => Le pseudo que le joueur désire (chaîne de caractères)
+	#
+	# === Retour
+	#
+	# Vrai si le pseudo est libre, faux si déjà utilisé
+	#
+	def GestionBase.ajouterJoueur(pseudo)
+		retour = nil
+	
+		#Si le pseudo n'est pas déjà pris
+		if(recupJoueur(pseudo)==nil)
+			retour = Joueur.create( :pseudo => pseudo)
+		end
+	
+		return retour != nil
+	end
+	
+	# Récupère un joueur de la base de données via son pseudo
+	#
+	# === Paramètres
+	#
+	# * +pseudo+ => Le pseudo du joueur que l'on souhaite récupérer (chaîne de caractères)
+	#
+	# === Retour
+	#
+	# Le joueur si existant, nil sinon
+	#
+	def GestionBase.recupJoueur(pseudo)
+		return Joueur.where("lower(pseudo) = ?", pseudo.downcase).first
+#		return Joueur.find_by_pseudo(pseudo)
+	end
+
+	# Récupère tous les joueur de la base de données
+	#
+	# === Retour
+	#
+	# Un tableau de joueurs
+	#
+	def GestionBase.recupJoueurAll
+		return Joueur.all
+	end
+	
+	# Récupère la difficulté d'une grille via son Id
+	#
+	# === Paramètres
+	#
+	# * +idGrille+ => L'Id de la grille dont on veut récupérer la difficulté
+	#
+	# === Retour
+	#
+	# La difficulté (niveau) de la grille (chaîne de caractère), ou nil si impossible à trouver
+	#
+	def GestionBase.recupDifficulte(idGrille)
+		grille= GrilleDb.find(idGrille)
+		return Difficulte.find(grille.difficultes_id).niveau
+	end
+	
+	# Récupère le mode de jeu de la grille via son Id
+	#
+	# === Paramètres
+	#
+	# * +idGrille+ => L'Id de la grille dont on veut récupérer le mode de jeu
+	#
+	# === Retour
+	#
+	# Le mode de jeu de la grille (chaîne de caractère), ou nil si impossible à trouver
+	#
+	def GestionBase.recupMode(idGrille)
+		grille= GrilleDb.find(idGrille)
+		return Mode.find(grille.modes_id).mode_jeu
+	end
+
+	# Récupère le score du joueur sur la grille
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du joueur dont on veut récupérer le score de la grille
+	# * +grilleDb+ => La grille dont on veut récupérer le score
+	#
+	# === Retour
+	#
+	# Le score du joueur sur la grilleDb, ou nil si le joueur n'existe pas
+	#
+	def GestionBase.recupScore(idJoueur, grilleDb)
+		score = nil
+	
+		begin
+			Joueur.find(idJoueur)
+
+			begin
+				score = Joue.where([ "joueurs_id = ? AND grille_dbs_id = ?", idJoueur, grilleDb.id ]).first.score
+			rescue
+				score = 0
+				puts "recupScore => La grille #{grilleDb.id} n'existe pas pour le joueur #{idJoueur}"
+			end
+		rescue
+			puts "recupScore ==> Joueur d'id #{idJoueur} n'existe pas dans la base"
+		ensure
+			return score
+		end
+	end
+	
+	# Récupère le score total du joueur sur les grilles qu'il a joué (uniquement en mode classé)
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du joueur dont on veut récupérer le score total
+	# * +idDifficulte+ => L'Id de la difficulté désirée
+	#
+	# === Retour
+	#
+	# Le score total du joueur sur les grilles classées terminées, ou nil si le joueur n'existe pas
+	#
+	def GestionBase.recupScoreTotal(idJoueur, idDifficulte)
+		score = nil
+	
+		begin
+			Joueur.find(idJoueur)
+			grilles = Joue.where([ "joueurs_id = ? AND terminee = 1", idJoueur ]).select{ |joue| GrilleDb.find(joue.grille_dbs_id).modes_id == Mode.find_by_mode_jeu("Classe").id && GrilleDb.find(joue.grille_dbs_id).difficultes_id == idDifficulte }
+			score = grilles.inject(0) { |s, joue| s += joue.score }
+		rescue
+			puts "recupScoreTotal ==> Joueur d'id #{idJoueur} n'existe pas dans la base"
+		ensure
+			return score
+		end
+	#	return Joue.where([ "joueurs_id = ?", idJoueur ]).sum(:score)
+	end
+	
+	# Récupère le nombre de grilles jouées par le joueur (uniquement en mode classé)
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du joueur dont on veut récupérer le nombre de grilles jouées
+	# * +idDifficulte+ => L'Id de la difficulté désirée
+	#
+	# === Retour
+	#
+	# Le nombre de grilles terminées par le joueur, ou nil si le joueur n'existe pas
+	#
+	def GestionBase.recupNbGrillesJouees(idJoueur, idDifficulte)
+		nb = nil
+	
+		begin
+			Joueur.find(idJoueur)
+			grilles = Joue.where([ "joueurs_id = ? AND terminee = 1", idJoueur ]).select{ |joue| GrilleDb.find(joue.grille_dbs_id).modes_id == Mode.find_by_mode_jeu("Classe").id && GrilleDb.find(joue.grille_dbs_id).difficultes_id == idDifficulte}
+			nb = grilles.inject(0) { |nb, joue| nb += 1 }
+		rescue
+			puts "recupNbGrillesJouees ==> Joueur d'id #{idJoueur} n'existe pas dans la base"
+		ensure
+			return nb
+		end
+	#	return Joue.where([ "joueurs_id = ?", idJoueur ]).count
+	end
+	
+	# Sauvegarde la grilles jouée par le joueur ou la créée si elle n'existe pas
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du joueur dont on veut récupérer la grille déjà commencées
+	# * +grilleDb+ => L'objet grille à enregistrer
+	#
+	# === Retour
+	#
+	# Aucun retour (Enregistrement dans la base)
+	#
+	def GestionBase.sauvegarderGrille(idJoueur, grilleDb)
+		begin			
+			raise ("raise sauvegarderGrille") if ((joue=Joue.where([ "joueurs_id = ? AND grille_dbs_id = ?", idJoueur, grilleDb.id ])).count != 1)
+			
+		rescue
+			Joue.create( :joueurs_id => idJoueur, :grille_dbs_id => grilleDb.id)
+		end
+	end
+	
+	# Récupère les grilles jouées par le joueur
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du joueur dont on veut récupérer les grilles déjà commencées 
+	# * +idDifficulte+ => L'Id de la difficulté des grilles qu'on souhaite récupérer
+	# * +idMode+ => L'Id du mode des grilles qu'on souhaite récupérer
+	# * +nbDebut+ => Le rang auquel commencer la récupération des grilles (début à 0, fin à 89)
+	# * +nbGrilles+ => Le nombre de grilles à récupérer à partir de nbDebut
+	#
+	# === Retour
+	#
+	# Les grilles, d'un nombre et de la difficulté voulus, jouées par le joueur, ou nil si le joueur n'existe pas
+	#
+	def GestionBase.recupGrilles(idJoueur, idDifficulte, idMode, nbDebut, nbGrilles)
+		grilles = nil
+	
+		begin
+			Joueur.find(idJoueur)
+			grilles = Array.new #GrilleDb.all
+#			joue = Joue.where([ "joueurs_id = ?", idJoueur ])
+			begin
+				if nbGrilles == 0
+					nbGrilles = GrilleDb.where(difficultes_id: idDifficulte, modes_id: idMode).count - nbDebut
+				end
+
+				GrilleDb.where(difficultes_id: idDifficulte, modes_id: idMode).offset(nbDebut).limit(nbGrilles).each do |grilleDb|
+					begin
+						joue = Joue.where([ "joueurs_id = ? AND grille_dbs_id = ?", idJoueur, grilleDb.id ]).first
+					rescue
+						joue = nil
+					end
+
+					if (joue != nil)
+						grilleDb.grilleSolution = joue.grilleSer
+					else
+						grille = grilleDb.grilleSolution
+
+						grille2 = YAML.load(grille)
+
+						grille = Grille.creer(grille2.tabCase, grille2.hauteur, grille2.largeur, grille2)
+
+						grilleDb.grilleSolution = YAML.dump(grille)
+#:niveau => difficulte
+						Joue.create( :joueurs_id => idJoueur, :grille_dbs_id => grilleDb.id, :grilleSer => grilleDb.grilleSolution, :score => 0, :terminee => false )
+					end
+
+					grilles.push(grilleDb)
+				end
+#				joue.map { |joue| grilles.push(GrilleDb.find(joue.grille_dbs_id)) }
+			rescue
+				puts "recupGrilles ==> Problème récupération grille depuis joue"
+			end
+		rescue
+			puts "recupGrilles ==> Joueur d'id #{idJoueur} n'existe pas dans la base"
+		ensure
+			return grilles
+		end
+	end
+
+	def GestionBase.recupGrilleAleatoire(idJoueur, idDifficulte, idMode)
+		# Récupère toutes les grilles du mode idMode et difficulte idDifficulte
+		grilles = GestionBase.recupGrilles(idJoueur, idDifficulte, idMode, 0, 0)
+
+		# Trie les grilles pour garder uniquement les grilles non terminée
+		grilleDb = grilles.select { |grilleDb| !GestionBase.grilleTerminee?(idJoueur, grilleDb) }.sample
+
+		if grilleDb == nil
+			#puts "Aucune grille non terminée, on prend parmi les terminées et on réinitialise"
+			grilleDb = grilles.sample
+
+			# Réinitialisation de la grille
+			grilleSolution = YAML.load(grilleDb.grilleSolution)
+			grille = Grille.creer(grilleSolution.tabCase, grilleSolution.hauteur, grilleSolution.largeur, grilleSolution)
+			grilleDb.grilleSolution = YAML.dump(grille)
+
+			# Enregistrement de la grille
+			GestionBase.changerScore(idJoueur, grilleDb, 0)
+		end
+
+		return grilleDb
+	end
+
+	# Modifie le score de la grille d'un Joueur
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du Joueur dont on veut modifier le scre de l'une des grilles
+	# * +grilleDb+ => L'objet grille dont on veut modifier le score
+	# score à supprimer des paramètres
+	# === Retour
+	#
+	# Aucun : modifie le score de la grille du joueur ainsi que la grilleSer
+	#
+	def GestionBase.changerScore(idJoueur, grilleDb, score)
+		begin
+			raise ("raise changerScore") if ((joue=Joue.where([ "joueurs_id = ? AND grille_dbs_id = ?", idJoueur, grilleDb.id ])).count != 1)
+			joue = joue.first
+			idDifficulte = grilleDb.difficultes_id
+			grille = YAML.load(grilleDb.grilleSolution)
+#			puts "grille: #{grille.nbAides}"
+
+			tempsReel = grille.timer
+			nbAides = 10 * grille.nbAides
+			terminee = false
+			begin
+				raise ("Grille non terminée") if (!grille.grilleFinie)
+				score = grilleDb.tempsMax + (3 * (grilleDb.tempsMoyen - tempsReel)) - nbAides + 500 - (3 * (7 - idDifficulte))
+				terminee = true
+				#puts "score: #{score}, scoreMax: #{grilleDb.scoreMax}, tempsMoyen: #{grilleDb.tempsMoyen}"
+			rescue # timer == 0?
+#				puts "Timer: #{tempsReel}"
+				score = 0
+			end
+#			score = grilleDb.scoreMax * grilleDb.tempsMoyen
+			joue.update(score: score, grilleSer: grilleDb.grilleSolution, terminee: terminee)# if (joue.score < score)
+		rescue
+			puts "changeScore ==> La grille d'id #{grilleDb.id} du joueur d'id #{idJoueur} n'existe pas dans la base. Score: #{score}"
+		end
+	end
+
+	# Permet de savoir si une grille a été terminée par le joueur
+	#
+	# === Paramètres
+	#
+	# * +idJoueur+ => L'Id du Joueur dont on veut savoir s'il a terminé la grille
+	# * +grilleDb+ => L'objet grille dont on veut savoir si elle a été terminée
+	#
+	# === Retour
+	#
+	# Si le joueur et la grille existent, renvoie l'état de la grille (true ou false), nil si la grille n'existe pas pour le joueur
+	#
+	def GestionBase.grilleTerminee?(idJoueur, grilleDb)
+		terminee = nil
+		begin
+			raise ("raise grilleTerminee?") if ((joue=Joue.where([ "joueurs_id = ? AND grille_dbs_id = ?", idJoueur, grilleDb.id ])).count != 1)
+			terminee = joue.first.terminee
+		rescue
+			puts "grilleTerminee? ==> La grille d'id #{grilleDb.id} du joueur d'id #{idJoueur} n'existe pas dans la base."
+		ensure
+			return terminee
+		end
+	end
+end

data/bin/db/GrilleDb.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+
+require_relative "../src/Grille"
+# Classe GrilleDb de la base de données
+class GrilleDb < ActiveRecord::Base
+	has_many :joueurs, through: :joue
+	belongs_to :difficulte
+	belongs_to :mode
+
+#	serialize :grilleSolution
+
+	def to_s
+		"<GrilleDb> difficulte : #{difficultes_id}, mode : #{modes_id}"
+	end
+end

data/bin/db/Joue.rb

@@ -0,0 +1,10 @@
+require 'active_record'
+# Classe Joue de la base de données
+class Joue < ActiveRecord::Base
+	belongs_to :joueur
+	belongs_to :grille_db
+
+	def to_s
+		"<Joue> Id du joueur : #{joueurs_id}, Id de la grille : #{grille_dbs_id}, score : #{score}"
+	end
+end

data/bin/db/Joueur.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+# Classe Joueur de la base de données
+class Joueur < ActiveRecord::Base
+	has_many :grille_dbs, through: :joue
+
+	def to_s
+		"<Joueur> pseudo : '#{pseudo}'"
+	end
+end

data/bin/db/Migration.rb

@@ -0,0 +1,70 @@
+require 'active_record'
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: 'base.sqlite')
+
+# Initialisation et création des tables
+class Migration < ActiveRecord::Migration[4.2]
+	def change
+		if ActiveRecord::Base.connection.table_exists?(:joueurs)
+			drop_table :joueurs
+		end
+	
+		if ActiveRecord::Base.connection.table_exists?(:grille_dbs)
+			drop_table :grille_dbs
+		end
+	
+		if ActiveRecord::Base.connection.table_exists?(:difficultes)	
+			drop_table :difficultes
+		end
+
+		if ActiveRecord::Base.connection.table_exists?(:modes)
+		
+			drop_table :modes
+		end
+
+		if ActiveRecord::Base.connection.table_exists?(:joues)
+		
+			drop_table :joues
+		end
+
+		if ActiveRecord::Base.connection.table_exists?(:phrases_aventures)
+		
+			drop_table :phrases_aventures
+		end
+		
+		create_table :joueurs do |t|
+			t.string :pseudo
+		end
+		
+		create_table :difficultes do |t|
+			t.string :niveau
+		end
+
+		create_table :modes do |t|
+			t.string :mode_jeu
+		end
+
+		create_table :grille_dbs do |t|
+			t.belongs_to :difficultes
+			t.belongs_to :modes
+			t.integer :tempsMoyen
+			t.integer :tempsMax
+			t.integer :scoreMax
+			t.text :grilleSolution
+		end
+
+		create_table :joues do |t|
+			t.belongs_to :joueurs
+			t.belongs_to :grille_dbs
+			t.text :grilleSer
+			t.integer :score
+			t.boolean :terminee
+		end
+
+		create_table :phrases_aventures do |t|
+			t.string :texteBot
+			t.integer :idZoneScore
+		end
+	end
+end
+
+#Migration.migrate(:up)

data/bin/db/Mode.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+# Classe Mode de la base de données
+class Mode < ActiveRecord::Base
+	has_many :grille_dbs
+
+	def to_s
+		"<Mode> mode : '#{mode_jeu}'"
+	end
+end

data/bin/db/PhrasesAventure.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+# Classe PhrasesAventure de la base de données
+class PhrasesAventure < ActiveRecord::Base
+end

data/bin/db/TestBase.rb

@@ -0,0 +1,144 @@
+#Test de base de données
+require "rubygems"
+require "active_record"
+require_relative "Migration"
+require_relative "Joue"
+require_relative "Joueur"
+require_relative "GrilleDb"
+require_relative "Difficulte"
+require_relative "Mode"
+require_relative "PhrasesAventure"
+require_relative "GestionBase"
+require_relative "../src/SerGrille"
+
+class TestBase
+	def TestBase.genererBase
+		# Réinitialise la base
+		Migration.migrate(:up)
+
+		fichiers = ["Facile", "Moyen", "Difficile"]
+
+#		Difficulte.create( :niveau => "Facile")
+#		Difficulte.create( :niveau => "Moyen")
+#		Difficulte.create( :niveau => "Difficile")
+		Mode.create( :mode_jeu => "Entrainement")
+		Mode.create( :mode_jeu => "Classe")
+		Mode.create( :mode_jeu => "Aventure")
+		
+#		unJoueur = GestionBase.ajouterJoueur("corentin")
+#		unJoueur2 = GestionBase.ajouterJoueur("alexis")
+		
+		# Ajoute toutes les grilles de différentes difficultés à la base
+		fichiers.each do |difficulte|
+			Difficulte.create( :niveau => difficulte )
+			SerGrille.transformeSerial2(difficulte)
+			tabGrille = SerGrille.deserialiseVide(difficulte)
+			idDifficulte = Difficulte.find_by_niveau(difficulte).id
+			puts "difficulté: #{idDifficulte}"
+			idMode = 1
+			puts "nb grilles: #{tabGrille.length}"
+#puts tabGrille
+			tabGrille.each do |grille|
+#puts "idMode: #{idMode}"
+#				puts "Grille: #{grille}, tabLien: "
+				x = grille.tabLien.length + (idDifficulte / 2.0) - 1
+				tempsMoyen = 3.6 * x * x - 34 * x + 120
+				tempsMax = 3 * tempsMoyen
+				scoreMax = tempsMax + 500 - (3 * (7 - idDifficulte))
+#				puts YAML.dump(grille)
+				GrilleDb.create(:grilleSolution => YAML.dump(grille), :difficultes_id => idDifficulte, :modes_id => idMode, :scoreMax => scoreMax, :tempsMoyen => tempsMoyen, :tempsMax => tempsMax)
+				idMode = (idMode % 3) + 1
+			end
+
+		end
+		TestBase.updateScore
+		#grille=GrilleDb.create(:grilleSolution => "1__5HHH", :niveau =>1, :mode_jeu => 3)
+		#GrilleDb.create(:grilleSolution => "1__5HHH", :niveau =>2, :mode_jeu => 3)
+		#GrilleDb.create(:grilleSolution => "1__5HHH", :niveau =>3, :mode_jeu => 3)
+		
+		#grille4=GrilleDb.create(:grilleSolution => "1__5HHH", :niveau_id =>3, :mode_jeu => 2)
+	end
+
+	def TestBase.test2
+#		grille1 = GestionBase.recupGrilles(1).first
+		# Joue.create( :joueurs_id => 1, :grille_dbs_id => 1,:grilleSer => nil,  :score => 2521)
+#		Joue.create( :joueurs_id => 1, :grille_dbs_id => 4,:grilleSer => grille1,  :score => 3210)
+		# Joue.create( :joueurs_id => 1, :grille_dbs_id => 3,:grilleSer => "1__5___;",  :score => 1)
+		# Joue.create( :joueurs_id => 1, :grille_dbs_id => 2,:grilleSer => "1__5___;",  :score => 2)
+		
+		# puts(GestionBase.recupJoueur("corentin"))
+		# puts "|#{GestionBase.recupJoueur("robin") == nil}|"
+		# puts(GestionBase.recupDifficulte(grille.id))
+		# puts(GestionBase.recupMode(grille4.id))
+		# puts(GestionBase.recupScoreTotal(1))
+		# puts(GestionBase.recupNbGrillesJouees(1))
+		# puts "Joueur 4 nb: #{GestionBase.recupNbGrillesJouees(4) == nil}"
+		idJoueur = 2
+		idDifficulte = 1
+		idMode = 1
+		GestionBase.recupGrilles(idJoueur, idDifficulte, idMode, 0, 12).each do |grilleDb|
+#puts "#{grilleDb}"
+#puts "#{grilleDb.grilleSolution}"
+			grille = YAML.load(grilleDb.grilleSolution)
+#puts "#{grille}"
+#			grille.clicTriangle(grille.tabCase[0], 1)
+			puts "ID: #{grilleDb.id}, Hauteur: #{grille.hauteur}, largeur: #{grille.largeur}, classe: #{grille.class}, scoreMax: #{grilleDb.scoreMax}, tempsMoyen: #{grilleDb.tempsMoyen}"
+#			puts "Solution: Hauteur: #{grille.grilleRes.hauteur}, largeur: #{grille.grilleRes.largeur}, classe: #{grille.grilleRes.class}"
+#puts "avant grilleDb ser: #{YAML.dump(grille).largeur}"
+			grilleDb.grilleSolution = YAML.dump(grille)
+#puts "grilleDb ser: #{grilleDb.grilleSolution.largeur}"
+			GestionBase.changerScore(idJoueur, grilleDb, 200)
+
+			puts "Score de la grille #{grilleDb.id}: #{GestionBase.recupScore(idJoueur, grilleDb)}"
+		end
+
+		puts GestionBase.recupJoueurAll
+		
+		puts "Score total de joueur 2 difficulté facile: #{GestionBase.recupScoreTotal(idJoueur, 1)}"
+		# puts "Grilles: "
+		# puts GestionBase.recupGrilles(1)
+		# puts "Nil?"
+		# puts "|#{GestionBase.recupGrilles(2) == nil}|"
+		# puts "|#{GestionBase.recupGrilles(3) == nil}|"
+		# puts (GestionBase.changeScore(1, 1, 50))
+		# puts(GestionBase.recupScoreTotal(1))
+		# puts (GestionBase.changeScore(2, 1, 650))
+		#tab=Joue.where([ "joueurs_id = ?", 1 ]).select {|joue| GestionBase.recupMode(GrilleDb.find(joue.grille_dbs_id).id)}# == "Classe"}
+		#puts "Tableau"
+		#puts tab
+		#puts "Somme"
+		#score = tab.select{ |joue| GestionBase.recupMode(GrilleDb.find(joue.grille_dbs_id).id).mode_jeu == "Classe"}
+		#p score
+		#puts score.inject(0) { |score, joue| score += joue.score }
+	end
+
+	def TestBase.updateScore
+                fichiers = ["Facile", "Moyen", "Difficile"]
+
+		puts "Attribution des scores maximum et temps moyen de résolution..."
+
+		GrilleDb.all.each do |grilleDb|
+                        idDifficulte = grilleDb.difficultes_id
+			grille = YAML.load(grilleDb.grilleSolution)
+#puts tabGrille
+#puts "idMode: #{idMode}"
+#                               puts "Grille: #{grille}, tabLien: "
+       			x = grille.hauteur + (idDifficulte / 2.0) - 1
+			tempsMoyen = 3.6 * x * x - 34 * x + 120
+			tempsMax = 3 * tempsMoyen
+			scoreMax = tempsMax + 500 - (3 * (7 - idDifficulte))
+			#puts "x: #{x}, scoreMax: #{scoreMax}, tempsMoyen: #{tempsMoyen}"
+			grilleDb.update(scoreMax: scoreMax, tempsMoyen: tempsMoyen, tempsMax: tempsMax)
+		end
+	end
+
+	def TestBase.reinitialiser
+		Joue.delete_all
+	end
+
+end
+
+TestBase.genererBase
+#TestBase.updateScore
+#TestBase.reinitialiser
+#puts GestionBase.recupGrilleAleatoire(2, 1, 2)

data/bin/hashi

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.expand_path(File.dirname(__FILE__)) + "/src") do
+    require_relative "src/Hashi"
+end