Jeu en Tour par Tour

Fermé

jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020 - Modifié le 2 mai 2020 à 09:46
jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020 - 2 mai 2020 à 19:37

Bonjour à tous,
Je me suis dernièrement mis à faire du Python, avec l'idée de créer un jeu jouable en tour par tour, sans intelligence artificielle, avec 2 personnages (player 1 et player 2).
J'ai créé la carte, les 2 persos apparaissant bien dessus, et un compteur de tour augmentant de 1 chaque fois la barre d'espace pressée (l'idée étant qu'un personnage joue et bouge durant les tours pairs, et l'autre durant les tours impairs). Les personnages sont définis pour pouvoir bouger dans les 4 directions, et cela marche si les touches ordononant les mouvements sont différentes d'un perso à l'autre. Sauf que j'aimerais qu'ils puissent bouger avec les mêmes touches (si jamais je voulais par exemple qu'il y ait 10 persos, ce serait plus pratique).
J'ai donc essayer de créer une boucle pour permettre cela, mais elle ne fonctionne pas: le premier à jouer se déplace bien dès que c'est son tour, mais pour l'autre, c'est comme si aucune commande ne lui était affecté…

Voici la boucle:

if nb_tours in range (0,400,2):             (partie à 400 tours, commençant au tour 0)
    turtle.listen()
    turtle.onkey(player1.go_left,"Left")
    turtle.onkey(player1.go_right,"Right")
    turtle.onkey(player1.go_down,"Down")
    turtle.onkey(player1.go_up,"Up")

if nb_tours in range (1,400,2):
    turtle.listen()
    turtle.onkey(player2.go_left,"Left")
    turtle.onkey(player2.go_right,"Right")
    turtle.onkey(player2.go_down,"Down")
    turtle.onkey(player2.go_up,"Up")

En revanche, si je met des touches différentes ça fonctionne, comme par exemple:

turtle.listen()
turtle.onkey(player1.go_left,"q")
turtle.onkey(player1.go_right,"d")
turtle.onkey(player1.go_down,"s")
turtle.onkey(player1.go_up,"z")
turtle.onkey(player2.go_left,"Left")
turtle.onkey(player2.go_right,"Right")
turtle.onkey(player2.go_down,"Down")
turtle.onkey(player2.go_up,"Up")

Merci pour votre aide, si vous trouver le problème, j'aimerai bien la solution car ça me prend la tête!!

A voir également:

Jeu en Tour par Tour
94 jeu - Télécharger - Puzzle & Réflexion
Mini tour pc puissant - Guide
Tour ordinateur wifi - Guide
Jeu zuma - Télécharger - Jeux vidéo
Mon jeu se lance sur le mauvais écran - Forum Jeux PC

6 réponses

Réponse 1 / 6

Whismeril Messages postés 19043 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 18 mai 2024 912
2 mai 2020 à 09:48

Bonjour à tous les 2.
En python il y a un truc primordial c’est l’indentation. Pour qu’elle soit préservée sur le site il faut utiliser les balises de codes.

Hydros, tu a essayé mais pas correctement.

Donc pour tous les deux, voici un petit tuto pour vos prochains posts https://codes-sources.commentcamarche.net/faq/11288-les-balises-de-code

Réponse 2 / 6

Hydr0s Messages postés 1678 Date d'inscription lundi 24 janvier 2011 Statut Membre Dernière intervention 24 août 2022 673
2 mai 2020 à 00:39

Salut,

Sans le code complet, c'est assez difficile de te dire ce qu'il ne va pas (surtout que je n'ai pas l'habitude de python) mais:

