Tutoriel 3 : fichiers blend et python

labyrinthe/3-arduino/3-labyrinthe-manette.py

@@ -0,0 +1,164 @@
+import bge # Bibliothèque Blender Game Engine (BGE)
+
+###############################################################################
+# 2-labyrinthe.py
+# @title: Module (unique) de la scène 3D du labyrinthe à bille
+# @project: Blender-EduTech - Tutoriel : Tutoriel 2 Labyrinthe à bille - Passage au Python
+# @lang: fr
+# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
+# @copyright: Copyright (C) 2023 Philippe Roy
+# @license: GNU GPL
+#
+# Commandes déclenchées par UPBGE pour le scène du labyrinthe
+#
+###############################################################################
+
+# Récupérer la scène 3D
+scene = bge.logic.getCurrentScene()
+# print("Objets de la scene : ", scene.objects) # Lister les objets de la scène
+
+# Constantes
+
+JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
+JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
+ACTIVATE = bge.logic.KX_INPUT_ACTIVE
+
+###############################################################################
+# Gestion du clavier
+###############################################################################
+
+# Flèches pour tourner le plateau
+def  clavier(cont):
+    obj = cont.owner # obj est l'objet associé au contrôleur donc 'Plateau'
+    # obj = scene.objects['Plateau']
+    keyboard = bge.logic.keyboard
+    resolution = 0.01
+
+    # Flèche haut - Up arrow
+    if keyboard.inputs[bge.events.UPARROWKEY].status[0] == ACTIVATE:
+        obj.applyRotation((-resolution,0,0), False)
+    
+    # Flèche bas - Down arrow
+    if keyboard.inputs[bge.events.DOWNARROWKEY].status[0] == ACTIVATE:
+        obj.applyRotation((resolution,0,0), False)
+ 
+    # Flèche gauche - Left arrow
+    if keyboard.inputs[bge.events.LEFTARROWKEY].status[0] == ACTIVATE:
+        obj.applyRotation((0, -resolution,0), False)
+
+    # Flèche droit - Right arrow
+    if keyboard.inputs[bge.events.RIGHTARROWKEY].status[0] == ACTIVATE:
+        obj.applyRotation((0, resolution,0), False)
+
+###############################################################################
+# Gameplay
+###############################################################################
+
+# Initialisation de la scène
+def  init(cont):
+    obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
+
+    # Mémorisation de la position de départ de la bille
+    obj['init_x']=obj.worldPosition.x
+    obj['init_y']=obj.worldPosition.y
+    obj['init_z']=obj.worldPosition.z
+
+    # Cacher le panneau de la victoire et suspendre la physique du panneau cliquable
+    scene.objects['Panneau victoire'].setVisible(False,True)
+    scene.objects['Panneau victoire - plan'].suspendPhysics (True)
+    scene.objects['Bouton fermer'].color = (0, 0, 0, 1) # Noir
+
+# Cycle (boucle de contrôle de la bille)
+def  cycle(cont):
+    obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
+    obj['z']=obj.worldPosition.z # la propriété z est mis à jour avec la position globale en z de la bille
+    obj_plateau = scene.objects['Plateau'] # obj_plateau est l'objet 'Plateau'
+    obj_plateau['rot_x']=obj_plateau.worldOrientation.to_euler().x # propriété 'rot_x' mis à jour avec l'orientation globale en x du plateau
+    obj_plateau['rot_y']=obj_plateau.worldOrientation.to_euler().y # propriété 'rot_y' mis à jour avec l'orientation globale en y du plateau
+    obj_plateau['rot_z']=obj_plateau.worldOrientation.to_euler().z # propriété 'rot_z' mis à jour avec l'orientation globale en z du plateau
+
+    # Redémarrer la partie si la bille a chuté et si la panneau victoire n'est pas visible
+    if obj['z'] < -20 and scene.objects['Panneau victoire'].visible == False:
+        print ("Chuuuu.....te")
+
+        # Replacement du plateau (tous les angles à 0 en plusieurs fois)
+        while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
+            obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
+
+        # Mettre la bille à la position de départ avec une vitesse nulle
+        obj.worldLinearVelocity=(0, 0, 0)
+        obj.worldAngularVelocity=(0, 0, 0)
+        obj.worldPosition.x = obj['init_x']
+        obj.worldPosition.y = obj['init_y']
+        obj.worldPosition.z = obj['init_z']+0.5 # On repose la bille
+
+# Victoire (colision de la bille avec l'arrivée)
+def victoire(cont):
+    scene.objects['Panneau victoire'].setVisible(True,True) # Afficher le panneau de la victoire
+    scene.objects['Panneau victoire - plan'].restorePhysics() # Restaurer la physique du panneau cliquable
+    start = 1
+    end = 100
+    layer = 0
+    priority = 1
+    blendin = 1.0
+    mode = bge.logic.KX_ACTION_MODE_PLAY
+    layerWeight = 0.0
+    ipoFlags = 0
+    speed = 1
+    scene.objects['Panneau victoire'].playAction('Panneau victoireAction', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
+
+# Highlight du bouton Fermer
+def victoire_fermer_hl(cont):
+    obj = cont.owner
+
+    # Activation
+    if cont.sensors['MO'].status == JUST_ACTIVATED:
+            obj.color = (1, 1, 1, 1) # Blanc
+
+    # Désactivation
+    if cont.sensors['MO'].status == JUST_RELEASED:
+        obj.color = (0, 0, 0, 1) # Noir
+
+# Fermer le panneau de la victoire (clic)
+def victoire_fermer(cont):
+    if cont.sensors['Click'].status == JUST_ACTIVATED and cont.sensors['MO'].positive:
+        scene.objects['Panneau victoire'].setVisible(False,True) # Cacher le panneau de la victoire
+        scene.objects['Panneau victoire - plan'].suspendPhysics (True) # Suspendre la physique du panneau cliquable
+        scene.objects['Bille']['z']= -21 # On provoque le redémarrage si la bille est ressortie
+
+###############################################################################    
+# Gestion du 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)

labyrinthe/3-arduino/test/manette-test.py

@@ -20,8 +20,8 @@ import sys
 # Communication avec la carte Arduino
 ###############################################################################
 
-carte = pyfirmata.Arduino('COM4') # Windows
-#carte = pyfirmata.Arduino('/dev/ttyACM0') # GNU/Linux
+# carte = pyfirmata.Arduino('COM4') # Windows
+carte = pyfirmata.Arduino('/dev/ttyACM0') # GNU/Linux
 print("Communication Carte Arduino établie")
 
 # Iterateur pour les entrees
@@ -30,22 +30,21 @@ it.start()
 
 # Fermer proprement la communication avec la carte Arduino lors de l'arret du programme
 def sigint_handler(signal, frame):
-    print ('Interruption du programme capturee.')
+    print ('Interruption du programme capturée.')
     carte.exit()
     time.sleep(1)
     sys.exit(0)
 
 ###############################################################################
-# Definition entrees - sorties
+# Definition entrées - sorties
 ###############################################################################
 
-# Definition entrees
+# Definition des 4 boutons
 bt_a = carte.get_pin('d:2:i')
 bt_r = carte.get_pin('d:3:i')
 bt_g = carte.get_pin('d:4:i')
 bt_d = carte.get_pin('d:5:i')
 
-
 # led = carte.get_pin('d:13:o')
 
 ###############################################################################
@@ -55,7 +54,7 @@ bt_d = carte.get_pin('d:5:i')
 while True:
     
     ##
-    # Manette
+    # 4 boutons
     ##
     
     if bt_a.read() == True and bt_r.read() == False:

labyrinthe/README.md

@@ -24,9 +24,9 @@ Il se décompose en 4 parties :
 
 ### Tutoriel 3 : Interfacer la scène 3D avec une carte Arduino - En cours d'écriture
 - Installer les bibliothèques pySerial et pyFirmata
-- Déplacer le plateau avec une manette (4 boutons binaires et/ou joystick) ; fichiers résultats : 3-1-labyrinthe-manette.blend,  3-1-labyrinthe-manette.py
-- Déplacer le plateau avec une centrale inertielle (IMU) ; fichiers résultats : 3-2-labyrinthe-imu.blend,  3-2-labyrinthe-imu.py, 3-2-labyrinthe-imu.ino
-- Déplacer le plateau avec un détecteur de geste ; fichiers résultats : 3-3-labyrinthe-gest.blend,  3-3-labyrinthe-gest.py, 3-3-labyrinthe-gest.ino
+- Déplacer le plateau avec une manette (4 boutons binaires et/ou joystick) ; fichiers résultats : 3-labyrinthe-manette.blend,  3-labyrinthe-manette.py
+- Déplacer le plateau avec une centrale inertielle (IMU) ; fichiers résultats : 3-labyrinthe-imu.blend,  3-labyrinthe-imu.py, 3-labyrinthe-imu.ino
+- Déplacer le plateau avec un détecteur de geste ; fichiers résultats : 3-labyrinthe-gest.blend,  3-labyrinthe-gest.py, 3-labyrinthe-gest.ino
 
 ### Tutoriel 4 : Interfacer la scène 3D avec une carte micro:bit - En cours d'écriture
 - Installer la bibliothèque pySerial