Class: Grille

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/Hashiparmentier/Core/Grille.rb

Overview

Auteur

Brabant Mano, Renoult Florent

Version

0.1

Date

09/04/2020

Cette classe représente une grille de jeu avec les cases, la pile d’action, les hypoyhèses, etc

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(chaine) ⇒ Grille

:nodoc:



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 89

def initialize(chaine)
  #puts "chaine", chaine

    i = -1
    j = -1

    chaine.each_line do |l|
      if(l.start_with?("#T"))
        t = l.split(' ')
        @tailleX = t[1].to_i()
        @tailleY = t[2].to_i()
        @mat = Array.new(@tailleX) { Array.new(@tailleY) }
        @matSolution = Array.new(@tailleX) { Array.new(@tailleY) }
      elsif(l.start_with?("#D"))
        d = l.split(' ')
        @difficulte = d[1].to_i()
      else
        i += 1
        j = -1
        l.split(' ') do |c|
          #print c
          j += 1
          if(c =~ /[1-8]/)
            @mat[i][j] = Ile.creer(i, j, c.ord() - '0'.ord(), self)
            @matSolution[i][j] = Ile.creer(i, j, c.ord() - '0'.ord(), self)
          elsif(c == '|')
            @matSolution[i][j] = Pont.construit(i, j, self, Pont::VERTICAL, 1)
            @mat[i][j] = Pont.creer(i, j, self)
          elsif(c == 'H')
            @matSolution[i][j] = Pont.construit(i, j, self, Pont::VERTICAL, 2)
            @mat[i][j] = Pont.creer(i, j, self)
          elsif(c == '-')
            @matSolution[i][j] = Pont.construit(i, j, self, Pont::HORIZONTAL, 1)
            @mat[i][j] = Pont.creer(i, j, self)
          elsif(c == '=')
            @matSolution[i][j] = Pont.construit(i, j, self, Pont::HORIZONTAL, 2)
            @mat[i][j] = Pont.creer(i, j, self)
          elsif(c == 'N')
            @matSolution[i][j] = Pont.creer(i, j, self)
            @mat[i][j] = Pont.creer(i, j, self)
          end
        end
      end
    end
    recommencer()
end

Instance Attribute Details

#actions ⇒ Object (readonly)

Returns the value of attribute actions.



32
33
34
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 32

def actions
  @actions
end

#couleurs ⇒ Object (readonly)

Returns the value of attribute couleurs.



44
45
46
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 44

def couleurs
  @couleurs
end

#difficulte ⇒ Object (readonly)

Returns the value of attribute difficulte.



23
24
25
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 23

def difficulte
  @difficulte
end

#mat ⇒ Object (readonly)

Returns the value of attribute mat.



38
39
40
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 38

def mat
  @mat
end

#matSolution ⇒ Object (readonly)

Returns the value of attribute matSolution.



35
36
37
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 35

def matSolution
  @matSolution
end

#score ⇒ Object

Returns the value of attribute score.



41
42
43
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 41

def score
  @score
end

#tailleX ⇒ Object (readonly)

Returns the value of attribute tailleX.



26
27
28
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 26

def tailleX
  @tailleX
end

#tailleY ⇒ Object (readonly)

Returns the value of attribute tailleY.



29
30
31
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 29

def tailleY
  @tailleY
end

Class Method Details

.chargerGrilles(dossier) ⇒ Object

Cette méthode permet de retourner toutes les grilles d’un dossier

param

  • dossier Le dossier où on va chercher les grilles



53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 53

def Grille.chargerGrilles(dossier)

  ret = Array.new()
  Dir.each_child(dossier) do |fichier|
    text = File.open(dossier + "/" + fichier).read
    text.gsub!(/\r\n/, "\n");
    ret.push(Grille.creer(text))
  end
  return ret

end

.creer(chaine) ⇒ Object

Ce constructeur permet de créer une nouvelle grille

param

  • chaine La chaine génératrice

Le format de la chaine est

  • “#T tailleGrilleX tailleGrilleY”

  • “#D difficulteGrille”

  • Ensemble de caractères séparés par des espaces pour coder la grille complète