la fonction
```
range(a[, b [,c]])
```
permet de générer une suite de nombre entre a et b avec un pas de c. Si tu veux vérifier que c'est bien au tour du joueur, un modulo
```
%
```
serait plus efficace (ex. tour%nb = 0 alors joueur 1 sinon joueur 2)
sans connaitre le module turtle, il faut surement que tu attendes la fin du tour du joueur 1 avant de lancer celui du joueur 2
le listen doit surement se placer à la fin des event (définir les touches puis lancer l'écoute des évènements)

En espérant avoir aider...

Réponse 3 / 6

jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020
2 mai 2020 à 10:13

Bonjour, et merci pour vos réponses.J'ai déja introduit in range, mais au sein des persos, pour que leur compétence de mouvements ne soient associées qu'à certains tours.

using System:
import turtle
import keyboard

fen=turtle.Screen()
fen.bgcolor("brown")                                         #MAP, fenêtre de fond
fen.title("Strategy Game")
fen.setup (700,700)
nb_tours = 0                                                   #commence au tour 0
def finir_tour(touche):
    global nb_tours
    if touche.name == "space":                                 #définition de la fonction tour par tour
        nb_tours += 1
        print("La partie est au tour : " +str(nb_tours))
        
keyboard.on_press(finir_tour)

class Pen(turtle.Turtle):
    def __init__(self):                                                   #définition des murs sur la carte
        turtle.Turtle.__init__(self)
        self.shape("square")
        self.color("black")
        self.penup()
        self.speed(0)
        
class Player1(turtle.Turtle):
    
    def __init__(self):
        
        turtle.Turtle.__init__(self)
        self.shape("circle")                  #création du player 1, fonctions: à certains tours
        self.color("blue")
        self.penup()
        self.speed(0)
        
    def go_up(self): 
        move_to_x= player1.xcor()
        move_to_y= player1.ycor() + 24
        if (move_to_x, move_to_y) not in walls:
            if nb_tours  in range (0,400,2):
                self.goto(move_to_x, move_to_y)
                
    def go_down(self):
        move_to_x= player1.xcor()
        move_to_y= player1.ycor() - 24
        if (move_to_x, move_to_y) not in walls:
            if nb_tours in range (0,400,2):
                self.goto(move_to_x, move_to_y)
                
    def go_right(self):
        move_to_x= player1.xcor() + 24
        move_to_y= player1.ycor()
        if (move_to_x, move_to_y) not in walls:
            if nb_tours in range (0,400,2):
                self.goto(move_to_x, move_to_y)
                


    def go_left(self):
        move_to_x= player1.xcor() - 24
        move_to_y= player1.ycor()
        if (move_to_x, move_to_y) not in walls:
            if nb_tours in range (0,400,2):
                self.goto(move_to_x, move_to_y)
              
class Player2(turtle.Turtle):
    
    def __init__(self):
        
        turtle.Turtle.__init__(self)
        self.shape("circle")
        self.color("blue")
        self.penup()
        self.speed(0)
        
    def go_up(self): 
        move_to_x= player2.xcor()                #création du player 1, mouvements: à certains tours
        move_to_y= player2.ycor() + 24
        if (move_to_x, move_to_y) not in walls:
            if nb_tours  in range (1,400,2):
                self.goto(move_to_x, move_to_y)
                
    def go_down(self):
        move_to_x= player2.xcor()
        move_to_y= player2.ycor() - 24
        if (move_to_x, move_to_y) not in walls:
            if nb_tours in range (1,400,2):
                self.goto(move_to_x, move_to_y)
                
    def go_right(self):
        move_to_x= player2.xcor() + 24
        move_to_y= player2.ycor()
        if (move_to_x, move_to_y) not in walls:
            if nb_tours in range (1,400,2):
                self.goto(move_to_x, move_to_y)
                


    def go_left(self):
        move_to_x= player2.xcor() - 24
        move_to_y= player2.ycor()
        if (move_to_x, move_to_y) not in walls:
            if nb_tours in range (1,400,2):
                self.goto(move_to_x, move_to_y)





    
levels=[""]

level_1= [
"XXXXXXXXXXXXXXXXXXXXXXXX", 
"XXXXXXXXXXXXXXXXXXXXXXXX", 
"XX P  Y   X    X   X  XX",
"XX        X    X   X  XX",
"XX      L X    X   X  XX",
"XX  XXXXXXX           XX",
"XX        X    X      XX",
"XX             XXXX   XX",
"XXXXX  XXXXXXX XXXX  XXX",
"XX  X  XXXXXXX    X   XX",                                                 #je dessine la map
"XX  X  X     X  X X   XX",
"XX  X  X     X        XX",
"XX  X  XX  XXX    XXXXXX",
"XX                X   XX",
"XX XXXXXXXXXXXX       XX",
"XX  X    X   X    XX  XX",
"XX  X    X   X    X   XX",
"XX       XX  X    X   XX",
"XX  X        X    X   XX",
"XXXXX XXXXXXXX XXXX   XX",
"XX                    XX",
"XX    X  K    M X   XXXX",
"XX    X     J   X     XX",
"XXXXXXXXXXXXXXXXXXXXXXXX",                     
"XXXXXXXXXXXXXXXXXXXXXXXX",           
]


levels.append(level_1)

def setup_maze(level):
    for y in range(len(level)):
        for x in range (len(level[y])):
            character=level[y][x]
            screen_x=-288+(x*24)
            screen_y=288-(y*24)
            if character=="X":
                pen.goto(screen_x, screen_y)
                pen.stamp()
                walls.append((screen_x, screen_y))

            if character=="K":
                player1.goto(screen_x, screen_y)
                pen.stamp()
            if character=="Y":
                player2.goto(screen_x, screen_y)
                pen.stamp()

pen=Pen()
player1=Player1()
player2= Player2()


if nb_tours in range (0,400,2):
    turtle.listen()
    turtle.onkey(player1.go_left,"Left")
    turtle.onkey(player1.go_right,"Right")
    turtle.onkey(player1.go_down,"Down")
    turtle.onkey(player1.go_up,"Up")  
elif nb_tours in range (1,400,2):
    turtle.listen()
    turtle.onkey(player2.go_left,"Left")
    turtle.onkey(player2.go_right,"Right")
    turtle.onkey(player2.go_down,"Down")
    turtle.onkey(player2.go_up,"Up")  


#le problème est juste au dessus,  si jamais je ne met pas de boucle et que je met des touches différentes, tout fonctionne, mais j'aimerais bien qu'ils puissent tous deux être jouable avec les flêches du clavier!


walls=[]

setup_maze(levels[1])
print(walls)


   
fen.tracer(0)

while True:
    fen.update()

yg_be Messages postés 22793 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 18 mai 2024 1 467
2 mai 2020 à 11:14

bonjour,
1) les lignes 167 à 178 ne contiennent aucune boucle, juste un test.
2) quand ces lignes sont-elle exécutées?
3) est-ce bien utile d'ainsi appeler onkey pour modifier la fonction appelée quand la touche est pressée? as-tu considéré la possibilité d'appeler toujours la même fonction?

