hashi-ruby 1.0.0

data/bin/src/ui/AfficheurGrille.rb

@@ -0,0 +1,385 @@
+require "gtk3"
+
+# Widget Gtk permettant d'afficher une grille
+class AfficheurGrille < Gtk::DrawingArea
+
+    # Deux systèmes de positions sont utilisés dans le code:
+    #
+    # => Les positions "virtuelles" (vX, vY) qui correspondent aux coordonnées
+    # 	 des cases (par exemple 0,0 pour la case en haut à gauche)
+    #
+    # => Les positions "réelles" (x, y) qui correspondent aux positions sur
+    #    la fenêtre (en pixels) et qui changent en fonction de la résolution de l'écran
+    #
+    # Les méthodes getX, getY, getVX, getVY sont là pour passer entre ces deux systèmes
+
+    # @grille => Grille à afficher
+    # @vWidth => Largeur virtuelle de la grille
+    # @vHeight => Hauteur virtuelle de la grille
+    # @ratio => Ratio de la résolution actuelle
+    # @vX => Nombre de pixel par coordonnée réelle horizontale
+    # @vY => Nombre de pixel par coordonnée réelle verticale
+    # @surbrillance => Liens à mettre en surbrillance
+
+    attr_accessor :cercleAide
+
+    private
+
+    # Constructeur
+    #
+    # === Parametres
+    #
+    # * +grille+ => Grille à afficher
+    # * +playable+ => Réagit au clics de souris ou non
+    # * +jeu+ => L'afficheur de jeu si la grille est utilisé en tant que jeu
+    def initialize(grille, playable, jeu)
+        super()
+        @playable = playable
+        @jeu = jeu
+        @surbrillance = []
+        @grille = grille
+        @vWidth = grille.largeur
+        @vHeight = grille.hauteur
+        @ratio = 1.0 * @vWidth / @vHeight
+        @cercleAide = nil
+        self.signal_connect("draw") { |widget, cr| draw(cr) }
+        self.signal_connect("button-press-event") { |widget, event| mouseClick(event); self.queue_draw() } if @playable
+        self.events = :all_events_mask
+    end
+
+    # Passage en état jouable
+    def setPlayable()
+        if !@playable
+            self.signal_connect("button-press-event") { |widget, event| mouseClick(event); self.queue_draw() }
+            @playable = true
+        end
+    end
+
+    # Largeur écran en pixels
+    #
+    # === Retour
+    #
+    # Retourne le nombre de pixels en largeur affichés à l'écran
+    def width()
+        return self.allocation.width()
+    end
+
+    # Hauteur écran en pixels
+    #
+    # === Retour
+    #
+    # Retourne le nombre de pixels en hauteur affichés à l'écran
+    def height()
+        return self.allocation.height()
+    end
+
+    # Conversion vX en x
+    #
+    # === Paramètres
+    #
+    # * +vX+ => Position virtuelle en x à convertir
+    #
+    # === Retour
+    #
+    # Retourne la position réelle en x correspondante
+    def getX(vX)
+        if width / @ratio > height
+            return vX * @vY + (width - height * @ratio) / 2 + @vY/2
+        else
+            return vX * @vX + @vX/2
+        end
+    end
+
+    # Conversion vY en y
+    #
+    # === Paramètres
+    #
+    # * +vY+ => Position virtuelle en y à convertir
+    #
+    # === Retour
+    #
+    # Retourne la position réelle en y correspondante
+    def getY(vY)
+        if height * @ratio > width
+            return vY * @vX + (height - width / @ratio) / 2 + @vX/2
+        else
+            return vY * @vY + @vY/2
+        end
+    end
+
+    # Conversion x en vX
+    #
+    # === Paramètres
+    #
+    # * +x+ => Position réelle en x à convertir
+    #
+    # === Retour
+    #
+    # Retourne la position virtuelle en x correspondante
+    def getVX(x)
+        if width / @ratio > height
+            return (x - (width - height * @ratio) / 2 - @vY/2) / @vY
+        else
+            return (x - @vX/2) / @vX
+        end
+    end
+
+    # Conversion y en vY
+    #
+    # === Paramètres
+    #
+    # * +y+ => Position réelle en y à convertir
+    #
+    # === Retour
+    #
+    # Retourne la position virtuelle en y correspondante
+    def getVY(y)
+        if height * @ratio > width
+            return (y - (height - width / @ratio) / 2 - @vX/2) / @vX
+        else
+            return (y - @vY/2) / @vY
+        end
+    end
+
+    # Retourne une valeur dimensionnée par la taille de l'affichage
+    # (utile par exemple pour modifier la taille des cercles
+    # en fonction de la taille de la fenêtre)
+    #
+    # === Paramètres
+    #
+    # * +s+ => Valeur à dimensionner
+    #
+    # === Retour
+    #
+    # Retourne la valeur dimensionnée
+    def scale(s)
+        if width / @ratio > height
+            return s * @vY
+        else
+            return s * @vX
+        end
+    end
+
+    # Dessin de la grille
+    #
+    # === Paramètres
+    #
+    # * +cr+ => Contexte sur lequel dessiner
+    def draw(cr)
+        @vX = 1.0 * width / @vWidth
+        @vY = 1.0 * height / @vHeight
+        cr.select_font_face("Arial", Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL)
+        cr.set_font_size(scale(0.5))
+        t = []
+        @grille.tabLien.each() do |l|
+            if !t.include?(l)
+                l2 = @grille.lienSimilaire(l)
+                if l2
+                    drawLien(cr, l, -0.075)
+                    drawLien(cr, l2, 0.075)
+                    t.append(l2)
+                else
+                    drawLien(cr, l, 0)
+                end
+            end
+        end
+        @grille.tabCase.each() { |c| drawCircle(cr, c) }
+    end
+
+    # Dessin d'un cercle
+    #
+    # === Paramètres
+    #
+    # * +cr+ => Contexte sur lequel dessiner
+    # * +c+ => Cercle à dessiner
+    def drawCircle(cr, c)
+        x = c.colonne()
+        y = c.ligne()
+        n = c.etiquetteCase()
+
+        cr.set_source_rgb(0.45, 0.45, 0.45)
+
+        #nord
+        if c.tabTriangle[0]
+            cr.move_to(getX(x), getY(y)-scale(0.45))
+            cr.line_to(getX(x) - scale(0.2), getY(y))
+            cr.line_to(getX(x) + scale(0.2), getY(y))
+            cr.close_path()
+            cr.fill()
+        end
+        #est
+        if c.tabTriangle[1]
+            cr.move_to(getX(x)+scale(0.45), getY(y))
+            cr.line_to(getX(x), getY(y)- scale(0.2))
+            cr.line_to(getX(x), getY(y)+ scale(0.2))
+            cr.close_path()
+            cr.fill()
+        end
+        #sud
+        if c.tabTriangle[2]
+            cr.move_to(getX(x), getY(y)+scale(0.45))
+            cr.line_to(getX(x) - scale(0.2), getY(y))
+            cr.line_to(getX(x) + scale(0.2), getY(y))
+            cr.close_path()
+            cr.fill()
+        end
+        #ouest
+        if c.tabTriangle[3]
+            cr.move_to(getX(x)-scale(0.45), getY(y))
+            cr.line_to(getX(x), getY(y)- scale(0.2))
+            cr.line_to(getX(x), getY(y)+ scale(0.2))
+            cr.close_path()
+            cr.fill()
+        end
+
+        # Affichage bordure cercle
+        saturee?(c) ? cr.set_source_rgb(0.5, 0.5, 0.5) : cr.set_source_rgb(0, 0, 0)
+        cr.set_source_rgb(0,1,0) if c == @cercleAide
+        cr.arc(getX(x), getY(y), scale(0.3), 0, 2*Math::PI)
+        cr.fill()
+        # Affichage partie balnche cercle
+        saturee?(c) ? cr.set_source_rgb(0.75, 0.75, 0.75) : cr.set_source_rgb(1, 1, 1)
+        cr.arc(getX(x), getY(y), scale(0.28), 0, 2*Math::PI)
+        cr.fill()
+        #Affichage numéro
+        saturee?(c) ? cr.set_source_rgb(0.5, 0.5, 0.5) : cr.set_source_rgb(0, 0, 0)
+        cr.set_source_rgb(0,1,0) if c == @cercleAide
+        cr.move_to(getX(x) - scale(0.14), getY(y) + scale(0.18))
+        cr.show_text(n.to_s())
+    end
+
+    def saturee?(c)
+        return true if c.nbLienCase(@grille.tabLien) >= c.etiquetteCase.to_i()
+        return false
+    end
+
+    # Dessin d'un lien
+    #
+    # === Paramètres
+    #
+    # * +cr+ => Contexte sur lequel dessiner
+    # * +l+ => Lien à dessiner
+    # * +offset+ => Décalage du lien
+    def drawLien(cr, l, offset)
+        x1 = l.case1.colonne()
+        y1 = l.case1.ligne()
+        x2 = l.case2.colonne()
+        y2 = l.case2.ligne()
+
+        epaisseur = 0.02
+
+        if l.hypothese
+            cr.set_source_rgb(0.2, 0.8, 0.2) # Couleur verte
+        else
+            cr.set_source_rgb(0, 0, 0)
+        end
+
+        if @surbrillance.include?(l)
+            cr.set_source_rgb(0.8,0.2,0.2)
+        end
+
+        if lienHorizontal(l)
+            cr.rectangle(getX(x1), getY(y1)-scale(epaisseur/2)+scale(offset), getX(x2)-getX(x1), scale(epaisseur))
+        else
+            cr.rectangle(getX(x1)-scale(epaisseur/2)+scale(offset), getY(y1), scale(epaisseur), getY(y2)-getY(y1))
+        end
+
+        cr.fill()
+    end
+
+    # Clic sur la souris
+    #
+    # === Paramètres
+    #
+    # * +event+ => Evenement Gtk contenant les informations sur le clic
+    def mouseClick(event)
+        #puts(event.x, event.y)
+        #puts(getVX(event.x), getVY(event.y))
+        @surbrillance = []
+        @grille.tabCase.each() do |c|
+            x = c.colonne
+            y = c.ligne
+
+            if (getVX(event.x) > x - 0.3) && (getVX(event.x) < x + 0.3) && (getVY(event.y) > y - 0.3) && (getVY(event.y) < y + 0.3)
+                @grille.clicCercle(c, @surbrillance)
+                @jeu.aJoue()
+                return
+            end
+
+            #haut
+            if c.tabTriangle[0] && (getVX(event.x) > x - 0.1) && (getVX(event.x) < x + 0.1) && (getVY(event.y) > y - 0.5) && (getVY(event.y) < y - 0.3)
+                @grille.clicTriangle(c,0)
+                @jeu.aJoue()
+                return
+            end
+
+            #bas
+            if c.tabTriangle[2] && (getVX(event.x) > x - 0.1) && (getVX(event.x) < x + 0.1) && (getVY(event.y) > y + 0.3) && (getVY(event.y) < y + 0.5)
+                @grille.clicTriangle(c,2)
+                @jeu.aJoue()
+                return
+            end
+
+            #gauche
+            if c.tabTriangle[3] && (getVX(event.x) > x - 0.5) && (getVX(event.x) < x - 0.3) && (getVY(event.y) > y - 0.1) && (getVY(event.y) < y + 0.1)
+                @grille.clicTriangle(c,3)
+                @jeu.aJoue()
+                return
+            end
+
+            #droite
+            if c.tabTriangle[1] && (getVX(event.x) > x + 0.3) && (getVX(event.x) < x + 0.5) && (getVY(event.y) > y - 0.1) && (getVY(event.y) < y + 0.1)
+                @grille.clicTriangle(c,1)
+                @jeu.aJoue()
+                return
+            end
+        end
+
+        @grille.tabLien.each() do |l|
+            if l.case1.colonne < l.case2.colonne
+                x1 = l.case1.colonne
+                x2 = l.case2.colonne
+            else
+                x1 = l.case2.colonne
+                x2 = l.case1.colonne
+            end
+
+            if l.case1.ligne < l.case2.ligne
+                y1 = l.case1.ligne
+                y2 = l.case2.ligne
+            else
+                y1 = l.case2.ligne
+                y2 = l.case1.ligne
+            end
+
+            marge = 0.2
+
+            if y1 == y2
+                if (getVX(event.x) > x1 + 0.4) && (getVX(event.x) < x2 - 0.4) && (getVY(event.y) > y1 - marge) && (getVY(event.y) < y1 + marge)
+                    @grille.clicLien(l)
+                    @jeu.aJoue()
+                    return
+                end
+            else
+                if (getVX(event.x) > x1 - marge) && (getVX(event.x) < x1 + marge) && (getVY(event.y) > y1 + 0.4) && (getVY(event.y) < y2 - 0.4)
+                    @grille.clicLien(l)
+                    @jeu.aJoue()
+                    return
+                end
+            end
+        end
+    end
+
+    # Test si lien horizontal
+    #
+    # === Paramètres
+    #
+    # * +l+ => Lien à tester
+    #
+    # === Retour
+    #
+    # Retourne vrai si le lien est horizontal, faux sinon
+    def lienHorizontal(l)
+        return l.case1.colonne != l.case2.colonne
+    end
+end

