Tutoriel Ruby

Acte I

1. Introduction

Ruby est un langage de programmation dynamique, interprété et orienté objet. Voici quelques bases :
1. Syntaxe claire et expressive : Ruby est réputé pour sa syntaxe simple et lisible, qui favorise la productivité des développeurs.
2. Tout est un objet : En Ruby, tout est un objet, même les types de base comme les entiers et les chaînes de caractères.
3. Orienté objet : Ruby est un langage de programmation orienté objet pur, ce qui signifie que presque tout en Ruby est un objet avec des méthodes et des propriétés.
4. Variables : Les variables en Ruby commencent par un sigle (dollar) suivi d'un nom de variable. Elles peuvent contenir n'importe quel type de données.
5. Méthodes : Les méthodes sont des fonctions définies dans les classes. Elles peuvent être appelées sur des objets pour effectuer des actions spécifiques.
6. Collections : Ruby propose différentes collections de données telles que les tableaux (Array) et les hashages (Hash) pour stocker des éléments de manière organisée.
7. Contrôle de flux : Comme dans la plupart des langages de programmation, Ruby offre des structures de contrôle de flux telles que les conditions (if/else), les boucles (while, for) et les instructions de contrôle (break, next).
8. Modules et Mixins : Ruby prend en charge les modules, qui sont des ensembles de méthodes et de constantes pouvant être inclus dans les classes. Les mixins permettent de réutiliser du code à travers l'inclusion de modules dans d'autres modules ou classes.
9. Gestion des exceptions : Ruby fournit un mécanisme de gestion des exceptions pour gérer les erreurs et les situations exceptionnelles dans le code.
10. Itérations : Ruby offre plusieurs méthodes pour itérer sur des collections de données de manière efficace et élégante, comme each, map, et times.

2. Exemple 1

Voici un exemple simple d'un programme Ruby qui prend en entrée le nom de l'utilisateur et lui dit bonjour : 
# Demander à l'utilisateur son nom
print "Quel est votre nom ? "
nom_utilisateur = gets.chomp

# Afficher un message de salutation
puts "Bonjour, #{nom_utilisateur} ! Bienvenue avec Ruby !"
Dans ce code :
- La méthode `gets.chomp` permet de récupérer une entrée de l'utilisateur depuis la console et de supprimer le saut de ligne à la fin.
- Le symbole `#{}` est utilisé pour insérer des variables dans une chaîne de caractères.
- La méthode `puts` affiche du texte suivi d'un saut de ligne.
Pour exécuter ce programme, placez ce code dans un fichier avec une extention `.rb`, et lancez le avec l'interpréteur `ruby`, il vous demandera alors votre nom, puis il vous accueillera avec un message de bienvenue : 
$ ruby hello.rb
Quel est votre nom ? J
Bonjour, J ! Bienvenue avec Ruby !

3. Exemple 2

Voici un autre exemple, cette fois-ci d'une fonction qui calcule la somme des nombres d'une liste en Ruby : 
def somme_liste(liste)
  somme = 0
  liste.each do |nombre|
    somme += nombre
  end
  return somme
end

# Exemple d'utilisation de la fonction
liste_nombres = [1, 2, 3, 4, 5]
resultat = somme_liste(liste_nombres)
puts "La somme des nombres dans la liste est : #{resultat}"
Dans ce code :
- La fonction `somme_liste` prend une liste de nombres en entrée et calcule leur somme en utilisant une boucle `each`.
- La variable `somme` est initialisée à zéro, puis chaque nombre de la liste est ajouté à cette variable.
- Finalement, la fonction retourne la somme.
- L'exemple d'utilisation montre comment utiliser la fonction avec une liste de nombres prédéfinie, puis affiche le résultat.

4. Classes et Objets

Pour instancier un objet de la classe `Dog` en Ruby, vous pouvez suivre l'exemple ci-dessous. Voici d'abord la classe `Dog` en Ruby, puis un exemple d'instanciation et d'appel de méthode. 
class Dog
  def initialize(name, age)
    @name = name
    @age = age
  end

  def bark
    puts "#{@name} dit Woof!"
  end
end

# Instanciation d'un objet de la classe Dog
mon_chien = Dog.new("Rex", 3)

