ropy/rp_map1.py

242 lines
11 KiB
Python
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import bge # Bibliothèque Blender Game Engine (UPBGE)
import bpy # Blender
from rp_lib import * # Bibliothèque Ropy
import os
###############################################################################
# rp_map1.py
# @title: Carte 1 pour Ropy
# @project: Ropy (Blender-EduTech)
# @lang: fr
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
# @copyright: Copyright (C) 2020-2022 Philippe Roy
# @license: GNU GPL
#
###############################################################################
scene = bge.logic.getCurrentScene()
###############################################################################
# Missions
###############################################################################
missions_card_description ={}
missions_conf ={}
###############################################################################
# Initialisation du niveau :
# Niveau 1 : Les premiers pas de Ropy
# Niveau 2 : Ma première fonction
# Niveau 3 : Sécuriser Ropy
# Niveau 4 : Partir au bout du monde
# Niveau 5 : Faire face à l'inconnu
# Niveau 6 : Se rendre utile
###############################################################################
missions_card=["mission_1-card", "mission_2-card", "mission_3-card", "mission_4-card", "mission_5-card", "mission_6-card"]
# missions_card=["mission_1-card", "mission_2-card", "mission_3-card", "mission_4-card", "mission_5-card", "mission_6-card", "mission_7-card", "mission_8-card"]
# Mission 1
mission_1_title="Mission 1\n Premiers pas"
mission_1_text="\n \n Il faut aider Ropy à atteindre la case \n de l'objectif (à l'est de la station). \n"
mission_1_text= mission_1_text +" -> Voir onglet Rover, page \"Avancer\" \n"
mission_1_text= mission_1_text +" -> Voir onglet Rover, page \"Tourner \" \n\n"
mission_1_text= mission_1_text +"Afin de visualiser le trajet, il faudra \n marquer les cases. \n"
mission_1_text= mission_1_text +" -> Voir onglet Rover, page \"Baliser\" \n"
mission_1_init=[-11.0,3.0, "e"] # Rover init position (x,y), orientation ("n|s|e|w")
mission_1_aim=[-7.0,2.0] # Aim position (x,y)
missions_card_description.update({"mission_1-card" : [mission_1_title, mission_1_text]})
missions_conf.update({"1" : [mission_1_init, mission_1_aim]})
# Mission 2
mission_2_title="Mission 2\n Ma première fonction"
mission_2_text= "\n \n Pour faciliter le codage, vous allez \n créer la fonction \"mrp_avancer()\" \n regroupant avancer et marquer. \n -> Voir onglet Python, page \"Fonction\"."
mission_2_init=[-11.0,3.0, "e"] # Rover init position (x,y), orientation ("n|s|e|w")
mission_2_aim=[-7.0,2.0] # Aim position (x,y)
missions_card_description.update({"mission_2-card" : [mission_2_title, mission_2_text]})
missions_conf.update({"2" : [mission_2_init, mission_2_aim]})
# Mission 3
mission_3_title="Mission 3\n Apprendre le danger"
mission_3_text="\n \n Tout d'abords, il faut provoquer une \n collision avec un obstacle (pente \n ou station) et observer ce qui se \n passe.\n \n"
mission_3_text= mission_3_text + " Il faut donc sécuriser Ropy en utilisant \n une structure alternative. \n -> Voir onglet Python, page \"Si alors\" \n -> Voir onglet Rover, page \"Détecter\" \n \n"
mission_3_init=[-11.0,3.0, "e"] # Rover init position (x,y), orientation ("n|s|e|w")
mission_3_aim=[100.0,100.0] # Aim caché
missions_card_description.update({"mission_3-card" : [mission_3_title, mission_3_text]})
missions_conf.update({"3" : [mission_3_init, mission_3_aim]})
# Mission 4
mission_4_title="Mission 4\n Partir au bout du monde"
mission_4_text="\n \n Ropy est maintenant prêt pour \n l'aventure soit atteindre la case \n du nouvel objectif (loin, très loin ...). \n \n Pour un tel voyage, l'utilisation \n d'une boucle s'impose. \n"
mission_4_text= mission_4_text +" -> Voir onglet Python, page \"Boucle\" \n \n \n \n \n"
mission_4_init=[-7.0,4.0, "s"] # Rover init position (x,y), orientation ("n|s|e|w")
mission_4_aim=[12.0,9.0] # Aim position (x,y)
missions_card_description.update({"mission_4-card" : [mission_4_title, mission_4_text]})
missions_conf.update({"4" : [mission_4_init, mission_4_aim]})
# Mission 5
mission_5_title="Mission 5\n Faire face à l'inconnu"
mission_5_text="\n \n La case à atteindre est toujours la \n même, mais le lieu de départ change \n à chaque fois. \n \n"
mission_5_text= mission_5_text +" Pour pallier à l\'aléatoire, vous \n utiliserez les pentes (obstacle) du \n terrain."
mission_5_text= mission_5_text +" Il faudra alors créer une \n fonction avec une boucle \"tant que\" \n qui permet d'avancer jusqu'à un \n obstacle :"
mission_5_text= mission_5_text +" \"mrp_avancer_mur()\". \n \n \n"
mission_5_init=[-7.0,4.0, "s"] # Rover init position (x,y), orientation ("n|s|e|w")
mission_5_aim=[12.0,9.0] # Aim position (x,y)
missions_card_description.update({"mission_5-card" : [mission_5_title, mission_5_text]})
missions_conf.update({"5" : [mission_5_init, mission_5_aim]})
# Mission 6
mission_6_title="Mission 6\n Se rendre utile"
mission_6_text="\n \n Une zone précise du terrain présente \n des pierres à analyser. \n \n Elles apparaissent de manière \n aléatoire (encore ...), pour les \n ramasser, Ropy doit passer sur toutes \n les cases de la zone. \n \n \n \n \n \n \n"
mission_6_init=[-11.0,3.0, "e"] # Rover init position (x,y), orientation ("n|s|e|w")
mission_6_aim=[9.0,11.0] # Aim position (x,y) # FIXME plusieurs objectifs avec des positions aléatoires
missions_card_description.update({"mission_6-card" : [mission_6_title, mission_6_text]})
missions_conf.update({"6" : [mission_6_init, mission_6_aim]})
# Mission 7
# mission_7_title="Mission 7\n FIXME"
# mission_7_text="\n \n FIXME"
# missions_card_description.update({"mission_7-card" : [mission_7_title, mission_7_text]})
# missions_conf.update({"7" : [mission_7_init, mission_7_aim]})
# Mission 8
# mission_8_title="Mission 8\n FIXME"
# mission_8_text="\n \n FIXME"
# missions_card_description.update({"mission_8-card" : [mission_8_title, mission_8_text]})
# missions_conf.update({"8" : [mission_8_init, mission_8_aim]})
# Description des cartes missions
def get_missions_card():
return missions_card
def get_card_description():
return missions_card_description
###############################################################################
# Map
###############################################################################
# Initialization
def map_init():
scene.objects['Terrain']['size'] = [-15,-11,15,10] # Map size
scene.objects['Terrain']['map_tile_montain']= []
scene.objects['Terrain']['map_tile_station']= [[-9,2],[-9,3]]
for obj_i in scene.objects:
if "terrain_sideCliff" in obj_i.name or "terrain_sideCorner" in obj_i.name or "terrain_sideCornerInner" in obj_i.name:
scene.objects['Terrain']['map_tile_montain'].append([round(obj_i.worldPosition.x), round(obj_i.worldPosition.y)])
# print (scene.objects['Terrain']['map_tile_montain'])
# i=0
# for i_xy in scene.objects['Terrain']['map_tile_montain']:
# beacon= scene.addObject("Beacon", scene.objects['Terrain'])
# beacon.worldPosition=[i_xy[0],i_xy[1],0.2]
# beacon.setVisible(True, True)
# i+=1
# Landscape
# file_path = 'asset/map/map1-landscape.blend'
# inner_path = 'Object'
# object_name = 'Landscape'
# bpy.ops.wm.append(
# filepath=os.path.join(file_path, inner_path, object_name),
# directory=os.path.join(file_path, inner_path),
# filename=object_name)
# Reset de la map
def map_reset():
scene.objects['Points']['step']=0
scene.objects['Points']['nbligne']=0
mission_init = missions_conf[str(scene.objects['Points']['mission'])][0]
mission_aim = missions_conf[str(scene.objects['Points']['mission'])][1]
# Cacher les balises
for i in range (100):
beacon = scene.objects["Beacon-"+str(i)]
beacon.worldPosition=[29,1+i,0.2]
beacon.setVisible(False,True)
beacon['activated']=False
scene.objects['Terrain']['map_tile_beacon']= []
# Initialisation du rover
obj = scene.objects['Rover']
obj.worldPosition.x = mission_init[0]
obj.worldPosition.y = mission_init[1]
obj.worldPosition.z = 0.2
applyRotationTo(obj, 0, 0, 0, True)
if mission_init[2] == "n":
obj.applyRotation((0, 0, math.pi), True)
if mission_init[2] == "e":
obj.applyRotation((0, 0, math.pi/2), True)
if mission_init[2] == "w":
obj.applyRotation((0, 0, -math.pi/2), True)
# Initialisation des objectifs
scene.objects['Terrain']['map_aim']= [[mission_aim[0],mission_aim[1]]]
obj_aim = scene.objects['Map_aim']
obj_aim.worldPosition.x = mission_aim[0]
obj_aim.worldPosition.y = mission_aim[1]
obj_aim.worldPosition.z = 0.5
###############################################################################
# Objectif
###############################################################################
def aim_show():
if scene.objects['Points']['mission']==3 :
scene.objects['Map_aim'].setVisible(False,True)
else:
scene.objects['Map_aim'].setVisible(True,True)
def aim_hide():
scene.objects['Map_aim'].setVisible(False,True)
def objectif_control(x,y):
if scene.objects['Points']['mission']==3:
return False
else:
if [x,y] in scene.objects['Terrain']['map_aim']:
return True
else:
return False
return False
###############################################################################
# Fonction bas niveau
###############################################################################
##
# Atteindre une orientation
##
def applyRotationTo(obj, rx=None, ry=None, rz=None, Local=True):
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), Local)
if rx-obj.worldOrientation.to_euler().x > rres:
obj.applyRotation((rres, 0, 0), Local)
# 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), Local)
if ry-obj.worldOrientation.to_euler().y > rres:
obj.applyRotation((0, rres, 0), Local)
# 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), Local)
if rz-obj.worldOrientation.to_euler().z > rres:
obj.applyRotation((0, 0, rres), Local)
# print ("delta z ",rz-obj.worldOrientation.to_euler().z)