Réponse 4 / 6

jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020
2 mai 2020 à 11:59

Merci pour votre aide!
Si j'ai bien compris, il faut faire un test et non un if. Entendez vous par 'test' la fonction try?
Sinon, j'ai essayé de créer une fonction mouvement, mais je n'arrive pas à l'écrire de manière à ce qu'elle concerne plusierurs turtles à la fois. Faut-il, si je fais cette fonction, qu'elle soit située en dehors des classes des joueurs, et dans ce cas là créer une liste contenant tout les joueurs pour dire que, n'importe quel joueur appelant la fonction aller en haut, par exemple, y aille?

yg_be Messages postés 22793 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 18 mai 2024 1 467
2 mai 2020 à 12:20

Tu n'as pas compris.
Il y a beaucoup d'erreurs et de maladresses dans ton code.
Pour commencer, je propose de n'avoir qu'une seule classe Player.

jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020 > yg_be Messages postés 22793 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 18 mai 2024
2 mai 2020 à 12:39

C'est fait: Je n'ai plus qu'un player, le compteur de tour, la carte, et la définition des mouvements du Player.
Saurais-tu maintenant comment rajouter un autre joueur, avec les même caractéristiques (sauf peut-être l'apparence), et avec qui le jeu se ferait en alternance, l'un durant les tours pairs, et l'autre durant les tours impairs?

import turtle
import keyboard

fen=turtle.Screen()
fen.bgcolor("brown")
fen.title("Strategy Game")
fen.setup (700,700)

nb_tours = 0
def finir_tour(touche):
    global nb_tours
    if touche.name == "space":
        nb_tours += 1
        print("La partie est au tour : " +str(nb_tours))

        
        
keyboard.on_press(finir_tour)


class Pen(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("square")
        self.color("black")
        self.penup()
        self.speed(0)
        



class Player(turtle.Turtle):
    
    def __init__(self):
        
        turtle.Turtle.__init__(self)
        self.shape("circle")
        self.color("blue")
        self.penup()
        self.speed(0)
        
    def go_up(self): 
        move_to_x= player.xcor()
        move_to_y= player.ycor() + 24
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)
    def go_down(self):
        move_to_x= player.xcor()
        move_to_y= player.ycor() - 24
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)
    def go_right(self):
        move_to_x= player.xcor() + 24
        move_to_y= player.ycor()
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)
    def go_left(self):
        move_to_x= player.xcor() - 24
        move_to_y= player.ycor()
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)
                



    
levels=[""]