Les caractères spéciaux sont

  • [1-8] Correspont à une ile avec le même nombre de liens à faire

  • N Correspont à une case vide

  • - Correspont à un pont horizontal simple

  • = Correspont à un pont horizontal double

  • | Correspont à un pont vertical simple

  • H Correspont à un pont vertical double



83
84
85
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 83

def Grille.creer(chaine)
    new(chaine)
end

Instance Method Details

#addAction(ile1, ile2, methode) ⇒ Object

Cette méthode permet d’ajouter une action à la pile d’action

param

  • ile1 La premère ile

  • ile2 La deuxième ile

  • methode La méthode utilisé (:createPont ou :supprimePont)



475
476
477
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 475

def addAction(ile1, ile2, methode)
  @actions.empiler(Action.creer(ile1, ile2, methode))
end

#afficheSolution ⇒ Object

Cette méthode permet d’afficher les case de la grille solution



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 157

def afficheSolution()
  print "\t"
  for colonne in (0..tailleX-1)
    print colonne.to_s() + " "
  end
  print "\n"
  ligne = -1
  @matSolution.each do |i|
    print (ligne+=1).to_s() + " :\t"
    i.each do |j|
      print j.to_s() + " "
    end
    print "\n"
  end
end

#afficheToi ⇒ Object

Cette méthode permet d’afficher les case de la grille



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 139

def afficheToi()
  print "\t"
  for colonne in (0..tailleX-1)
    print colonne.to_s() + " "
  end
  print "\n"
  ligne = -1
  @mat.each do |i|
    print (ligne+=1).to_s() + " :\t"
    i.each do |j|
      print j.to_s() + " "
    end
    print "\n"
  end
end

#chercherVoisins(pont, direction) ⇒ Object

Cette méthode permet de créer un pont entre la dernière ile et une autre ile qui passe par un pont donné

param

  • pont La case pont par lequel doit passer le pont entre les deux iles

  • direction La direction dans laquelle est dirigé le pont



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 360

def chercherVoisins(pont, direction)

  if(direction == Pont::HORIZONTAL)

    i = pont.posX
    j = pont.posY
    while(!(ileDroite = getCase(i, j)).estIle?())
      j += 1
    end
    j = pont.posY
    while(!(ileGauche = getCase(i, j)).estIle?())
      j -= 1
    end

    temp = @dernierIle
    if(ileGauche == @dernierIle)
      ile2 = ileDroite
    elsif(ileDroite == @dernierIle)
      ile2 = ileGauche
    else
      ile2 = ileDroite
      setDernierIle(ileGauche)
    end
    createPont(ile2)
    setDernierIle(temp)

  elsif(direction == Pont::VERTICAL)

    i = pont.posX
    j = pont.posY
    while(!(ileBas = getCase(i, j)).estIle?())
      i += 1
    end
    i = pont.posX
    while(!(ileHaut = getCase(i, j)).estIle?())
      i -= 1
    end

    temp = @dernierIle
    if(ileBas == @dernierIle)
      ile2 = ileHaut
    elsif(ileHaut == @dernierIle)
      ile2 = ileBas
    else
      ile2 = ileHaut
      setDernierIle(ileBas)
    end
    createPont(ile2)
    setDernierIle(temp)
  end

end

#clickOnIle(ile) ⇒ Object

Méthode à appeler quand on appuie sur une ile

param

  • ile L’ile sur laquelle on a cliqué



302
303
304
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 302

def clickOnIle(ile)
  setDernierIle(ile)
end

#clickOnPont(pont) ⇒ Object

Méthode à appeler quand on appuie sur une ile

param

  • ile L’ile sur laquelle on a cliqué



311
312
313
314
315
316
317
318
319
320
321
322
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 311

def clickOnPont(pont)

  if(!@dernierIle.eql?(nil))
    if(pont.surbrillance())
      self.chercherVoisins(pont, pont.directionSurbrillance)
      @score -= 20
    else
      self.setDernierIle(nil)
    end
  end

end

#createPont(ile2, action = true) ⇒ Object

Cette méthode permet de créer un pont entre deux iles

param

  • ile2 La deuxième ile (La première est l’ile @dernierIle)

  • action Boolean, si true on ajoute l’action à la pile d’action, si false on ne l’ajoute pas