data/bin/src/ui/AfficheurJeu.rb

@@ -0,0 +1,209 @@
+require "gtk3"
+require_relative "AfficheurGrille"
+require_relative "Timer"
+require_relative "Didacticiel"
+
+# Widget Gtk permettant d'afficher un plateau de jeu
+class AfficheurJeu < Gtk::Paned
+
+    # @afficheurGrille => Widget afficheur grille
+    # @timer => Label du timer
+    # @annuler => Bouton annuler
+    # @refaire => Bouton refaire
+    # @hypothese => Bouton hypothèse
+    # @verif => Bouton vérification
+    # @aidePos => Bouton aide position
+    # @aideTech => Bouton aide technique
+    # @pause => Bouton pause
+    # @menu => Menu de droite
+
+    # Constructeur
+    #
+    # === Parametres
+    #
+    # * +grille+ => Grille à afficher
+    # * +fenetre+ => Fenetre principale
+    # * +type+ => "entrainemen", "classe", "aventure" 
+    def initialize(grille, fenetre, type)
+        super(Gtk::Orientation.new(0))
+        @paused = false
+        @type = type
+        @fenetre = fenetre
+
+        @grilleDb = grille
+        @grille = YAML.load(@grilleDb.grilleSolution)
+        @grille.nbAides ||= 0
+        @nbAides = @grille.nbAides
+        @afficheurGrille = AfficheurGrille.new(@grille, true, self)
+
+        @menu = Gtk::Box.new(Gtk::Orientation.new(1), 0)
+        @menu.spacing = 5
+        c = Gtk::Label.new("")
+        c.expand = true
+        @menu.add(c)
+        @boutonContinuer = Gtk::Button.new(:label => "Continuer")
+        @boutonContinuer.signal_connect("clicked") { |widget| self.remove(@menu); self.add1(@afficheurGrille); self.show_all(); @paused = false; @timer.reprendre() }
+        @boutonRegles = Gtk::Button.new(:label => "Didacticiel")
+        @boutonRegles.signal_connect("clicked") { |widget| @didacticiel = Didacticiel.new(); }
+        @boutonQuitter = Gtk::Button.new(:label => "Quitter")
+        @boutonQuitter.signal_connect("clicked") do |widget|
+            if @type == "classe"
+                d = Gtk::MessageDialog.new(:buttons => :ok_cancel)
+                d.text = "Votre progression sur cette grille sera effacée si vous quittez"
+                d.message_type = :question
+                r = d.run == :ok
+                d.destroy
+                fenetre.finJeu() if r
+            else
+                @grille.timer = @timer.secondes
+                @grille.nbAides = @nbAides
+                @grilleDb.grilleSolution = @grille.to_yaml()
+                GestionBase.changerScore(fenetre.joueur.id, @grilleDb, 0)
+                puts("Sauvegardé")
+                fenetre.finJeu()
+            end
+        end
+        @menu.add(@boutonContinuer)
+        @menu.add(@boutonRegles)
+        @menu.add(@boutonQuitter)
+
+        c = Gtk::Label.new("")
+        c.expand = true
+        @menu.add(c)
+
+        boxVerticale = Gtk::Box.new(Gtk::Orientation.new(1), 0)
+        @timer = Timer.new(@grille.timer)
+        @timer.margin_top = 15
+        boxVerticale.add(@timer)
+        
+        
+        boxHorizontale = Gtk::Box.new(Gtk::Orientation.new(0), 0)
+        boxHorizontale.margin_top = 15
+        @annuler = Gtk::Button.new(:label => "Annuler")
+        @annuler.hexpand = true
+        boxHorizontale.add(@annuler)
+        @annuler.signal_connect("clicked") { |widget| @grille.annuler(); @afficheurGrille.queue_draw() }
+
+        @refaire = Gtk::Button.new(:label => "Refaire")
+        @refaire.hexpand = true
+        boxHorizontale.add(@refaire)
+        @refaire.signal_connect("clicked") { |widget| @grille.refaire(); @afficheurGrille.queue_draw() }
+        boxVerticale.add(boxHorizontale)
+
+        @verif = Gtk::Button.new(:label => "Vérification")
+        boxVerticale.add(@verif)
+        @verif.signal_connect("clicked") do |widget|
+            r = @grille.verification();
+            @nbAides += 3*r;
+            @afficheurGrille.queue_draw()
+            d = Gtk::MessageDialog.new()
+            d.text = "Erreurs corrigées: #{r}"
+            d.message_type = :info
+            d.run
+            d.destroy
+        end
+
+        @hypothese = Gtk::Stack.new()
+        @boutonHypothese = Gtk::Button.new(:label => "Hypothèse")
+        @boutonHypothese.signal_connect("clicked") { |widget| @grille.commencerHypothese(); @hypothese.visible_child = @boxHypothese; @afficheurGrille.queue_draw() }
+        @hypothese.add(@boutonHypothese)
+
+        @boxHypothese = Gtk::Box.new(Gtk::Orientation.new(0), 0)
+        @boutonValiderHypothese = Gtk::Button.new(:label => "Valider")
+        @boutonValiderHypothese.signal_connect("clicked") { |widget| @grille.validerHypothese(); @hypothese.visible_child = @boutonHypothese; @afficheurGrille.queue_draw() }
+        @boutonValiderHypothese.hexpand = true
+        @boutonAnnulerHypothese = Gtk::Button.new(:label => "Annuler")
+        @boutonAnnulerHypothese.signal_connect("clicked") { |widget| @grille.annulerHypothese(); @hypothese.visible_child = @boutonHypothese; @afficheurGrille.queue_draw() }
+        @boutonAnnulerHypothese.hexpand = true
+
+        @boxHypothese.add(@boutonAnnulerHypothese)
+        @boxHypothese.add(@boutonValiderHypothese)
+        @hypothese.add(@boxHypothese)
+        boxVerticale.add(@hypothese)
+        @hypothese.show_all()
+        @hypothese.visible_child = (@grille.hypothese == true ? @boxHypothese : @boutonHypothese)
+
+        @reinitialiser = Gtk::Button.new(:label => "Réinitialiser")
+        boxVerticale.add(@reinitialiser)
+        @reinitialiser.signal_connect("clicked") { |widget| @grille.reinitialiser(); @afficheurGrille.queue_draw() }
+
+
+        box = Gtk::Box.new(Gtk::Orientation.new(1), 0)
+        box.margin_top = 15
+        box.vexpand = true
+
+        box.add(Gtk::Label.new("Aide :"))
+
+        @aidePos = Gtk::Button.new(:label => "Position")
+        @aidePos.margin_top = 5
+        box.add(@aidePos)
+        @aidePos.signal_connect("clicked") do |widget|
+            @aide ||= @grille.obtenirAide()
+            puts("avant " + @nbAides.to_s)
+            @nbAides += @aide.niveau == 1 ? 5 : @aide.niveau == 2 ? 3 : 1
+            puts("après " + @nbAides.to_s)
+            @afficheurGrille.cercleAide = @aide.caseJeu
+            @afficheurGrille.queue_draw()
+            @aidePos.sensitive = false
+        end
+
+        @aideTech = Gtk::Button.new(:label => "Technique")
+        box.add(@aideTech)
+        @aideTech.signal_connect("clicked") do |widget|
+            @aide ||= @grille.obtenirAide()
+            puts("avant " + @nbAides.to_s)
+            @nbAides += @aide.niveau == 1 ? 5 : @aide.niveau == 2 ? 3 : 1
+            puts("après " + @nbAides.to_s)
+            @description.text = @aide.description
+            @afficheurGrille.queue_draw()
+            @aideTech.sensitive = false
+        end
+
+        if @type == "aventure"
+            @aideTech.sensitive = false
+            @aidePos.sensitive = false
+        end
+
+        @description = Gtk::Label.new("")
+        @description.line_wrap = true
+        box.add(@description)
+
+        boxVerticale.add(box)
+        @pause = Gtk::Button.new(:label => "Pause")
+        boxVerticale.add(@pause)
+        @pause.signal_connect("clicked") { |widget| @timer.pause(); self.remove(@afficheurGrille); self.add1(@menu); self.show_all(); @paused = true }
+
+        self.add1(@afficheurGrille)
+        self.add2(boxVerticale)
+        self.set_wide_handle(true)
+        #self.set_position(1000)
+        #puts(self.allocation.width)
+        self.signal_connect("draw") do
+            self.set_position(self.allocation.width* (@paused ? 1 : 0.80))
+            print(nil)
+        end
+    end
+
+    def aJoue()
+        if @type != "aventure" 
+            @aide = nil
+            @afficheurGrille.cercleAide = nil
+            @description.text = ""
+            @aideTech.sensitive = true
+            @aidePos.sensitive = true
+        end
+        if @grille.grilleFinie?()
+            @grille.timer = @timer.secondes
+            @grille.nbAides = @nbAides
+            @grilleDb.grilleSolution = @grille.to_yaml()
+            GestionBase.changerScore(@fenetre.joueur.id, @grilleDb, 0)
+            puts("Sauvegardé")
+            d = Gtk::MessageDialog.new()
+            d.text = "Score final: #{GestionBase.recupScore(@fenetre.joueur.id, @grilleDb)}"
+            d.message_type = :info
+            d.run
+            d.destroy
+            @fenetre.finJeu()
+        end
+    end
+end

