Rotation de Labyrinthe

Projet

a marqué ce sujet comme résolu.

Bonjour à tous, Je suis en licence d’informatique et on a comme projet de fin d’année la création jeu, un labyrinthe. Il faut donc évidemment pouvoir y jouer et donc modéliser un labyrinthe et tous plein de chose. Cependant mon groupe et moi on bloque sur la rotation de ce dernier, pour faire court il faut faire avancer le personnage non pas en le bougeant mais en effectuant une rotation de labyrinthe (oui je sais c’est compliqué). Donc si quelqu’un est chaud en informatique on aimerai beaucoup un petit coup de main, merci beaucoup à ceux qui prendrons le temps de lire ça 😃 Le code:

g = [["."for i in range(10)]for i in range(10)]

    def placement(grille, objet):

       grille[r(0,9)][r(0,9)]=objet.symbole

       return afficher(grille)

    def mouvement(labyrinthe, direction):
      if direction == "gauche" or "haut":
        truc = -1
      else:
        truc = 1
      for ligne in range(len(labyrinthe)):
       for colonne in range(ligne):

          if labyrinthe[ligne][colonne] != ".":
             deplacement = truc
             deplacement = truc * a_qui(labyrinthe[ligne][colonne]).glissant

             if deplacement != 0:
                 if direction == "gauche" or direction == "droite":
                     nouvelle_case = [ligne,colonne+deplacement]
                 else:
                     nouvelle_case = [ligne+deplacement,colonne]

                 if nouvelle_case[0]> len(labyrinthe):
                     nouvelle_case[0] = len(labyrinthe)-1
                 if nouvelle_case[0]< 0:
                     nouvelle_case[0] = 0
                 if nouvelle_case[1] > len(labyrinthe[1]):
                     nouvelle_case[0] = len(labyrinthe[1])-1
                 if nouvelle_case[1] < 0:
                     nouvelle_case[1] = 0
                 print(nouvelle_case)

    Labyrinthe[nouvelle_case[0]][nouvelle_case[1]] = a_qui(labyrinthe[ligne][colonne]).symbole
    labyrinthe[ligne].[colonne] = "."
    return afficher(labyrinthe)

    class Trou:
      def __init__(self):
         self.glissant = 0
         self.symbole = "@"
         #self.position = position
         recouvert = False

    '''def tombe(self, position_du_personnage):
        if position == position_du_personnage:
            self.recouvert = True
            return self.recouvert
        else:
            return False'''

    class Boule:
      def __init__(self):
         self.glissant = 3
         self.symbole = "O"


    def a_qui(symbole):
      if symbole == "@":
         return Trou()
      return Boule()

    def afficher(labyrinthe):
      for i in labyrinthe:
         for j in i:
            print(j, end=" ")
         print("")
+0 -0

Salut,

Il y a deux choses que je ne comprends pas tout à fait dans ton post:

  • le personnage ne se déplace pas en marchant mais en faisant des rotations de labyrinthes. Mais des rotations ne lui permettront jamais d’avancer. A un moment, il faut une translation (soit du personnage, soit du labyrinthe). Donc comment ton personnage est censé avancer?
  • Où bloques-tu exactement ?

Une façon de faire qui pourrait fonctionner est de créer ton labyrinthe puis dans un tableau, tu gardes 4 versions de celui-ci (un par orientation). Ensuite, quand tu dois faire une rotation, tout ce qu’il te reste à faire est d’utiliser un autre labyrinthe dans ton tableau.

Déjà merci de vos réponses ! C’est tout à fait ça Aabu, un labyrinthe à bille. Alors en faite l’idée c’est une rotation labyrinthe avec gravité. En gros il y a une gravité et en tournant le labyrinthe la gravité changerai, je sais c’est chiant je pourrais juste faire bouger la bille/personnage mais c’est pas la consigne on doit vraiment faire bouger le personnage/bille en faisant bouger le labyrinthe. Bah écoute je bloque dans la rotation mon code ne fonctionne et je comprends pas où est la faute, pour moi tous me semble bon

La première chose, c’est ce que dit Migwel, c’est que tu dois gérer en principe 2 types de mouvement : le mouvement 'Pas en avant’, et le mouvement 'Quart-de-tour’. Avec en plus la notion 'Quart-de-tour-a-droite' et 'Quart-de-tour-a-gauche’, mais c’est la même fonction sur le fond.

Quand tu as les 2 fonctions qui te permettent de gérer ça, peut-être que ton choix, ce sera de dire qu’un quart de tour est systématiquement suivi d’un pas en avant, et qu’on ne veut pas afficher la situation intermédiaire. Ok, pas de problème. Mais ça ne change rien, tu as besoin de ces 2 fonctions.

Dans une version 2, pour optimiser les traitements, il faudrait faire une fonction qui fusionne ces 2 actions. Mais c’est beaucoup de complications, pour un bénéfice quasi-nul.

Tu as 2 options. Et il faut que tu choisisses une des 2 options, pas que tu tergiverses entre les 2.