return

  • true Si le pont a été crée

  • false Sinon



596
597
598
599
600
601
602
603
604
605
606
607
608
609
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 596

def createPont(ile2, action = true)
  direction = getDirectionPont(@dernierIle, ile2)
  if(direction != Pont::NULLE)
    if(action)
      self.addAction(@dernierIle, ile2, :createPont)
    end
    ile2.ajouteNombrePont(@dernierIle)
    @dernierIle.ajouteNombrePont(ile2)
  end
  proc = Proc.new do |pont|
    pont.augmenteValeur(direction)
  end
  return parcoursPont(@dernierIle, ile2, proc)
end

#creerHypothese ⇒ Object

Cette méthode permet d’emmetre une nouvelle hypothèse (changer la couleur des ponts que l’on va modifier)



261
262
263
264
265
266
267
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 261

def creerHypothese()
  begin
    undoCouleurPont(@couleurs.undo())
  rescue => e
    puts e
  end
end

#effacePont ⇒ Object

Cette méthode permet d’enlever la surbrillance des pont disponibles de @dernierIle



755
756
757
758
759
760
761
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 755

def effacePont()
  for direction in Ile::DIRECTIONS
    if(@dernierIle.aVoisinDisponible?(direction))
      eteintPont(@dernierIle.getVoisin(direction))
    end
  end
end

#estVoisin?(ile1, ile2 = @dernierIle) ⇒ Boolean

Cette méthode permet de savoir si deux iles sont voisines

param

  • ile1 La première ile

  • ile2 La deuxième ile

return

  • true Si les iles sont voisines

  • false Sinon

Returns:

  • (Boolean) 


579
580
581
582
583
584
585
586
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 579

def estVoisin?(ile1, ile2 = @dernierIle)
  proc = Proc.new do |pont|
    if(pont.estIle?())
      return false
    end
  end
  return parcoursPont(ile1, ile2, proc)
end

#eteintPont(ile2) ⇒ Object

Cette méthode permet de retirer la surbrillance d’un pont entre deux iles

param

  • ile2 La deuxième ile (La première est l’ile @dernierIle)

return

  • true Si le pont n’est plus en surbrillance

  • false Sinon



657
658
659
660
661
662
663
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 657

def eteintPont(ile2)
  direction = getDirectionPont(@dernierIle, ile2)
  proc = Proc.new do |pont|
    pont.supprSurbrillance(direction)
  end
  return parcoursPont(@dernierIle, ile2, proc)
end

#fini? ⇒ Boolean

Cette méthode permet de savoir si la grille est fini (si tous les ponts on été placé comme dans la solution)

return

  • true Si la grille est fini

  • false Sinon

Returns:

  • (Boolean) 


178
179
180
181
182
183
184
185
186
187
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 178

def fini?()
  for i in (0..(@tailleX-1))
    for j in (0..(@tailleY-1))
      if(@mat[i][j] != @matSolution[i][j])
        return false
      end
    end
  end
  return true
end

#getCase(i, j) ⇒ Object

Cette méthode permet de recuperer une case de la grille

param

  • i La position en abscisse

  • j La position en ordonnée

return

  • La case à la position [i]



238
239
240
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 238

def getCase(i, j)
    return @mat[i][j]
end

#getCaseSolution(i, j) ⇒ Object

Cette méthode permet de recuperer une case de la grille solution

param

  • i La position en abscisse

  • j La position en ordonnée

return

  • La case à la position (i, j)



255
256
257
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 255

def getCaseSolution(i, j)
    return @matSolution[i][j]
end

#getDernierIle ⇒ Object

Cette méthode permet de recuperer la dernière ile séléctionnée

return

  • La dernière ile séléctionnée



739
740
741
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 739

def getDernierIle()
  return @dernierIle
end

#getDifference(ile1, ile2) ⇒ Object

Cette méthode permet de connaitre la direction et les positions des ponts qui pourrait relier deux iles

param

  • ile1 La première ile

  • ile2 La deuxième ile

return

  • direction : La direction du pont, retourne Pont::NULLE si les iles ne sont pas voisines

  • petitPos : La plus petit coordonnée du pont (en abscisse ou en ordonnée en fontion de la direction)

  • grandPos : La plus grande coordonnée du pont (en abscisse ou en ordonnée en fontion de la direction)