data/bin/src/ui/AfficheurSelection.rb

@@ -0,0 +1,38 @@
+require "gtk3"
+require_relative "SelecteurGrille"
+
+# Widget Gtk permettant d'afficher des sélectionneurs de grille
+class AfficheurSelection < Gtk::Box
+
+	# Constructeur
+        #
+        # === Paramètres
+        #
+        # * +fenetre+ - Fenetre principale
+	def initialize(fenetre)
+		super(Gtk::Orientation.new(0), 0)
+
+		boxHorizontale = Gtk::Box.new(Gtk::Orientation.new(0), 0)
+		self.add(boxHorizontale)
+
+		stackDif = Gtk::Stack.new()
+                stackDif.set_transition_type(Gtk::Stack::TransitionType::SLIDE_UP_DOWN);
+                stackDif.set_transition_duration(500);
+                boxVerticale = Gtk::Box.new(Gtk::Orientation.new(1), 0)
+		sideDif = Gtk::StackSidebar.new()
+		sideDif.stack = stackDif
+                sideDif.vexpand = true
+                boxVerticale.add(sideDif)
+
+                retour = Gtk::Button.new(label: "Retour")
+                retour.signal_connect("clicked") { fenetre.finSelection(nil, nil) }
+                boxVerticale.add(retour)
+
+		boxHorizontale.add(boxVerticale)
+		boxHorizontale.add(stackDif)
+
+		["Facile", "Moyen", "Difficile"].each_with_index() do |dif, i|
+			stackDif.add_titled(SelecteurGrille.new(fenetre, i+1), dif, dif)
+	        end
+	end
+end