Option 1. Tu as un tableau qui contient le contenu du labyrinthe, ce tableau ne change jamais. Et tu dois alors une fonction qui gère l’affichage de ce tableau, et qui va être compliquée. Cette fonction aura besoin de plusieurs paramètres :

  • le contenu du labyrinthe , évidemment.

  • la case à positionner en bas au centre de l’écran.

  • La direction à afficher : Nord Sud Est ou Ouest ; j’emploie ces 4 mots plutôt que gauche droite devant derrière, j’espère que tu vois à quel point ils sont mieux adaptés.

Option 2 : Tu as un tableau, qui contient le descriptif du labyrinthe. Et à chaque mouvement, ou à chaque quart de tour, tu modifies complètement le contenu de ce tableau. Systématiquement, tout le contenu de ce tableau est relatif à la position du joueur, le joueur est toujours à la position (0,0) et regarde toujours vers le haut de l’écran, c’est le sol qui se déplace sous lui.

Dans ce cas, la fonction qui va permettre d’afficher le labyrinthe à l’écran sera très facile, mais la fonction qui va devoir gérer chaque mouvement ou chaque quart de tour sera complexe.

A mon avis, au final, l’option 1 est plus simple (mais je ne suis pas sûr).

Au vu de tes explications, je pense que tu as choisi l’option 2.

L’option 2 est compliquée. Si ton labyrinthe est un tableau[50,60], tu as besoin d’un 2ème tableau Labyrinthe_nouveau [60,50]

Les dimensions [50,60] deviennent [60,50]

Et normalement, il te faut 2 boucles consécutives :

  • Une boucle sur les 60*50 cases, pour mettre les bonnes valeurs dans le tableau labyrinthe_nouveau

  • Une boucle pour Copier purement et simplement le tableau labyrinthe_nouveau vers le tableau Labyrinthe, parce que l’objet que tu manipules, c’est labyrinthe.

Cette 2ème boucle peut être évitée, si tu fais comme ça :

def laby_nouveau(laby , sens_de_rotation): 
   bla bla 
   return laby_nouv
laby= laby_nouveau(laby)

Edit : Bon, je vois cette histoire de labyrinthe à bille et du coup, je me demande si je ne suis pas totalement hors-sujet.

+1 -0

Merci pour ta réponse élégance ;) Et oui c’est ce que j’ai fait, regarde à la ligne 10 de mon code J’ai définis une fonction mouvement qui est en gros l’équivalent de ta fonction laby_nouv je crois Et pour mieux éclaircir mon code les class que j’ai créé servent à déterminer des frottements parce que je ne veux pas faire un simple labyrinthe mais je veux des « enemies » en gros, par exemple une boule qui sera là pour faire perdre le joueur sera donc plus lourde et donc plus rapide que le joueur, c’est ça la class à la fin de mon code. Mais en gros je bloque parce que ça ne fonctionne pas, je sais pas si c’est par que j’ai surenchéri sur les « if » ou si la class boule par exemple fait bugger le tout

+0 -0

J’allais justement intervenir pour parler de cette ligne 10, car elle ne fait pas ce que tu penses : la condition est toujours vraie.

direction == "gauche" or "haut" est en effet une expression équivalente à (direction == "gauche") or "haut" qui est toujours vraie (car elle s’interprète comme « direction est égal à "gauche" ou "haut" est une chaîne non-vide »).

Il faudrait alors écrire direction == "gauche" or direction == "haut" ou direction in {"gauche", "haut"} pour avoir le bon comportement.

Aussi ligne 46 tu assignes une variable recouvert qui n’est jamais utilisée et est donc perdue. Tu ne voulais pas plutôt assigner la valeur à l’attribut self.recouvert ?

Enfin je te conseille d’essayer d’arriver à un prototype fonctionnel avant de tenter d’introduire d’autres éléments comme des ennemis.

                 if nouvelle_case[0]> len(labyrinthe):
                     nouvelle_case[0] = len(labyrinthe)-1
                 if nouvelle_case[0]< 0:
                     nouvelle_case[0] = 0

Les 2 dernières lignes disent de ramener au bord quand on dépasse le bord.

Les 2 premières disent de ramener au bord quand on dépasse le bord d’au moins 2 unités.

                  if nouvelle_case[1] > len(labyrinthe[1]):
                     nouvelle_case[0] = len(labyrinthe[1])-1

Si le contenu de la variable nouvelle_case[1] est incohérent, alors modifier le contenu de … zut , on modifie une autre variable que celle qui était incohérente.

+1 -0
 Bonjour, 

Je reviens à vous, je voulais vérifier avant de faire tous messege de remerciement, mais après essaie avec vos conseils je n’arrive toujours pas à avoir la chose voulue, mais il y a du mieux. En gros mtn je peux me déplacer à gauche ou en haut mais je n’arrive toujours pas à me déplacer en bas ou à droite. Si quelqu’un a une idée je suis preneur Merci encore pour vos réponses et merci d’avance Bonne soirée

Je reviens à vous, je voulais vérifier avant de faire tous messege de remerciement, mais après essaie avec vos conseils je n’arrive toujours pas à avoir la chose voulue, mais il y a du mieux. En gros mtn je peux me déplacer à gauche ou en haut mais je n’arrive toujours pas à me déplacer en bas ou à droite.

Richaumefr

Les différents types de déplacements me semblent assez similaire, est-ce que tu as réussi à identifier pourquoi ça se passait différemment pour les deux derniers ?

Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte