amphi-5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d13d622b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Amphi 5 - Bilan séquence 2 - Lancement séquence 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17d37fca",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Bilan de la séquence 2\n",
    "    - Quelques démos de vos productions\n",
    "    - Vos retours sur la séquence 2\n",
    "- Lancement de la séquence 3\n",
    "    - Découverte du sujet du problème 3\n",
    "    - Quelques éléments pour bien démarrer\n",
    "    - Quelques éléments pour aller plus loin"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22f55655",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Bilan séquence 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53131646",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Comment interpréter les appréciations ?\n",
    "\n",
    "Réponse : **PAS** comme des notes \"brutes\" sur 15 (à la rigueur sur 10) !!!\n",
    "\n",
    "Chaque rubrique (base, améliorations, code, algo, assiduité) est indépendante\n",
    "\n",
    "Il faut prendre les appréciations comme des *indications* pour savoir quoi améliorer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "454f709f",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "L'objectif est d'avoir \"bien\" (ou 2 points) partout (sauf éventuellement dans \"améliorations\")\n",
    "\n",
    "- avoir 2 points partout est un objectif **atteignable**\n",
    "- avoir une ou deux rubriques à 1 est un signe qu'il faut lire et s'entraîner davantage !\n",
    "- avoir 3 points dans une rubrique est **rare**, avoir 3 partout est quasiment impossible\n",
    "\n",
    "Vous **pouvez** (devez ?) demander des détails ou des explications si vous ne comprenez pas une appréciation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8f606a",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Barème (schématique) pour interpréter votre note :\n",
    "\n",
    "- 1 dans une ou deux catégories (hors améliorations) : il y a des choses importantes à corriger, demandez de l'aide aux profs !\n",
    "- 2 ou plus dans *base*, *code*, *algo* et *assiduité* : tout va bien ! Continuez à découvrir et à progresser !\n",
    "- 2 partout : c'est très bien ! Continuez comme ça !\n",
    "- 3 dans une ou catégorie (ou plus) : félicitations !"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d589b93",
   "metadata": {},
   "source": [
    "### Quelques démos !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e7cb567",
   "metadata": {},
   "source": [
    "### Algorithme\n",
    "\n",
    "**Sentinelle** : au lieu de travailler sur une matrice $12 \\times 8$, on peut travailler au centre d'une matrice $14 \\times 10$, donc avec une bord de cases vides\n",
    "\n",
    "**Remplacer du code avec des données**: au lieu d'écrire du code pour les quatres directions, on peut écrire une liste ``dirs = [(1, 0), (0, 1), (-1, 0), (0, -1)]`` et itérer sur cette liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa230e4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrice toute remplie, mat[14][10]\n",
    "mat = [[1 for _ in range(10)] for _ in range(14)]\n",
    "# l'encadrement vide (sentinelle)\n",
    "for i in range(14):\n",
    "    mat[i][0] = mat[i][-1] = 0\n",
    "for j in range(10):\n",
    "    mat[0][j] = mat[-1][j] = 0\n",
    "    \n",
    "# liste des directions\n",
    "dirs = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n",
    "\n",
    "def turn_left(d):\n",
    "    '''\n",
    "    Renvoie la direction après un virage à gauche\n",
    "    '''\n",
    "    return dirs[dirs.index(d) - 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "299cd0cd",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Pour l'algorithme, plusieurs possibilités :\n",
    "- Deux virages max, donc trois paramètres suffit (distance avant le premier virage, entre le premier et le second, après le second)\n",
    "- Un algorithme de parcours (récursif ou pas), mais il faut se souvenir de la direction pour détecter le virage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f269e61",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_path_1(src, dest):\n",
    "    for d1 in dirs: # première direction\n",
    "        for l1 in range(14): # longueur max, idem pour chaque segment\n",
    "            x, y = src\n",
    "            x += d1[0] * l1\n",
    "            y += d2[0] * l1\n",
    "            # si le nouveau point est bien dans la zone, sans tuile\n",
    "            # entre lui et la source\n",
    "            if is_in_zone(x, y) and all_empty(src, (x, y)):\n",
    "                if (x, y) == dest: # on est là !\n",
    "                    return True\n",
    "                d2 = turn_left(d1)\n",
    "                for l2 in range(-13, 14): # tourner à gauche et à droite\n",
    "                    x2 = x + d2[0] * l2\n",
    "                    y2 = y + d2[1] * l2\n",
    "                    if is_in_zone(x2, y2) and all_empty((x, y), (x2, y2)):\n",
    "                        ......"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73cd7aef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_path_2(src, dest):\n",
    "    visited = [(src, d, 0) for d in dirs] # liste des cases deja vues\n",
    "    while visited: # tant qu'on peut continuer\n",
    "        coord, direct, vir = visited.pop()\n",
    "        if not is_in_zone(coord): # si on sort de la zone, on termine\n",
    "            continue\n",
    "        # est-ce qu'on arrive ?\n",
    "        if coord == dest:\n",
    "            return True\n",
    "        # est-ce qu'on est bloqué ?\n",
    "        if mat[coord[0]][coord[1]] != 0:\n",
    "            return False\n",
    "        # soit on avance\n",
    "        ???\n",
    "        # soit on fait un virage\n",
    "        if vir < 2:\n",
    "            # soit on tourne vers la gauche\n",
    "            ???\n",
    "            # soit on tourne vers la droite\n",
    "            ???\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7134a6d3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd2284bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bfdd7f6a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Impressions, remarques, critiques sur la séquence 2\n",
    "\n",
    "- Problème 2 trop dur par rapport au problème 1\n",
    "- Peut-être faire des solutions partielles si on n'arrive pas trop bien à faire en totalité"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c8fc00",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lancement séquence 3\n",
    "\n",
    "[Jeu en ligne](https://elgoog.im/breakout/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19f31707",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Présentation du problème 3 : Breakout"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd9f8607",
   "metadata": {},
   "source": [
    "### Architecture -- Construction MVC\n",
    "\n",
    "**Architecture** : comment on organise le code d'un programme, surtout quand c'est grand et compliqué ?\n",
    "\n",
    "Solution : la **modularisation** !\n",
    "\n",
    "Quelques principes : \n",
    "- Séparer en plusieurs modules (``from mymod import symb`` si vous voulez utiliser la fonction/classe ``symb`` défini dans ``mymod.py`` dans le même répertoire)\n",
    "- Séparer les fonctions en modules selon leur thématiques (calcul, interface utilisateur, graphique, ...)\n",
    "- Chaque fonction doit faire exactement une chose. Pas d'affichage dans une fonction de calcul.\n",
    "- Si vous utilisez des classes, alors un fichier par classe.\n",
    "\n",
    "Méthode de modularisation usuelle : la construction MVC (Modèle--Vue--Contrôle)\n",
    "- **Modèle** : Les données et le modèle algorithmique pour manipulation/interaction des données\n",
    "- **Vue** : L'affichage et l'interface d'utilisateur\n",
    "- **Controlleur** : La logique concernant les actions effectuées par l'utilisateur\n",
    "\n",
    "![Construction MVC, Wikipedia](img/mvc.png)\n",
    "\n",
    "**On peut avoir plusieurs modules pour chaque aspect de MVC !** La construction MVC n'est qu'un premier découpage. Si les modules deviennent trop grands ou trop \"polyvalents\", alors on peut les découper plus loin."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28c0935",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Quelques pistes pour bien démarrer\n",
    "\n",
    "Illustrations tirées de l'ouvrage \"The Nature of Code\" par Daniel Shiffman, ouvrage libre, gratuit et animé [disponible en ligne](https://natureofcode.com/book/)\n",
    "\n",
    "Lecture fortement recommandée, en particulier les chapitres 1 et 2 !!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03929027",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Représenter un objet mobile\n",
    "\n",
    "Pour représenter chaque objet mobile dans la scène, on a besoin de connaître au moins\n",
    "- sa position\n",
    "- sa vitesse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1218f850",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut utiliser pour cela des **vecteurs** à deux dimensions :\n",
    "\n",
    "![dessin de vecteur](img/vecteur.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ada071e1",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Un vecteur peut servir à représenter \n",
    "- la **position** d'un objet par rapport à l'origine (vecteur position),\n",
    "- ou bien sa **vitesse** ou déplacement au cours du prochain laps de temps (vecteur vitesse)\n",
    "\n",
    "![vecteur comme position et vecteur comme vitesse](img/vecteur_point_vitesse.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47ad1c24",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Un vecteur peut être vu \n",
    "- comme une \"flèche\" entre deux points du plan\n",
    "- ou comme un couple de deux nombres (coordonnées ou composantes)\n",
    "\n",
    "![composantes d'un vecteur](img/vecteur_composantes.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f955b1ec",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "À chaque intervalle de temps (par exemple un 60e de seconde) et pour chaque objet mobile :\n",
    "\n",
    "- on ajoute le vecteur vitesse de l'objet à sa position précédente\n",
    "- on dessine l'objet à sa nouvelle position"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c71556f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Vecteurs en Python\n",
    "\n",
    "Représentation simple : avec des `tuple` ou des `list` de taille 2\n",
    "\n",
    "Premières opérations :\n",
    "- addition de deux vecteurs (composante par composante)\n",
    "- multiplication par un nombre (produit scalaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "676bcb22",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def somme_vecteurs(v1, v2):\n",
    "    x1, y1 = v1\n",
    "    x2, y2 = v2\n",
    "    x = x1 + x2\n",
    "    y = y1 + y2\n",
    "    return (x, y)\n",
    "    \n",
    "def produit_scalaire(v, m):\n",
    "    x, y = v\n",
    "    return (m*x, m*y)\n",
    "    \n",
    "# insérer un test ici\n",
    "produit_scalaire(somme_vecteurs((1, 2), (3, 4)), 1/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70c1c68d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Objets mobiles en Python\n",
    "\n",
    "Représentation simple : liste de deux vecteurs (position et vitesse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08db92c7",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import fltk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e24fe81",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def dessine(mobile):\n",
    "    pos = mobile[0]\n",
    "    x, y = pos\n",
    "    fltk.cercle(x, y, 10)\n",
    "    \n",
    "def deplace(mobile):\n",
    "    pos, vit = mobile\n",
    "    mobile[0] = somme_vecteurs(pos, vit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8757495f",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from random import uniform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff20f496",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def scene1():\n",
    "    \"\"\"Je veux une balle qui se déplace à une vitesse constante\n",
    "    dans une direction fixe (aléatoire).\n",
    "    \"\"\"\n",
    "    mobile = [[300, 300], [uniform(-2, 2), uniform(-2, 2)]]\n",
    "    \n",
    "    fltk.cree_fenetre(600, 600)\n",
    "\n",
    "    while True:\n",
    "        ev = fltk.donne_ev()\n",
    "        tev = fltk.type_ev(ev)\n",
    "        if tev == 'Quitte':\n",
    "            break\n",
    "        \n",
    "        fltk.efface_tout()\n",
    "        \n",
    "        # notre moteur de déplacement :\n",
    "        dessine(mobile)\n",
    "        deplace(mobile)\n",
    "    \n",
    "        fltk.mise_a_jour()\n",
    "\n",
    "    fltk.ferme_fenetre()\n",
    "\n",
    "scene1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcc332fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "fltk.ferme_fenetre()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f731d80",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Et ensuite ?\n",
    "\n",
    "- Gestion des rebonds sur les bords\n",
    "- Dessin et contrôle de la raquette\n",
    "- Rebondissement sur la raquette\n",
    "- Détection des collisions entre la balle et une brique\n",
    "- Calculer l'effet des collisions et faire les mise-à-jour"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3203331d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Pour aller plus loin\n",
    "\n",
    "Voir le chapitre 2 de [Nature of Code](https://natureofcode.com/book/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26c4b8e9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}