level_1= [
"XXXXXXXXXXXXXXXXXXXXXXXX", 
"XXXXXXXXXXXXXXXXXXXXXXXX", 
"XX X  X   X    X   X  XX",
"XX        X    X   X  XX",
"XX      X X    X   X  XX",
"XX  XXXXXXX           XX",
"XX        X    X      XX",
"XX             XXXX   XX",
"XXXXX  XXXXXXX XXXX  XXX",
"XX  X  XXXXXXX    X   XX",
"XX  X  X     X  X X   XX",
"XX  X  X     X        XX",
"XX  X  XX  XXX    XXXXXX",
"XX                X   XX",
"XX XXXXXXXXXXXX       XX",
"XX  X    X   X    XX  XX",
"XX  X    X   X    X   XX",
"XX       XX  X    X   XX",
"XX  X        X    X   XX",
"XXXXX XXXXXXXX XXXX   XX",
"XX                    XX",
"XX    X  X    X X   XXXX",
"XX    X     J   X     XX",
"XXXXXXXXXXXXXXXXXXXXXXXX",                     
"XXXXXXXXXXXXXXXXXXXXXXXX",           
]


levels.append(level_1)

def setup_maze(level):
    for y in range(len(level)):
        for x in range (len(level[y])):
            character=level[y][x]
            screen_x=-288+(x*24)
            screen_y=288-(y*24)
            if character=="X":
                pen.goto(screen_x, screen_y)
                pen.stamp()
                walls.append((screen_x, screen_y))

            if character=="J":
                player.goto(screen_x, screen_y)
                pen.stamp()

pen=Pen()
player=Player()

turtle.listen()
turtle.onkey(player.go_left, "Left")
turtle.onkey(player.go_right, "Right")
turtle.onkey(player.go_down, "Down")
turtle.onkey(player.go_up, "Up")
walls=[]

setup_maze(levels[1])
print(walls)

fen.tracer(0)

while True:
    fen.update()

yg_be Messages postés 22793 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 18 mai 2024 1 467 > jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020
2 mai 2020 à 14:00

avant d'ajouter un joueur supplémentaire, préparons-nous:
1) simplifions, utilisons également "onkey" pour activer la fonction finir_tour, et supprimons l'utilisation de keyboard
2) créons une nouvelle variable pour le joueur qui est occupé à jouer, par exemple "currentplayer"
3) créons quatre nouvelles fonctions, hors de la classe Player, une pour chacun des mouvements. ces fonctions appelleront la fonction correspondant au mouvement pour le joueur qui est occupé à jouer
4) modifions les appels à onkey pour appeler les nouvelles fonctions

J'ai suivi vos instructions en considérant pour l'instant, puisqu'il n' y a qu'un seul joueur,que le currentplayer correspond au seul player. J'ai également modifier le passage de tour, en utilisant sous vos conseils onkey. Désormais dans la class player, il n'y a plus que la définition de son apparence et, en dehors de sa classe, après le traçage de la carte, j'ai rajouté les 4 fonctions, devant s'activer avec les onkey qui, désormais, désignent le currentplayer.
Problème: la carte ne s'affiche même plus.
Sauriez vous pourquoi?

import turtle
import keyboard

fen=turtle.Screen()
fen.bgcolor("brown")
fen.title("Strategy Game")
fen.setup (700,700)

nb_tours = 0
def finir_tour(touche):
    global nb_tours
    nb_tours += 1                                                           #fonction passage de tour
    print("La partie est au tour : " +str(nb_tours))        
        