554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 554

def getDifference(ile1, ile2)

  direction = getDirectionPont(ile1, ile2)
  if(direction == Pont::HORIZONTAL)
    petitPos = [ile2.posY(), ile1.posY()].min() + 1
    grandPos = [ile2.posY(), ile1.posY()].max() - 1
  elsif(direction == Pont::VERTICAL) #alors pont vertical
    petitPos = [ile2.posX(), ile1.posX()].min() + 1
    grandPos = [ile2.posX(), ile1.posX()].max() - 1
  else
    petitPos = 0
    grandPos = 0
  end
  return direction, petitPos, grandPos

end

#getDirectionPont(ile1, ile2) ⇒ Object

Cette méthode permet de connaitre la direction du pont qui pourrait relier deux iles

param

  • ile1 La première ile

  • ile2 La deuxième ile

return

  • La direction du pont Si les deux iles sont voisines

  • Pont::NULLE Sinon



535
536
537
538
539
540
541
542
543
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 535

def getDirectionPont(ile1, ile2)
  if(ile1.posX() == ile2.posX()) #alors pont horizontal
    return Pont::HORIZONTAL
  elsif(ile1.posY() == ile2.posY()) #alors pont vertical
    return Pont::VERTICAL
  else
    return Pont::NULLE
  end
end

#getGrille ⇒ Object

Cette méthode permet de recuperer la matrice de cases



206
207
208
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 206

def getGrille()
    return @mat
end

#getMeilleurScore(compte) ⇒ Object 



800
801
802
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 800

def getMeilleurScore(compte)
  Sauvegarde.recuperer(compte, self).getScore()
end

#memeSolution(grille) ⇒ Object

Cette méthode permet de savoir si la grille à une solution identique à une autre grille

param

  • grille L’autre grille

return

  • true Si les grilles ont la même solution

  • false Sinon



217
218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 217

def memeSolution(grille)

  return false if(@tailleX != grille.tailleX || @tailleY != grille.tailleY)
  for i in (0..(@tailleX-1))
    for j in (0..(@tailleY-1))
      if(self.getCaseSolution(i, j) != grille.getCaseSolution(i, j))
        return false
      end
    end
  end
  return true

end

#montrePont ⇒ Object

Cette méthode permet de mettre en surbrillance les pont disponibles de @dernierIle



745
746
747
748
749
750
751
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 745

def montrePont()
  for direction in Ile::DIRECTIONS
    if(@dernierIle.aVoisinDisponible?(direction))
      surbrillancePont(@dernierIle.getVoisin(direction))
    end
  end
end

#parcoursPont(ile1, ile2, proc) ⇒ Object

Cette méthode permet de parcourir les ponts entre deux ile avec un bloc

param

  • ile1 La première ile

  • ile2 La deuxième ile

  • proc Le bloc

return

  • false Si les deux iles ne sont pas voisines

  • La valeur de retour du bloc sinon



689
690
691
692
693
694
695
696
697
698
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 689

def parcoursPont(ile1, ile2, proc)
  direction, petitPos, grandPos = getDifference(ile1, ile2)
  if(direction == Pont::HORIZONTAL)
    return parcoursPontHorizontal(petitPos, grandPos, proc, ile1.posX())
  elsif(direction == Pont::VERTICAL)
    return parcoursPontVertical(petitPos, grandPos, proc, ile1.posY())
  else
    return false
  end
end

#recommencer ⇒ Object

Cette méthode permet de remmetre à zéro la grille



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 326

def recommencer()

  @actions = UndoRedo.creer()

  setDernierIle(nil)
  @score = 500 * @tailleX


  @couleurs = UndoRedo.creer()

  @couleurs.empiler(Couleur::JAUNE)
  @couleurs.empiler(Couleur::CYAN)
  @couleurs.empiler(Couleur::MAGENTA)
  @couleurs.empiler(Couleur::VERT)
  @couleurs.empiler(Couleur::BLEU)
  @couleurs.empiler(Couleur::NOIR)


  undoCouleurPont(@couleurs.undo())

  @mat.each do |ligne|
    ligne.each do |c|
      c.raz()
    end
  end

