374 lines
15 KiB
Python
374 lines
15 KiB
Python
import bge # Bibliothèque Blender Game Engine (BGE)
|
|
import math
|
|
import time
|
|
|
|
###############################################################################
|
|
# ropy_lib.py
|
|
# @title: Bibliothèque du Robot Ropy (rp_*)
|
|
# @project: Ropy du projet Blender-EduTech
|
|
# @lang: fr
|
|
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
|
|
# @copyright: Copyright (C) 2020-2022 Philippe Roy
|
|
# @license: GNU GPL
|
|
#
|
|
# Bibliothèque des actions du robot
|
|
# Bibliothèque pour la construction des murs
|
|
#
|
|
# Ropy est destiné à la découverte de la programmation procédurale et du language Python.
|
|
# A travers plusieurs challenges, donc de manière graduée, les élèves vont apprendre à manipuler les structures algorithmiques de base et à les coder en Python.
|
|
#
|
|
###############################################################################
|
|
|
|
# Récupérer l'objet robot
|
|
|
|
cont = bge.logic.getCurrentController()
|
|
obj = cont.owner
|
|
scene = bge.logic.getCurrentScene()
|
|
nb_objets_fixes = len(scene.objects)
|
|
# print ("Nombre d'objets fixes de la scene : ", nb_objets_fixes)
|
|
print("Objets de la scene : ", scene.objects)
|
|
|
|
# Configuration des mouvements
|
|
|
|
pas=3 # Pas linéaire
|
|
pas_rot=math.pi/2 # Pas angulaire
|
|
|
|
###############################################################################
|
|
# Initialisation de la position du robot
|
|
###############################################################################
|
|
|
|
# Position initiale du robot
|
|
def rp_init_position():
|
|
x = obj['x_init']
|
|
y = obj['y_init']
|
|
obj.worldPosition.x = -((y-4.5)*3)+3
|
|
obj.worldPosition.y = (x-5.5)*3
|
|
obj.worldPosition.z = 1.25
|
|
print('\x1b[6;30;47m', "Placer le robot case (X,Y) :", x, y, '\x1b[0m')
|
|
|
|
#MODIF
|
|
obj['x'],obj['y'] = x,y
|
|
obj['d'] = 1 #est
|
|
|
|
# Pile des mouvements
|
|
# obj['mvts'] = ""
|
|
# obj['mvt_i'] = 0
|
|
|
|
# Répérer le robot détruit
|
|
if obj['detruit']:
|
|
start = 300
|
|
end = start+75
|
|
layer = 0
|
|
priority = 1
|
|
blendin = 1.0
|
|
mode = bge.logic.KX_ACTION_MODE_PLAY
|
|
layerWeight = 0.0
|
|
ipoFlags = 0
|
|
speed = 3
|
|
scene.objects['Armature'].playAction('ArmatureAction.Saut.001', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
# scene.objects['Body'].playAction('BodyAction.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
# scene.objects['Eyes_glass'].playAction('Eyes_glassAction.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
# scene.objects['Mouth'].playAction('MouthAction.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
# scene.objects['Jetpack'].playAction('JetpackAction.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
scene.objects['poignee1'].playAction('poignee1Action.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
scene.objects['poignee2'].playAction('poignee2Action.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
scene.objects['poignee3'].playAction('poignee3Action.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
scene.objects['poignee4'].playAction('poignee4Action.Saut', start, end, layer, priority, blendin, mode, layerWeight, ipoFlags, speed)
|
|
obj['detruit']=False
|
|
|
|
###############################################################################
|
|
# Affichage
|
|
###############################################################################
|
|
|
|
#Afficher position
|
|
def rp_print_position():
|
|
print('\x1b[6;30;42m', "Position case (X,Y) : ", round(-obj.worldPosition.x/3+5.5), round(obj.worldPosition.y/3+5.5), '\x1b[0m')
|
|
|
|
###############################################################################
|
|
# Moteur physique
|
|
# Détection des collisions aves les murs
|
|
###############################################################################
|
|
|
|
# Détection d'une collision
|
|
# rpcore_ : fonction bas niveau
|
|
def rpcore_detect_mur(debug_flag=False):
|
|
|
|
# Vecteur du mouvement
|
|
#MODIF
|
|
init_x,init_y = obj['x'],obj['y']
|
|
final_x,final_y = init_x,init_y
|
|
direction = obj['d']
|
|
if direction == 0: #nord
|
|
final_y+=1
|
|
elif direction == 1: #est
|
|
final_x+=1
|
|
elif direction == 2: #sud
|
|
final_y-=1
|
|
elif direction == 3: #ouest
|
|
final_x-=1
|
|
#init_x = round(obj.worldPosition.y/3+5.5)
|
|
#init_y = round(-obj.worldPosition.x/3+5.5)
|
|
#obj.applyMovement((0, -pas, 0), True)
|
|
#final_x = round(obj.worldPosition.y/3+5.5)
|
|
#final_y = round(-obj.worldPosition.x/3+5.5)
|
|
#obj.applyMovement((0, pas, 0), True)
|
|
|
|
# Calcul du centre du mouvement
|
|
mov_xc =init_x + (final_x - init_x)/2-0.5
|
|
mov_yc =init_y + (final_y - init_y)/2-0.5
|
|
if debug_flag:
|
|
print('\x1b[6;30;47m', "Mouvement (X_init,Y_init,X_final,Y_final) : ", init_x,init_y, final_x,final_y, '\x1b[0m')
|
|
print('\x1b[6;30;47m', "Mouvement (xc,yc) : ", mov_xc, mov_yc, '\x1b[0m')
|
|
|
|
# Test sur les murs exterieurs (10x10)
|
|
if ((final_x <1) or (final_y <1) or (final_x >10) or (final_y >10)):
|
|
if debug_flag:
|
|
print ("Détection de mur : mur détecté")
|
|
return True
|
|
|
|
# Test sur les murs intéreurs
|
|
else:
|
|
i=0
|
|
for mur in scene.objects:
|
|
i +=1
|
|
if mur.name=="Mur":
|
|
|
|
# Mur en X : calcul du centre du mur
|
|
if (round(mur.worldOrientation.to_euler().z,2) == round(math.pi,2)) or (round(mur.worldOrientation.to_euler().z,2) == round(-math.pi,2)):
|
|
mur_xc =mur['x1']
|
|
mur_yc =mur['y1']+0.5
|
|
|
|
# Mur en Y : calcul du centre du mur
|
|
elif (round(mur.worldOrientation.to_euler().z,2) == round(math.pi/2,2)) or (round(mur.worldOrientation.to_euler().z,2) == round(-math.pi/2,2)):
|
|
mur_xc =mur['x1']+0.5
|
|
mur_yc =mur['y1']
|
|
|
|
# Trace de debug
|
|
if debug_flag:
|
|
print('\x1b[6;30;47m', "Mur",mur['murId'],"X (x1,y1,x2,y2) : ", mur['x1'], mur['y1'], mur['x2'], mur['y2'], '\x1b[0m')
|
|
print('\x1b[6;30;47m', "Mur",mur['murId'],"Y (xc,yc) : ", mur_xc, mur_yc, '\x1b[0m')
|
|
|
|
# Même centre -> mouvement pas possible
|
|
if (mov_xc == mur_xc) and(mov_yc == mur_yc):
|
|
if debug_flag:
|
|
print ("Détection de mur : mur détecté")
|
|
return True
|
|
|
|
# Mouvement possible
|
|
if debug_flag:
|
|
print ("Détection de mur : pas de mur")
|
|
return False
|
|
|
|
|
|
# Fonction pour l'élève
|
|
def rp_detect_mur():
|
|
if rpcore_detect_mur() == True:
|
|
print('\x1b[6;30;45m', "Détection de mur : mur devant ! : Position case (X,Y): ", round(-obj.worldPosition.x/3+5.5), round(obj.worldPosition.y/3+5.5), '\x1b[0m')
|
|
return True
|
|
else:
|
|
print('\x1b[6;30;45m', "Détection de mur : voie libre : Position case (X,Y):", round(-obj.worldPosition.x/3+5.5), round(obj.worldPosition.y/3+5.5), '\x1b[0m')
|
|
return False
|
|
|
|
###############################################################################
|
|
# Mouvements
|
|
###############################################################################
|
|
|
|
# Avancer
|
|
def rp_avancer(debug_flag=False):
|
|
obj.visible=False
|
|
|
|
#MODIF
|
|
if obj['detruit']!=True and obj['d'] >= 0:
|
|
|
|
# Vecteur du mouvement
|
|
#MODIF
|
|
init_x,init_y = obj['x'],obj['y']
|
|
final_x,final_y = init_x,init_y
|
|
direction = obj['d']
|
|
if direction == 0: #nord
|
|
final_y+=1
|
|
elif direction == 1: #est
|
|
final_x+=1
|
|
elif direction == 2: #sud
|
|
final_y-=1
|
|
elif direction == 3: #ouest
|
|
final_x-=1
|
|
#init_x = round(obj.worldPosition.y/3+5.5)
|
|
#init_y = round(-obj.worldPosition.x/3+5.5)
|
|
#obj.applyMovement((0, -pas, 0), True)
|
|
#final_x = round(obj.worldPosition.y/3+5.5)
|
|
#final_y = round(-obj.worldPosition.x/3+5.5)
|
|
#obj.applyMovement((0, pas, 0), True)
|
|
|
|
# Test des murs
|
|
if rpcore_detect_mur(debug_flag) == True:
|
|
print('\x1b[6;30;41m', "Avancer case (X,Y) -> case (X,Y) :", init_x,",",init_y,"->",final_x,",",final_y, '\x1b[0m')
|
|
print('\x1b[6;30;41m', "Bling, blang ... L'aventure de Ropy s'arrête donc ici ...", '\x1b[0m')
|
|
obj['mvts'] = obj['mvts']+"c"
|
|
|
|
#MODIF
|
|
obj['d'] = -1
|
|
#obj['detruit']=True
|
|
else:
|
|
#MODIF
|
|
obj['x'],obj['y']=final_x,final_y
|
|
#obj.applyMovement((0, -pas, 0), True)
|
|
|
|
obj['mvts'] = obj['mvts']+"a"
|
|
print('\x1b[6;30;42m', "Avancer case (X,Y) -> case (X,Y) :", init_x,",",init_y,"->",final_x,",",final_y, '\x1b[0m')
|
|
|
|
# Test de l'objectif
|
|
i=0
|
|
for objectif in scene.objects:
|
|
i +=1
|
|
if objectif.name=="Objectif":
|
|
if objectif['x'] == final_x and objectif['y'] == final_y:
|
|
print('\x1b[6;30;42m', "Objectif atteint", '\x1b[0m')
|
|
obj['mvts'] = obj['mvts']+"o"
|
|
|
|
# Tourner à droite
|
|
def rp_droite():
|
|
# obj.visible=False
|
|
|
|
#MODIF
|
|
if obj['detruit']!=True and obj['d'] >= 0:
|
|
# scene.objects['Robot'].applyRotation((0, 0, -pas_rot), True)
|
|
|
|
#MODIF
|
|
#obj.applyRotation((0, 0, -pas_rot), True)
|
|
obj['d'] = (obj['d']+1)%4
|
|
|
|
obj['mvts'] = obj['mvts']+"d"
|
|
print('\x1b[6;30;42m', "Tourner à droite", '\x1b[0m')
|
|
# print("Orientation : ", obj.worldOrientation.to_euler().z)
|
|
|
|
# Tourner à gauche
|
|
def rp_gauche():
|
|
# obj.visible=False
|
|
|
|
#MODIF
|
|
if obj['detruit']!=True and obj['d'] >= 0:
|
|
# scene.objects['Robot'].applyRotation((0, 0, pas_rot), True)
|
|
|
|
#MODIF
|
|
obj['d'] = (obj['d']+3)%4
|
|
#obj.applyRotation((0, 0, pas_rot), True)
|
|
|
|
obj['mvts'] = obj['mvts']+"g"
|
|
print('\x1b[6;30;42m', "Tourner à gauche", '\x1b[0m')
|
|
# print("Orientation : ", obj.worldOrientation.to_euler().z)
|
|
|
|
# Orienter
|
|
def rp_orientation(orientation):
|
|
if orientation=="nord":
|
|
obj.applyRotation((0, 0, -obj.worldOrientation.to_euler().z-math.pi/2), True)
|
|
#MODIF
|
|
obj['d']=0
|
|
if orientation=="sud":
|
|
obj.applyRotation((0, 0, -obj.worldOrientation.to_euler().z+math.pi/2), True)
|
|
#MODIF
|
|
obj['d']=2
|
|
if orientation=="est":
|
|
obj.applyRotation((0, 0, -obj.worldOrientation.to_euler().z+math.pi), True)
|
|
#MODIF
|
|
obj['d']=1
|
|
if orientation=="ouest":
|
|
obj.applyRotation((0, 0, -obj.worldOrientation.to_euler().z), True)
|
|
#MODIF
|
|
obj['d']=3
|
|
# print("Orientation : ", obj.worldOrientation.to_euler().z)
|
|
|
|
###############################################################################
|
|
# Marquage du sol
|
|
###############################################################################
|
|
|
|
# Marquer une case
|
|
def rp_marquer():
|
|
if obj['detruit']!=True:
|
|
obj['mvts'] = obj['mvts']+"m"
|
|
if obj['mvts_start'] ==False : # à condition d'avoir terminé le mouvement
|
|
marque1= scene.addObject("Marque", obj)
|
|
marque1.worldPosition.x = obj.worldPosition.x
|
|
marque1.worldPosition.y = obj.worldPosition.y
|
|
marque1.worldPosition.z = 0.2
|
|
# print('\x1b[6;30;43m', "Marquer case (X,Y) :", round(obj.worldPosition.y/3+5.5),",",round(-obj.worldPosition.x/3+5.5), '\x1b[0m')
|
|
|
|
# Enlever l'ensemble des murs et des marques
|
|
def rp_enlever_marques():
|
|
print ("")
|
|
print ("Table rase !")
|
|
for i in range (nb_objets_fixes, len(scene.objects)):
|
|
scene.objects[i].endObject()
|
|
|
|
###############################################################################
|
|
# Construction du niveau
|
|
###############################################################################
|
|
|
|
# Définition du niveau
|
|
def rp_niveau (niveau=0):
|
|
obj['level'] =niveau
|
|
|
|
# Construire les murs
|
|
# Longueur : fixe d' une case
|
|
# Position des murs : liste imbriquée : [[mur1_x1,mur1_y1,mur1_x2,mur1_y2],[mur2_x1,mur2_y1,mur2_x2,mur2_y2], ...]
|
|
# FIXME : verifier si les murs sont dans la zone 10x10
|
|
# FIXME : intervertir l'ordre des coordonnéees
|
|
# FIXME : verifier si le mur est d'une case
|
|
def rp_construire_murs (def_murs):
|
|
# print("Objets de la scene : ", scene.objects)
|
|
i=0
|
|
for def_mur in def_murs:
|
|
i +=1
|
|
# print (def_mur)
|
|
|
|
# Mur en X
|
|
if def_mur[0] == def_mur[2]:
|
|
mur1= scene.addObject("Mur", obj)
|
|
mur1['murId'] = i
|
|
mur1['x1'] = def_mur[0]
|
|
mur1['y1'] = def_mur[1]
|
|
mur1['x2'] = def_mur[2]
|
|
mur1['y2'] = def_mur[3]
|
|
# print ("mur ", 0)
|
|
# mur1.applyRotation((0, 0, -obj.worldOrientation.to_euler().z), True)
|
|
# mur1.applyRotation((0, 0, -math.pi/2), True)
|
|
# mur1.applyRotation((0, 0, -obj.worldOrientation.to_euler().z), True)
|
|
|
|
# mur1.worldOrientation.to_euler().z = 0
|
|
mur1.worldPosition.x = -((def_mur[1]-4.5)*3)
|
|
mur1.worldPosition.y = ((def_mur[0]-5.5)*3)+1.5
|
|
mur1.worldPosition.z = 1.5
|
|
print('\x1b[6;30;47m', "Construire mur X",mur1['murId'],"coordonnées (x1,y1,x2,y2) :", def_mur[0], def_mur[1], def_mur[2], def_mur[3], '\x1b[0m')
|
|
|
|
# Mur en Y
|
|
elif def_mur[1] == def_mur[3]:
|
|
mur2= scene.addObject("Mur", obj)
|
|
mur2['murId'] = i
|
|
mur2['x1'] = def_mur[0]
|
|
mur2['y1'] = def_mur[1]
|
|
mur2['x2'] = def_mur[2]
|
|
mur2['y2'] = def_mur[3]
|
|
# print ("mur ", -obj.worldOrientation.to_euler().z-math.pi/2)
|
|
mur2.applyRotation((0, 0, -obj.worldOrientation.to_euler().z-math.pi/2), True)
|
|
# print ("mur ", math.pi/2)
|
|
# mur2.applyRotation((0, 0, -math.pi), True)
|
|
# mur2.worldOrientation.to_euler().z = math.pi/2
|
|
|
|
mur2.worldPosition.x = -((def_mur[1]-5.5)*3)-1.5
|
|
mur2.worldPosition.y = ((def_mur[0]-4.5)*3)
|
|
mur2.worldPosition.z = 1.5
|
|
print('\x1b[6;30;47m', "Construire mur Y",mur2['murId'],"coordonnées (x1,y1,x2,y2) :", def_mur[0], def_mur[1], def_mur[2], def_mur[3], '\x1b[0m')
|
|
else:
|
|
print ('\x1b[6;30;41m', "Mur ni sur X ni sur Y !", '\x1b[0m')
|
|
|
|
# Marquer l'objectif
|
|
def rp_marquer_objectif (x,y):
|
|
objectif1= scene.addObject("Objectif", obj)
|
|
objectif1.worldPosition.x = -((y-4.5)*3)+3
|
|
objectif1.worldPosition.y = (x-5.5)*3
|
|
objectif1.worldPosition.z = 0.2
|
|
objectif1['x'] = x
|
|
objectif1['y'] = y
|
|
print('\x1b[6;30;47m', "Marquer l'objectif case (X,Y) :", x,y, '\x1b[0m')
|
|
|