Mise en place des tutoriels 2, 3 et 4

labyrinthe/2-python/2-labyrinthe.py

@@ -0,0 +1,168 @@
+import bge # Bibliothèque Blender Game Engine (BGE)
+
+###############################################################################
+# labyrinthe.py
+# @title: Commandes pour le tutotiel Labyrinthe
+# @project: Blender-EduTech
+# @lang: fr
+# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
+# @copyright: Copyright (C) 2021 Philippe Roy
+# @license: GNU GPL
+#
+# Commandes déclenchées par UPBGE pour le tutoriel Labyrinthe
+#
+###############################################################################
+
+# Récupérer la scène 3D
+scene = bge.logic.getCurrentScene()
+# print("Objets de la scene : ", scene.objects)
+
+# Constantes
+
+JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
+JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
+ACTIVATE = bge.logic.KX_INPUT_ACTIVE
+# JUST_DEACTIVATED = bge.logic.KX_SENSOR_JUST_DEACTIVATED
+
+###############################################################################
+# Gestion du clavier
+###############################################################################
+
+# Flèches pour tourner le plateau
+def  clavier(cont):
+    # obj = cont.owner
+    obj = scene.objects['Plateau']
+    keyboard = bge.logic.keyboard
+    resolution = 0.01
+
+    # Up
+    if (ACTIVATE == keyboard.events[bge.events.UPARROWKEY]):
+        obj.applyRotation((-resolution,0,0), False)
+    
+    # Down
+    if (ACTIVATE == keyboard.events[bge.events.DOWNARROWKEY]):
+        obj.applyRotation((resolution,0,0), False)
+ 
+    # Left
+    if (ACTIVATE == keyboard.events[bge.events.LEFTARROWKEY]):
+        obj.applyRotation((0, -resolution,0), False)
+
+    # Right
+    if (ACTIVATE == keyboard.events[bge.events.RIGHTARROWKEY]):
+        obj.applyRotation((0, resolution,0), False)
+
+###############################################################################    
+# Joystick
+###############################################################################
+
+def  joystick(cont):
+    obj = cont.owner
+    joystickIndex = 0 #int from 0 to 6
+    joy = bge.logic.joysticks[joystickIndex]
+    events = joy.activeButtons
+    axis = joy.axisValues[0:4]
+    resolution = 0.01
+    
+    leftStick_x = axis[0]; leftStick_y = axis[1]
+    rightStick_x = axis[2]; rightStick_y = axis[3]
+
+    #if any button is pressed
+    # if events:
+    #     print(events) #spit out integer index of pressed buttons
+    # if 0 in events:
+    #     doSomething()
+        
+    # Up
+    if leftStick_y <-0.1 :
+        obj.applyRotation((-resolution,0,0), False)
+    
+    # Down
+    if leftStick_y >0.1 :
+        obj.applyRotation((resolution,0,0), False)
+ 
+    # Left
+    if leftStick_x <-0.1 :
+        obj.applyRotation((0, -resolution,0), False)
+
+    # Right
+    if leftStick_x >0.1 :
+        obj.applyRotation((0, resolution,0), False)
+
+###############################################################################    
+# Restart
+###############################################################################
+
+# Initialisation
+def  init(cont):
+
+    # Mémorisation de la position de départ  du joueur
+    obj = scene.objects['Joueur']
+    # obj = cont.owner
+    obj['init_lx']=obj.worldPosition.x
+    obj['init_ly']=obj.worldPosition.y
+    obj['init_lz']=obj.worldPosition.z
+
+    # Cacher le texte de victoire
+    scene.objects['Texte'].setVisible(False,False)
+
+    # Appliquer le poids à la balle
+    # obj.gravity = [0, 0, -10000000]
+    # obj.mass = 10
+    # obj. applyForce([0, 0, -100000000])
+    # obj.setDamping(0.5, 0.5)
+
+# Atteindre une orientation  (bas niveau)
+def applyRotationTo(obj, rx=None, ry=None, rz=None):
+    rres=0.001 # resolution rotation
+
+    # x
+    if rx is not None:
+        while (abs(rx-obj.worldOrientation.to_euler().x) > rres) :
+            if obj.worldOrientation.to_euler().x-rx > rres:
+                obj.applyRotation((-rres, 0, 0), True)
+            if rx-obj.worldOrientation.to_euler().x > rres:
+                obj.applyRotation((rres, 0, 0), True)
+            # print ("delta x ",rx-obj.worldOrientation.to_euler().x)
+        
+    # y
+    if ry is not None:
+        while (abs(ry-obj.worldOrientation.to_euler().y) > rres) :
+            if obj.worldOrientation.to_euler().y-ry > rres:
+                obj.applyRotation((0, -rres, 0), True)
+            if ry-obj.worldOrientation.to_euler().y > rres:
+                obj.applyRotation((0, rres, 0), True)
+            # print ("delta y ",ry-obj.worldOrientation.to_euler().y)
+
+    # z
+    if rz is not None:
+        while (abs(rz-obj.worldOrientation.to_euler().z) > rres) :
+            if obj.worldOrientation.to_euler().z-rz > rres:
+                obj.applyRotation((0, 0, -rres), True)
+            if rz-obj.worldOrientation.to_euler().z > rres:
+                obj.applyRotation((0, 0, rres), True)
+            # print ("delta z ",rz-obj.worldOrientation.to_euler().z)
+
+# Redémarrage de la partie
+def  restart(cont):
+    obj = cont.owner
+    obj['pos_z'] = obj.worldPosition.z  # Affichage de la position en z (debug)
+    if obj.worldPosition.z <-20 or obj.worldPosition.z >20 :
+
+        # Replacement du plateau
+        applyRotationTo(scene.objects['Plateau'], 0, 0, 0)
+
+        # Vitesse initiale nulle du joueur
+        obj.worldLinearVelocity=(0, 0, 0)
+        obj.worldAngularVelocity=(0, 0, 0)
+
+        # Replacement du joueur au point de départ 
+        obj.worldPosition.x=obj['init_lx']
+        obj.worldPosition.y=obj['init_ly']
+        obj.worldPosition.z=obj['init_lz']
+
+###############################################################################    
+# Gagné
+###############################################################################
+
+def  gagne(cont):
+    scene.objects['Texte'].setVisible(True,False)