data/bin/src/ui/Afrique.rb

@@ -0,0 +1,38 @@
+require "gtk3"
+require_relative "Carte"
+require_relative "Etiquette"
+
+# Widget Gtk affichant l'afrique
+class Afrique < Carte
+
+    # @factZoom => Facteur de zoom
+    # @dX => Décalage de l'affichage en x
+    # @dY => Décalage de l'affichage en y
+
+    # Constructeur
+    #
+    # === Paramètres
+    #
+    # * +carte+ - Carte principale
+    def initialize(carte)
+        super(carte)
+        @dX = -2450
+        @dY = -2000
+        @factZoom = 1.3
+
+        @g = carte.grillesD
+
+        self.dessinerEtiquettes()
+    end
+
+    def dessinerEtiquettes()
+        ajouterEtiquette(Etiquette.new(2150, 1750, 90, 30, @carte.etoiles[2][7], @g[7]))
+        ajouterEtiquette(Etiquette.new(2500, 1780, 90, 30, @carte.etoiles[2][8], @g[8]))
+        ajouterEtiquette(Etiquette.new(2450, 2000, 90, 30, @carte.etoiles[2][9], @g[9]))
+        ajouterEtiquette(Etiquette.new(2730, 2230, 90, 30, @carte.etoiles[2][10], @g[10]))
+        ajouterEtiquette(Etiquette.new(2450, 2330, 90, 30, @carte.etoiles[2][11], @g[11]))
+        ajouterEtiquette(Etiquette.new(2290, 1650, 90, 30, @carte.etoiles[2][12], @g[12]))
+        ajouterEtiquette(Etiquette.new(2420, 2200, 90, 30, @carte.etoiles[2][13], @g[13]))
+        super()
+    end
+end

