ropy/rp_map1.py

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 La case à atteindre est toujours la \n même (à l'est de la station). \n \n"
mission_2_text= mission_2_text + " Pour faciliter le codage, vous devez \n créer et utiliser la fonction \n \"mrp_avancer()\" regroupant avancer \n et marquer. \n -> Voir onglet Python, page \"Fonction\". \n\n\n\n\n"
mission_2_init=[-11.0,3.0, "e"]
mission_2_aim=[-7.0,2.0]
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 \n utilisant 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"]
mission_4_aim=[12.0,9.0]
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"] # FIXME position aléatoire
mission_5_aim=[12.0,9.0]
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 \n toutes les cases de la zone. \n \n \n \n \n \n \n"
mission_6_init=[-7.0,4.0, "s"] # FIXME position aléatoire
mission_6_aim=[9.0,11.0] # 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
###############################################################################

##
# Afficher l'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)

##
# Cacher l'objectif
##

def aim_hide():
    scene.objects['Map_aim'].setVisible(False,True)

##
# Validation de l'objectif atteint
##
    
def objectif_control(x,y):

    # Mission 1
    if scene.objects['Points']['mission']==1:
        if [x,y] in scene.objects['Terrain']['map_aim']: # Aim
            if len(scene.objects['Terrain']['map_tile_beacon'])>=6: # 6 balises posées mini
                return True

    # Mission 2 (fonction)
    if scene.objects['Points']['mission']==2:
        if [x,y] in scene.objects['Terrain']['map_aim']: # Aim
            if len(scene.objects['Terrain']['map_tile_beacon'])>=6: # 6 balises posées mini
                if scene.objects['Points']['nbligne'] <=40: # 40 lignes de code maxi
                    txt=["def mrp_avancer():", "def mrp_avancer() :", "def mrp_avancer ():", "def mrp_avancer () :"] # Présence de "def mrp_avancer():"
                    if rp_cmd_txtcount(txt):
                        return True

    # Mission 3 (structure alternative)
    # Le controle de l'objectif est dans la fonction rp_detect(). 

    # Mission 4 (boucle en for)
    if scene.objects['Points']['mission']==4:
        if [x,y] in scene.objects['Terrain']['map_aim']: # Aim
            if scene.objects['Points']['nbligne'] <=40: # 40 lignes de code maxi
                return True

    # Mission 5 (boucle en while)
    if scene.objects['Points']['mission']==5:
        return False

    # Mission 6 (passer sur tout le terrain)
    if scene.objects['Points']['mission']==6:
        return False

    return False


###############################################################################
# Fonction bas niveau
###############################################################################

##
# Recherche de texte dans le script 
##

def rp_cmd_txtcount (text_list):
    # print (os.getcwd())
    file = open('rp_cmd.py', 'r')
    file_txt = file.read()
    print (file_txt)
    for text in text_list:
        # print ("text :", text)
        # print ("file_txt.count (text) :", file_txt.count (text))
        if file_txt.count (text) >0:
            # print ("Recherche de ",text," dans le script 'rp_cmd.py' -> True")
            file.close()
            return True
        # else:
        # print ("Recherche de ",text," dans le script 'rp_cmd.py' -> False")
    file.close()
    return False

##
# 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)