Bonsoir à tous codeuses et codeurs,

Je suis en terminale S et j'ai à rendre mon rapport de l'option Informatique et Science du Numérique (ISN) dans peu de temps. Cette option consiste à apprendre les bases de la programmation et à aboutir à un projet de fin d'année. Le langage abordé est le langage Python et s'orientant facilement (pour ceux qui souhaitent coder dans un interface graphique bien sûre) vers le module Pygame. 

Avec mon binôme, nous avons créé un jeu en s'inspirant des jeux "ROGUE-LIKE" sur Python (Pygame). Comme partout, quand on laisse quelque chose de côter et qu'on essaye de le reprendre.. on oublie facilement. C'est un peu près ce qui s'est passé pour notre code..

N'ayant pas des compétences aiguës dans la programmation (débuté cette année) et une ambition de créer des jeux "balèzes"! Nous nous sommes beaucoup fait aidé par les professeurs et des amis plus à l'aise dans ce domaine. Sur ce, je tiens à dire que l'entente n'était pas du tout sournoise et que le but recherché n'était pas de laisser le travail aux autres.. Nous avons pris beaucoup de temps et de plaisir à chercher des solutions pendant de longues heures!

C'est donc en se replongeant dans notre programme que nous nous sommes posé des questions à propos d'une syntaxe particulières:

Bien sûre, il n'est pas la peine de nous dire que il existe des millions d'autres possibilités pour faire ce que nous avons fait puisque il est évident que c'est le cas, mais peu importe.. 

Nous avons donc dans notre jeu, un personnage qui se déplace! Oui et bien ce personnage se déplace grâce à une fonction (avec paramètres) et après plusieurs essais non concluant nous en sommes arrivés à quelque chose qui marche!! Mais le problème étant que nous avons des difficultés pour comprendre le comment du pourquoi.. 

Alors, voici notre code (pas au complet mais les parties concernées par le problème) :

Voici une salle de notre donjon:

tl1 = [                                                
[n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n],
[n,c,c,c,c,c,c,c,c,c,m,c,c,c,c,c,c,c,n],
[n,c,c,c,c,c,m,m,c,c,c,c,c,c,c,c,t,c,n],
[n,c,c,c,c,c,m,m,c,c,c,c,c,c,m,m,m,c,n],
[n,c,m,m,m,c,c,c,m,m,m,m,m,m,m,m,m,c,n],
[n,c,c,c,c,c,m,m,m,m,c,c,c,c,c,m,c,c,n],
[n,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,n],
[n,c,c,c,c,c,c,c,c,c,c,c,c,c,m,m,m,m,n],
[n,m,m,m,m,m,c,c,c,c,m,m,m,m,m,m,m,m,n],
[n,c,c,c,c,c,c,m,m,c,c,c,c,c,m,c,m,c,n],
[n,n,n,n,n,n,n,n,n,p,n,n,n,n,n,n,n,n,n]]

Voici notre fonction pour le déplacement:

def deplacement(position,direction):
 
    new_position = (position[0]+direction[0] , position[1]+direction[1])
 
    if 0 <= new_position[0] < len(tableau[0]) and 0 <= new_position[1] < len(tableau):
        if tableau[new_position[1]][new_position[0]] != m and tableau[new_position[1]][new_position[0]] != n:
            return new_position
        else: return position
 
    elif tableau[position[1]][position[0]] == p:
        if direction==(1,0):
            changement_map('est')
            return (new_position[0]-len(tableau[0]) , new_position[1])
        if direction==(-1,0):
            changement_map('ouest')
            return (new_position[0]+len(tableau[0]) , new_position[1])
        if direction==(0,1):
            changement_map('sud')
            return (new_position[0] , new_position[1]-len(tableau))
        if direction==(0,-1):
            changement_map('nord')
            return (new_position[0] , new_position[1]+len(tableau))
 
    else: return position

Ce qui nous préoccupe, c'est donc les "indices" entre crochet comme "position_perso[1]" ?! 