class Pen(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("square")
        self.color("black")
        self.penup()                                   
        self.speed(0)
        



class Player(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("circle")
        self.color("blue")                         #classe de mon unique player, qui est jusqu'ici que défini par son apparence
        self.penup()
        self.speed(0)




    
levels=[""]

level_1= [
"XXXXXXXXXXXXXXXXXXXXXXXX", 
"XXXXXXXXXXXXXXXXXXXXXXXX", 
"XX X  X   X    X   X  XX",
"XX        X    X   X  XX",
"XX      X X    X   X  XX",
"XX  XXXXXXX           XX",
"XX        X    X      XX",
"XX             XXXX   XX",
"XXXXX  XXXXXXX XXXX  XXX",
"XX  X  XXXXXXX    X   XX",
"XX  X  X     X  X X   XX",
"XX  X  X     X        XX",                                    #dessin de la carte
"XX  X  XX  XXX    XXXXXX",
"XX                X   XX",
"XX XXXXXXXXXXXX       XX",
"XX  X    X   X    XX  XX",
"XX  X    X   X    X   XX",
"XX       XX  X    X   XX",
"XX  X        X    X   XX",
"XXXXX XXXXXXXX XXXX   XX",
"XX                    XX",
"XX    X  X    X X   XXXX",
"XX    X     J   X     XX",
"XXXXXXXXXXXXXXXXXXXXXXXX",                     
"XXXXXXXXXXXXXXXXXXXXXXXX",           
]


levels.append(level_1)

def setup_maze(level):
    for y in range(len(level)):
        for x in range (len(level[y])):
            character=level[y][x]
            screen_x=-288+(x*24)                                            #création à l'ordi de cette carte
            screen_y=288-(y*24)
            if character=="X":
                pen.goto(screen_x, screen_y)
                pen.stamp()
                walls.append((screen_x, screen_y))
            if character=="J":
                player.goto(screen_x, screen_y)
                pen.stamp()

pen=Pen()
player=Player()


currentplayer=player           #dès qu'il y aura un autre joueur, je changerai cette variable en fonction du numéro du tour

def go_up(self):
    move_to_x= currentplayer.xcor()
    move_to_y= currentplayer.ycor() + 24
    if (move_to_x, move_to_y) not in walls:
        self.goto(move_to_x, move_to_y)


def go_down(self):                                       #voilà mes cartes fonction qui, si j'ai compris, doivent bouger le currentplayer
    move_to_x= currentplayer.xcor()
    move_to_y= currentplayer.ycor() - 24
    if (move_to_x, move_to_y) not in walls:
        self.goto(move_to_x, move_to_y)

def go_right(self):
    move_to_x= currentplayer.xcor() + 24
    move_to_y= currentplayer.ycor()
    if (move_to_x, move_to_y) not in walls:
        self.goto(move_to_x, move_to_y)

def go_left(self):
    move_to_x= currentplayer.xcor() - 24
    move_to_y= currentplayer.ycor()
    if (move_to_x, move_to_y) not in walls:
        self.goto(move_to_x, move_to_y)
                

    
turtle.listen()
turtle.onkey(currentplayer.go_left, "Left")
turtle.onkey(currentplayer.go_right, "Right")
turtle.onkey(currentplayer.go_down, "Down")        #Voilà les instructions renvoyant aux fonctions de mouvement
turtle.onkey(currentplayer.go_up, "Up")                     #et à la fonction de passage de tour !!
turtle.onkey(currentplayer.finir_tour, "space")
walls=[]

setup_maze(levels[1])
print(walls)

fen.tracer(0)

while True:
    fen.update()

Tu n’obtiens aucun message d'erreur? Bizarre...
1) il n'y avait rien à changer dans la déclaration de la classe.
2) les quatre nouvelles fonctions (avec 4 nouveaux noms, pour ne pas confondre), hors de la classe Player, une pour chacun des mouvements. doivent simplement appeler la fonction de la classe Player correspondant au mouvement pour le joueur qui est occupé à jouer
3) modifier les appels à onkey pour appeler les nouvelles fonctions

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question

Réponse 5 / 6

yg_be Messages postés 22793 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 18 mai 2024 1 467
2 mai 2020 à 18:53

tu tentes de faire un exercice compliqué sans avoir pris le temps d'acquérir les compétences de base: pourquoi?

comment écrit-on, en python, un appel à une fonction?

Réponse 6 / 6

jober123 Messages postés 9 Date d'inscription vendredi 1 mai 2020 Statut Membre Dernière intervention 2 mai 2020
2 mai 2020 à 19:37

Il faut écrire currentplayer.append(nom de la fonction) pour qu'il y ait appel à la fonction?

P;S: C'est vrai qu'il me manque certaines bases, mais j'avais trop envie d'essayer de créer un jeu (si on peut appeler ça un jeu). Surtout n'hésites pas à me dire si ça te dérange de répondre.

Discussions similaires

comment brancher une tour sur un pc portable

Jeux similaires à amour sucré

Tour d'ordinateur qui ne s'allume plus

Avis sur les sites pour Gagner de l'Argent ?

IMPOSSIBLE la tour montparnasse infernale

Discussions similaires

Newsletters