Vous avez passé toute votre vie à coder, que ce soit en étudiant vos cours, en suivant les instructions de votre mère, ou simplement en faisant des crêpes.

Dans un livre de recette

Ingrédients :

250 g de farine
3 œufs
50 cl de lait
50 g de beurre fondu
1 pincée de sel
2 cuillères à soupe de sucre (facultatif, pour des crêpes sucrées)

Instructions :

Préparer la pâte :
- Dans un grand bol, tamisez la farine.
- Faites un puits au centre et cassez-y les œufs.
- Mélangez doucement les œufs avec la farine en incorporant peu à peu la farine.
- Versez le lait progressivement tout en continuant à mélanger pour éviter les grumeaux. Vous pouvez utiliser un fouet ou un mixeur plongeant pour obtenir une pâte lisse.
- Ajoutez le beurre fondu et mélangez bien.
- Si vous faites des crêpes sucrées, ajoutez le sucre à ce stade.
- Ajoutez une pincée de sel.
Laisser reposer la pâte :
- Couvrez le bol avec un film plastique ou un torchon propre.
- Laissez reposer la pâte pendant environ 30 minutes à 1 heure à température ambiante. Cela permet à la farine de bien s’hydrater et rend les crêpes plus légères.
Cuire les crêpes :
- Faites chauffer une poêle antiadhésive ou une crêpière à feu moyen.
- Graissez légèrement la poêle avec un peu de beurre ou d’huile (vous pouvez utiliser un papier absorbant pour étaler une fine couche).
- Versez une petite quantité de pâte dans la poêle chaude et inclinez la poêle pour répartir la pâte uniformément en une fine couche.
- Faites cuire environ 1 à 2 minutes jusqu'à ce que les bords de la crêpe se détachent de la poêle et que la surface soit dorée.
- Retournez la crêpe avec une spatule et faites cuire l’autre côté encore 30 secondes à 1 minute.
- Répétez jusqu’à ce que vous ayez cuit toutes les crêpes, en graissant légèrement la poêle entre chaque crêpe si nécessaire.
Servir :
- Servez les crêpes chaudes avec vos garnitures préférées : confiture, miel, sucre, Nutella, fruits, chantilly, etc.

Bon appétit !

En pseudo code

début

  // étape 1 : préparer la pâte
  prendre un grand bol
  tamiser la farine dans le bol
  faire un puits au centre de la farine
  casser les œufs dans le puits
  mélanger les œufs avec la farine en incorporant progressivement la farine
  ajouter le lait petit à petit tout en mélangeant jusqu'à obtenir une pâte lisse
  ajouter le beurre fondu dans la pâte et mélanger
  si vous faites des crêpes sucrées
    ajouter le sucre dans la pâte et mélanger
  fin si
  ajouter une pincée de sel dans la pâte
  couvrir le bol avec un film plastique ou un torchon
  laisser reposer la pâte pendant 30 minutes à 1 heure

  // étape 2 : cuire les crêpes
  chauffer une poêle à feu moyen
  pour chaque crêpe
    graisser légèrement la poêle avec du beurre ou de l'huile
    verser une petite quantité de pâte dans la poêle
    incliner la poêle pour étaler la pâte en une fine couche
    cuire pendant 1 à 2 minutes jusqu'à ce que les bords se détachent et que la surface soit dorée
    retourner la crêpe avec une spatule
    cuire l'autre côté pendant 30 secondes à 1 minute
  fin pour

  // étape 3 : servir
  servir les crêpes chaudes avec les garnitures de votre choix (confiture, miel, sucre, Nutella, fruits, chantilly, etc.)

fin

Version codé

1. Lua

En Lua, nous modifions la fonction de cuisson pour inclure la fonction de service après chaque crêpe :

-- Fonction pour préparer la pâte
function preparerPate()
    local pate = {}
    pate.farine = 250
    pate.oeufs = 3
    pate.lait = 50
    pate.beurre_fondu = 50
    pate.sel = 1
    pate.sucre = 2 -- facultatif
    pate.quantite_restante = 10 -- Quantité de pâte restante en "unités"
    return pate
end

-- Fonction pour cuire les crêpes
function cuireCrepes(pate)
    while pate.quantite_restante > 0 do
        print("Chauffer une poêle à feu moyen")
        print("Graisser légèrement la poêle")
        print("Verser une petite quantité de pâte dans la poêle")
        print("Incliner la poêle pour étaler la pâte en une fine couche")
        print("Cuire pendant 1 à 2 minutes jusqu'à doré, retourner et cuire l'autre côté")

        pate.quantite_restante = pate.quantite_restante - 1 -- Une crêpe consommée, réduire la quantité

        -- Servir la crêpe immédiatement après cuisson
        print("Une crêpe a été servie. Pâte restante: " .. pate.quantite_restante)
    end
end

-- Exécution des fonctions
local pate = preparerPate()
cuireCrepes(pate)

2. Python

En Python, nous ajoutons l'appel à la fonction de service à l'intérieur de la boucle de cuisson :

def preparer_pate():
    pate = {
        'farine': 250,
        'oeufs': 3,
        'lait': 50,
        'beurre_fondu': 50,
        'sel': 1,
        'sucre': 2,  # facultatif
        'quantite_restante': 10  # Quantité de pâte restante en "unités"
    }
    return pate

def melanger_pate(pate):
    print("Tamiser la farine dans un bol")
    print("Faire un puits et ajouter les œufs")
    print("Incorporer les œufs et ajouter le lait progressivement")
    print("Ajouter le beurre fondu et le sucre si nécessaire")
    print("Ajouter une pincée de sel")
    print("Laisser reposer la pâte pendant 30 minutes à 1 heure")

def servir_crepe():
    print("Une crêpe a été servie.")

def cuire_crepes(pate):
    while pate['quantite_restante'] > 0:
        print("Chauffer une poêle à feu moyen")
        print("Graisser légèrement la poêle")
        print("Verser une petite quantité de pâte dans la poêle")
        print("Incliner la poêle pour étaler la pâte en une fine couche")
        print("Cuire jusqu'à doré, retourner et cuire l'autre côté")

        pate['quantite_restante'] -= 1  # Une crêpe consommée, réduire la quantité

        # Servir la crêpe immédiatement après cuisson
        servir_crepe()
        print(f"Pâte restante: {pate['quantite_restante']}")

# Exécution des fonctions
pate = preparer_pate()
melanger_pate(pate)
cuire_crepes(pate)

3. C

En C#, nous mettons l'appel à la méthode de service à l'intérieur de la boucle de cuisson :

using System;

class Program
{
    static void Main()
    {
        // Préparer la pâte
        var pate = PreparerPate();
        MelangerPate(pate);

        // Cuire les crêpes
        CuireCrepes(pate);
    }

    static dynamic PreparerPate()
    {
        Console.WriteLine("Préparer la pâte avec 250g de farine, 3 œufs, 50cl de lait, 50g de beurre fondu, 1 pincée de sel et 2 cuillères à soupe de sucre (facultatif)");
        return new { QuantiteRestante = 10 }; // Quantité de pâte restante
    }

    static void MelangerPate(dynamic pate)
    {
        Console.WriteLine("Tamiser la farine dans un bol");
        Console.WriteLine("Faire un puits et ajouter les œufs");
        Console.WriteLine("Incorporer les œufs et ajouter le lait progressivement");
        Console.WriteLine("Ajouter le beurre fondu et le sucre si nécessaire");
        Console.WriteLine("Ajouter une pincée de sel");
        Console.WriteLine("Laisser reposer la pâte pendant 30 minutes à 1 heure");
    }

    static void CuireCrepes(dynamic pate)
    {
        while (pate.QuantiteRestante > 0)
        {
            Console.WriteLine("Chauffer une poêle à feu moyen");
            Console.WriteLine("Graisser légèrement la poêle");
            Console.WriteLine("Verser une petite quantité de pâte dans la poêle");
            Console.WriteLine("Incliner la poêle pour étaler la pâte en une fine couche");
            Console.WriteLine("Cuire jusqu'à doré, retourner et cuire l'autre côté");

            pate.QuantiteRestante--; // Une crêpe consommée, réduire la quantité

            // Servir la crêpe immédiatement après cuisson
            Console.WriteLine("Une crêpe a été servie.");
            Console.WriteLine($"Pâte restante: {pate.QuantiteRestante}");
        }
    }
}

En Unity3D

using UnityEngine;
using System.Collections;

[System.Serializable]
public class Recipe
{
    [Header("Ingrédients")]
    public float farine = 250f; // en grammes
    public int oeufs = 3;
    public float lait = 50f; // en centilitres
    public float beurre = 50f; // en grammes
    public float sel = 1f; // en grammes, ou ajuster pour une pincée
    public float sucre = 2f; // en cuillères à soupe, facultatif
}

public class CrepeMaker : MonoBehaviour
{
    [Header("Paramètres de cuisson")]
    public float tempsCuisson = 0.3f; // Temps de cuisson pour chaque côté

    [Header("Paramètres de production")]
    public int quantiteCrêpes = 30;

    [Header("Taille de la crêpe")]
    public float tailleDeLaCrepe = 1.0f;

    [Header("Ingrédients")]
    [SerializeField] private Recipe recette; // Référence à la recette

    private float initialYPosition = 10f;
    private float spacingY = 0.5f;

    public int beaucoupDeCrepe = 50;
    public int crepeRestante = 0;

    private GameObject ground;

    [ContextMenu("Faire une crêpe")]
    public void FaireUneCrepe()
    {
        InstantiateCrepe(initialYPosition);
    }

    [ContextMenu("Faire beaucoup de crêpes")]
    public void FaireBeaucoupDeCrepes()
    {
        for (int i = 0; i < beaucoupDeCrepe; i++)
        {
            InstantiateCrepe(initialYPosition);
        }
    }

    void Awake()
    {
        CreateGround();
    }

    void Start()
    {
        PrepararPate();
        MelangerPate();
        StartCoroutine(CuireCrepes());
    }

    void PrepararPate()
    {
        Debug.Log($"Préparation de la pâte : {recette.farine}g de farine, {recette.oeufs} œufs, {recette.lait}cl de lait, {recette.beurre}g de beurre fondu, {recette.sel} pincée(s) de sel, et {recette.sucre} cuillère(s) à soupe de sucre (facultatif).");
    }

    void MelangerPate()
    {
        Debug.Log($"Tamiser les {recette.farine}g de farine dans un bol.");
        Debug.Log($"Faire un puits et ajouter les {recette.oeufs} œufs.");
        Debug.Log($"Incorporer les œufs et ajouter les {recette.lait}cl de lait progressivement.");
        Debug.Log($"Ajouter les {recette.beurre}g de beurre fondu et {recette.sucre} cuillère(s) à soupe de sucre si nécessaire.");
        Debug.Log($"Ajouter {recette.sel} pincée(s) de sel.");
        Debug.Log("Laisser reposer la pâte pendant 30 minutes à 1 heure.");
    }

    IEnumerator CuireCrepes()
    {
        float currentYPosition = initialYPosition;
        for (int i = 0; i < quantiteCrêpes; i++)
        {
            Debug.Log("Chauffer une poêle à feu moyen.");
            Debug.Log("Graisser légèrement la poêle.");
            Debug.Log("Verser une petite quantité de pâte dans la poêle.");
            Debug.Log("Incliner la poêle pour étaler la pâte en une fine couche.");

            // Instancier une crêpe
            InstantiateCrepe(currentYPosition);

            Debug.Log("Cuisson en cours...");
            yield return new WaitForSeconds(tempsCuisson); // Attendre le temps de cuisson

            Debug.Log("Retourner la crêpe et cuire l'autre côté.");
            yield return new WaitForSeconds(tempsCuisson); // Attendre encore le temps de cuisson

            crepeRestante = quantiteCrêpes - i - 1;
            Debug.Log("Une crêpe a été servie. Pâte restante : " + crepeRestante);

            // Mettre à jour la position pour la prochaine crêpe
            currentYPosition -= spacingY;

            //Sabotage
            FaireBeaucoupDeCrepes();
        }
        Debug.Log("Toutes les crêpes ont été cuites.");

    }

    void InstantiateCrepe(float yPosition)
    {
        GameObject crepe = GameObject.CreatePrimitive(PrimitiveType.Cylinder);

        // Ajuster l'échelle pour rendre le cylindre plat
        crepe.transform.localScale = new Vector3(tailleDeLaCrepe, 0.1f, tailleDeLaCrepe);

        // Positionner le cylindre
        crepe.transform.position = new Vector3(0, yPosition, 0);
        crepe.transform.rotation = Quaternion.Euler(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));

        // Ajouter un Rigidbody avec gravité
        Rigidbody rb = crepe.AddComponent<Rigidbody>();
        rb.useGravity = true;

        // Ajouter un matériau jaune
        Renderer renderer = crepe.GetComponent<Renderer>();
        renderer.material.color = Color.yellow;
    }

    void CreateGround()
    {
        ground = GameObject.CreatePrimitive(PrimitiveType.Cube);
        ground.transform.localScale = new Vector3(10, 0.1f, 10);
        ground.transform.position = new Vector3(0, 0, 0);
        Renderer renderer = ground.GetComponent<Renderer>();
        renderer.material.color = Color.gray;
    }
}

getMilk(1);
if (eggs.Count > 0)
      getMilk(6);

EloiStree / 2024_07_19_CharleroiStreetAR

Workshop-Day: Apprendre ce qu'est une variable, une méthode et une interface en déplaçant le drone. #175

165

164