Nous avons donc posé les choses sur papier! Rien de tel pour comprendre et nous en avons conclu qu'il s'agissait de d'une coordonnée spécifique dans notre tableau (mis au dessus), soit à un Y, soit à un X, selon l'indice [0] ou [1].

Mais nous n'en sommes pas sûr et nos recherches sur internet n'ont pas été fructueuses, c'est pourquoi nous faisons référence ici, sur le site du notre zéro favori

Si les éléments fournis ici ne sont pas exhaustifs, veuillez avoir l’amabilité de m'envoyer un mail.

pierrebaptiste.lanvin@gmail.com

-
Edité par Codeur702 16 mai 2014 à 12:21:46

Avec ce que tu nous as fourni effectivement les tableau[position][position] correspondent bien à une case de ta map.

La nouvelle position est définie avec la somme entre ta position actuelle et ta direction. Se sont tout les deux des tuples de la forme (X,Y).

On vient ici tester plusieurs possibilité :

- Si ton personage est dans la map

             - Si il essaye d'avancer sur une case autre que m ou n alors le mouvement est autoriser

             - Sinon il reste à sa position

- Si ton personage doit arriver sur une case p, alors on observe direction pour savoir par quelle porte il est passer

- Si aucune des deux proposition si dessus n'est vrai, alors il ne bouge pas.

J'ai répondu à ta question ? N'hésite pas !

(Met ton code entre balise Steuplé ' , je suis vieux j'ai 20 ans j'arrive pas à le lire sinon )

-
Edité par MonsieurVaros 16 mai 2014 à 10:17:59

Pas de soucis, il faut que je j'apprivoise un peu les outils de l'éditeur etc.. 

D'accord merci beaucoup pour ta réponse jordanscandola1, alors quand j'ai une parenthèse (tuple c'est bien ça?) avec par exemple: position_perso = (9,5) , le 9 va correspondre à un X dans le tableau et donc correspondre à position[0], le zéro étant l'indice du premier élément du tuple ou de la liste selon ce qu'on a choisi. 

On à un autre petit problème de lecture à ce niveau-ci : 

temps_boucle=[0,0]



cooldown_max_ia=1

cooldown_ia=cooldown_max_ia



cooldown_max=0.2

cooldown=0

while continuer:

# calcul du temps de la boucle :

    temps_boucle += [pygame.time.get_ticks()]

    del temps_boucle[0]

    secondes = (temps_boucle[1]-temps_boucle[0])/1000

#Définition que met le temps de l'ia pour se déplacer :

    cooldown_ia-=secondes

    if cooldown_ia <= 0:

        for pos_ia in range (len(position_ia)):

            position_ia[pos_ia][1] = trajectoire(position_ia[pos_ia][1])

        cooldown_ia=cooldown_max_ia

On comprend bien que ce bout de code calcul le temps d'une boucle, et permet de le convertir en secondes. Puis à partir du temps de boucle que met l'ia à 'se déplacer', de ce fait cela permet à notre personnage de ne pas dépendre du 'temps de déplacement de l'ia'. Cependant on voudrait savoir plus clairement comment l'expliquer et le comprendre.

Je n'arrive pas à comprendre pourquoi del temps_boucle[0] alors qu'ensuite on l'utilise. Peut-être que nohar ou Fred pourront t'aiguiller sur cette partie.

Pour la suite une histoire de déplacement à chaque tour de boucle ? Je vois pas trop avec le simple petit morceau de code que tu as mis.

Je n'arrive pas à comprendre pourquoi del temps_boucle[0] alors qu'ensuite on l'utilise.

C'est juste une façon très crade d'implémenter une file (FIFO), probablement de façon à garder les 2 dernières valeurs à tout instant. La version propre utiliserait une collections.deque, avec deq.append() pour ajouter une valeur en queue de file et deq.popleft() pour virer la valeur de tête, tout ça en temps constant.

Sinon là comme ça le reste du code ne m'inspire pas grand chose.