end

#redo ⇒ Object

Cette méthode permet de refaire la dernière action annulé par le undo



498
499
500
501
502
503
504
505
506
507
508
509
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 498

def redo()
  if(!@actions.empty?())
    begin
      action = @actions.redo()
      self.setDernierIle(action.ile1())
      #Invoque la méthode utilisé sans l'ajouter à la undoRedo d'action
      self.send(action.methode(), action.ile2(), false)
    rescue => e
      puts e.message()
    end
  end
end

#redoCouleurPont(couleur) ⇒ Object

Cette méthode permet d’appeler la méthode Case#redoCouleurPont de chaque case de la grille

param

  • couleur La couleur à passer au la méthode Case#redoCouleurPont



417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 417

def redoCouleurPont(couleur)

  @mat.each do |ligne|
    ligne.each do |c|
      if(c.estPont?())
        c.redoCouleurPont(couleur)
      end
    end
  end

end

#redoSupprCouleurPont(couleur) ⇒ Object

Cette méthode permet d’appeler la méthode Case#redoCouleurPont de chaque case de la grille et de supprimer les ponts de la dernière hypothèse

param

  • couleur La couleur à passer a la méthode Case#redoCouleurPont



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 433

def redoSupprCouleurPont(couleur)

  @mat.each do |ligne|
    ligne.each do |c|
      if(c.estPont?())
        if(c.couleurPont == c.couleurPontCourante)
          while(c.valeur != 0)
            #print "Valeur", c.valeur, c.direction, "\n"
            chercherVoisins(c, c.direction)
          end
        end
        c.redoCouleurPont(couleur)
      end
    end
  end

end

#routeDisponible?(ile1, ile2) ⇒ Boolean

Cette méthode permet de savoir si la route entre deux pont est disponible (iles voisines et pas séparées par un pont)

param

  • ile1 La première ile

  • ile2 La deuxième ile

Returns:

  • (Boolean) 


670
671
672
673
674
675
676
677
678
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 670

def routeDisponible?(ile1, ile2)
  direction = getDirectionPont(ile1, ile2)
  proc = Proc.new do |pont|
    if(pont.direction != Pont::NULLE && pont.direction != direction)
      return false
    end
  end
  return parcoursPont(ile1, ile2, proc)
end

#sauvegarder(compte) ⇒ Object

Cette méthode permet de sauvegarder la grille dans la base de donnée



788
789
790
791
792
793
794
795
796
797
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 788

def sauvegarder(compte)

  save = Sauvegarde.recuperer(compte, self)
  save.setGrille(self)
  if(fini?())
    save.setScore([save.getScore(), @score].max) if self.fini?()
  end
  save.sauvegarder()

end

#setDernierIle(ile1) ⇒ Object

Cette méthode permet de modifier la dernière ile séléctionnée

param

  • ile1 La nouvelle ile



722
723
724
725
726
727
728
729
730
731
732
733
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 722

def setDernierIle(ile1)
  if(!@dernierIle.eql?(nil))
    effacePont()
    @dernierIle.dernier = false
  end
  @dernierIle = ile1
  if(!@dernierIle.eql?(nil))
    montrePont()
    #afficheToi()
    @dernierIle.dernier = true
  end
end

#setTempsFin(minutes, secondes) ⇒ Object

met a jour le temps que l’utilisateur à mis à finir la map



243
244
245
246
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 243

def setTempsFin(minutes,secondes)
  @minutesFin = minutes
  @secondesFin =secondes
end

#sortLimite?(posX, posY) ⇒ Boolean

Cette méthode permet de savoir si les coordonnées passés sont comprises dans la grille

param

  • posX La position en abscisse

  • posY La position en ordonnée

return

  • true Si les coordonnées sont valides

  • false Sinon

Returns:

  • (Boolean) 


197
198
199
200
201
202
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 197

def sortLimite?(posX, posY)
  if(posX < 0 || posY < 0 || posX >= @tailleX || posY >= @tailleY)
    return true
  end
  return false
end

#supprimeHypothese ⇒ Object

Cette méthode permet de supprimer la dernière hypothèse (supprime tous les ponts de la dernière couleur)