data/bin/src/ui/AmeriqueNord.rb

@@ -0,0 +1,38 @@
+require "gtk3"
+require_relative "Carte"
+require_relative "Etiquette"
+
+# Widget Gtk affichant l'amerique du nord
+class AmeriqueNord < Carte
+
+    # @factZoom => Facteur de zoom
+    # @dX => Décalage de l'affichage en x
+    # @dY => Décalage de l'affichage en y
+
+    # Constructeur
+    #
+    # === Paramètres
+    #
+    # * +carte+ - Carte principale
+    def initialize(carte)
+        super(carte)
+        @dX = -1080
+        @dY = -1350
+        @factZoom = 1.1
+        
+        @g = carte.grillesF
+        
+        self.dessinerEtiquettes()
+    end
+
+    def dessinerEtiquettes()
+        ajouterEtiquette(Etiquette.new(1050, 1790, 90, 30, @carte.etoiles[0][0], @g[0]))
+        ajouterEtiquette(Etiquette.new(1270, 1700, 90, 30, @carte.etoiles[0][1], @g[1]))
+        ajouterEtiquette(Etiquette.new(1000, 1630, 90, 30, @carte.etoiles[0][2], @g[2]))
+        ajouterEtiquette(Etiquette.new(1230, 1530, 90, 30, @carte.etoiles[0][3], @g[3]))
+        ajouterEtiquette(Etiquette.new(930, 1300, 90, 30, @carte.etoiles[0][4], @g[4]))
+        ajouterEtiquette(Etiquette.new(1400, 1250, 90, 30, @carte.etoiles[0][5], @g[5]))
+        ajouterEtiquette(Etiquette.new(500, 1000, 90, 30, @carte.etoiles[0][6], @g[6]))
+        super()
+    end
+end