# Appel de la méthode bark sur l'objet
mon_chien.bark
Dans ce code :
- La méthode `initialize` est l'équivalent du constructeur en Ruby, elle est appelée lorsqu'un nouvel objet est instancié.
- Les variables d'instance `@name` et `@age` sont utilisées pour stocker les attributs de l'objet.
- La méthode `bark` affiche un message contenant le nom du chien.
- L'objet `mon_chien` est créé en appelant `Dog.new` avec les arguments "Rex" et 3.
- La méthode `bark` est appelée sur l'objet `mon_chien` pour afficher le message.
En exécutant ce code, vous verrez "Rex dit Woof!" s'afficher dans la console. 
$ ruby dog.rb
Rex dit Woof!

5. Map sur une liste

En Ruby, la méthode `map` est utilisée pour transformer chaque élément d'une liste en appliquant un bloc de code et en retournant une nouvelle liste avec les résultats. Voici un exemple simple : 
# Liste initiale de nombres
nombres = [1, 2, 3, 4, 5]

# Utilisation de la méthode map pour créer une nouvelle liste
# avec les nombres multipliés par 2
nombres_doubles = nombres.map do |nombre|
  nombre * 2
end

# Affichage de la nouvelle liste
puts "Nombres doubles : #{nombres_doubles}"
Dans ce code :
- La liste `nombres` contient les nombres de 1 à 5.
- La méthode `map` est appelée sur la liste `nombres`. Le bloc de code `do |nombre| nombre * 2 end` multiplie chaque nombre par 2.
- La nouvelle liste `nombres_doubles` contient les résultats de cette transformation.
- La méthode `puts` est utilisée pour afficher la nouvelle liste.
Quand ce code est exécuté, il affichera : 
Nombres doubles : [2, 4, 6, 8, 10]
Ce qui montre que chaque élément de la liste originale a été multiplié par 2.

Acte II

6. Créer un mini-jeu

Pour créer des mini-jeux en Ruby, une des bibliothèques les plus populaires est Gosu. Gosu est une bibliothèque de développement de jeux 2D simple et puissante qui fonctionne sur plusieurs plateformes (Windows, MacOS, Linux). Voici comment vous pouvez commencer à utiliser Gosu pour créer des mini-jeux en Ruby :
1. Installer Gosu :
Vous pouvez installer Gosu via RubyGems. Ouvrez votre terminal et exécutez : 
$ sudo apt-get install ruby
$ sudo apt-get install ruby-dev
$ sudo gem install gosu

Successfully installed gosu-1.4.6
2. Créer un mini-jeu simple :
Voici un exemple de code pour commencer un mini-jeu simple où un joueur peut déplacer un carré avec les touches du clavier : 
require 'gosu'

class GameWindow < Gosu::Window
  def initialize
    super 640, 480
    self.caption = "Mini-Jeu avec Gosu"
    @x = @y = 320
    @image = Gosu::Image.new("media/square.png")
  end

  def update
    if Gosu.button_down? Gosu::KB_LEFT
      @x -= 5
    end
    if Gosu.button_down? Gosu::KB_RIGHT
      @x += 5
    end
    if Gosu.button_down? Gosu::KB_UP
      @y -= 5
    end
    if Gosu.button_down? Gosu::KB_DOWN
      @y += 5
    end
  end

  def draw
    @image.draw(@x, @y, 1)
  end
end

GameWindow.new.show
Dans ce code :
- La classe `GameWindow` hérite de `Gosu::Window`.
- La méthode `initialize` configure la fenêtre du jeu, définit la position initiale du carré et charge une image pour le carré.
- La méthode `update` est appelée en boucle et permet de mettre à jour la position du carré en fonction des touches du clavier pressées.
- La méthode `draw` dessine le carré à sa position actuelle.
3. Créer l'image du carré :
Vous devrez créer une image pour le carré que vous pouvez nommer `square.png` et placer dans un dossier `media`. La taille de l'image peut être, par exemple, 50x50 pixels.
4. Exécuter le jeu :
Sauvegardez le code ci-dessus dans un fichier, par exemple `mini_game.rb`, et exécutez-le avec Ruby :
 $ ruby mini_game.rb  
Gosu est bien documenté et offre de nombreuses fonctionnalités pour gérer les graphismes, le son et les entrées utilisateur, ce qui le rend idéal pour créer des mini-jeux en Ruby.
Ces éléments constituent les bases de Ruby, mais il y a bien plus à explorer dans ce langage riche et flexible !
Created with ChatGPT