labyrinthe/README.md

@@ -1,4 +1,34 @@
-# Labyrinthe à bille
+## Tutoriel 1 - Labyrinthe à bille : **Créer une scène 3D interactive**
+
+L'objectif de ce tutoriel est de créer une scène animée et interactive. Le support est le labyrinthe à bille ; le principe est faire tourner le plateau sur 2 axes afin d'amener la bille du départ à l'arrivée.
+
+Ce tutoriel est une déclinaison pour UPBGE du projet n°1 du livre ["Créez vos propres jeux 3D comme les pros" (Éditions Graziel)](https://graziel.com/fr/livres/8-creez-vos-propres-jeux-3d-comme-les-pros-avec-le-blender-game-engine-9791093846002.html) de Grégory Gossellin De Bénicourt.
+
+Il se décompose en 3 parties :
+
+### Tutoriel 1 : Ma première scène
+- Installer Blender/UPBGE
+- Modéliser les objets 3D et définir leurs materiaux et leur physique
+- Gérer la scène avec la lumière et la caméra
+- Programmer le comportement des objets et le gameplay les briques logiques
+- Créer une zone cliquable
+- Créer une animation par images-clé
+- Produire un exécutable (GNU/Linux, Windows, macOS)
+- Fichier resultat : 1-labyrinthe.blend
+
+### Tutoriel 2 : Passage au Python
+- Installer un éditeur de code (Emacs, Spyder)
+- Sustituer la programmation par briques logiques avec des modules codés en Python
+- Inclure les scripts Python avec l'exécutable
+- Fichiers resultats : 2-labyrinthe.blend,  2-labyrinthe.py
+
+### Tutoriel 3 : Interfacer la scène 3D avec une carte Arduino
+- Installer les bibliothèques pySerial et pyFirmata
+- Créer une manette avec 4 boutons binaires (fichiers resultats : 3-1-labyrinthe.blend,  3-1-labyrinthe.py)
+- Créer une manette avec un capteur de position (fichiers resultats : 3-2-labyrinthe.blend,  3-2-labyrinthe.py, 3-2-labyrinthe.ino)
+
+### Tutoriel 4 : Interfacer la scène 3D avec une carte micro:bit
+- Installer la bibliothèque pySerial
+- Créer une manette avec une carte micro:bit
+- Fichiers resultats : 4-labyrinthe.blend,  4-labyrinthe.py, 4-labyrinthe-carte.py)
 
-- Tutoriel 1 : **Créer une scène 3D interactive**
-- Tutoriel 2 : **Jumeler une maquette numérique avec un système réel**