param

  • jeu Le jeu dont-on va modifier la grille



285
286
287
288
289
290
291
292
293
294
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 285

def supprimeHypothese()
  begin
    @couleurs.redo()
    @couleurs.redo()
    redoSupprCouleurPont(@couleurs.undo())
    setDernierIle(@dernierIle)
  rescue => e
    puts e.message()
  end
end

#supprimePont(ile2, action = true) ⇒ Object

Cette méthode permet de supprimer un pont entre deux iles

param

  • ile2 La deuxième ile (La première est l’ile @dernierIle)

  • action Boolean, si true on ajoute l’action à la pile d’action, si false on ne l’ajoute pas

return

  • true Si le pont a été supprimer

  • false Sinon



619
620
621
622
623
624
625
626
627
628
629
630
631
632
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 619

def supprimePont(ile2, action = true)
  direction = getDirectionPont(@dernierIle, ile2)
  if(direction != Pont::NULLE)
    if(action)
      self.addAction(@dernierIle, ile2, :supprimePont)
    end
    ile2.retireNombrePont(@dernierIle)
    @dernierIle.retireNombrePont(ile2)
  end
  proc = Proc.new do |pont|
    pont.diminueValeur(direction)
  end
  return parcoursPont(@dernierIle, ile2, proc)
end

#surbrillancePont(ile2) ⇒ Object

Cette méthode permet de mettre en surbrillance un pont entre deux iles

param

  • ile2 La deuxième ile (La première est l’ile @dernierIle)

return

  • true Si le pont a été mis en surbrillance

  • false Sinon



642
643
644
645
646
647
648
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 642

def surbrillancePont(ile2)
  direction = getDirectionPont(@dernierIle, ile2)
  proc = Proc.new do |pont|
    pont.metSurbrillance(direction)
  end
  return parcoursPont(@dernierIle, ile2, proc)
end

#undo ⇒ Object

Cette méthode permet d’annuler la dernière action éfféctué par l’utilisateur



481
482
483
484
485
486
487
488
489
490
491
492
493
494
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 481

def undo()
  if(!@actions.empty?())
    begin
      tempIle = self.getDernierIle()
      action = @actions.undo()
      self.setDernierIle(action.ile1())
      #Invoque l'inverse de la méthode utilisé sans l'ajouter à la undoRedo d'action
      self.send(homologue(action.methode()), action.ile2(), false)
      self.setDernierIle(tempIle)
    rescue => e
      puts e.message()
    end
  end
end

#undoCouleurPont(couleur) ⇒ Object

Cette méthode permet d’appeler la méthode Case#undoCouleurPont de chaque case de la grille

param

  • couleur La couleur à passer au la méthode Case#undoCouleurPont



456
457
458
459
460
461
462
463
464
465
466
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 456

def undoCouleurPont(couleur)

  @mat.each do |ligne|
    ligne.each do |c|
      if(c.estPont?())
        c.undoCouleurPont(couleur)
      end
    end
  end

end

#valeurPont(ile1, ile2) ⇒ Object

Cette méthode permet de retourner la valeur du pont entre deux ile

return

  • La valeur du pont entre deux iles Si elles sont rélié

  • 0 Sinon



768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 768

def valeurPont(ile1, ile2)
  direction, petitPos, grandPos = getDifference(ile1, ile2)
  if(direction == Pont::HORIZONTAL)
    pont = @mat[ile1.posX()][petitPos]
  elsif(direction == Pont::VERTICAL)
    pont = @mat[petitPos][ile1.posY()]
  elsif(direction == Pont::NULLE)
    return 0
  end

  if(pont.direction == direction)
    return pont.valeur
  end

  return 0

end

#valideHypothese ⇒ Object

Cette méthode permet de valider la dernière hypothèse (prendre tous les ponts de la dernière couleur et la changer à l’avant dernière)



271
272
273
274
275
276
277
278
279
 
# File 'lib/Hashiparmentier/Core/Grille.rb', line 271

def valideHypothese()
  begin
    @couleurs.redo()
    @couleurs.redo()
    redoCouleurPont(@couleurs.undo())
  rescue => e
    puts e.message()
  end
end