def __init__(self):
j1Name = raw_input("Nickname of player 1 : ")
self.j1 = Joueur(str(j1Name), "o")
j2Name = raw_input("Nickname of player 2 : ")
self.j2 = Joueur(str(j2Name), "x")
self.j1.changeMyTurn()
self.plateau = Plateau()
def AjouterMotTemp(self,mot,joueur : Joueur = None): listeCases=[] listeLettre=[] if mot[3]: #Place en ligne for idx,lettre in enumerate(mot[0]): if self.cases[mot[1]][mot[2]+idx].lettre.valeur== '_': listeLettre.append(lettre) self.cases[mot[1]][mot[2]+idx].lettre=Lettre(lettre,self.valeurLettres.get(lettre),True) listeCases.append(self.cases[mot[1]][mot[2]+idx]) else: #Place en colonne for idx,lettre in enumerate(mot[0]): if self.cases[mot[1]+idx][mot[2]].lettre.valeur== '_': listeLettre.append(lettre) self.cases[mot[1]+idx][mot[2]].lettre=Lettre(lettre,self.valeurLettres.get(lettre),True) listeCases.append(self.cases[mot[1]+idx][mot[2]]) if joueur != None : joueur.enleverChevalet(listeLettre) return Mot(listeCases,mot[3])
def test_getNbTresorsRestants(self):
j = Joueur("test")
for i in range(10):
res = j.getNbTresorsRestants()
self.assertEqual(res, i, "Le nombre de trésors du joueur " + str(j) + " devrait être " + str(
i) + " mais getNbTresors a retourné " + str(res) +
"\nCela peut provenir des fonctions getNbTresorsRestants, ajouterTresor ou Joueur")
j.ajouterTresor(i + 1)
def test_getNom(self):
noms = ["toto", "azerty", "nom23"]
for nom in noms:
j = Joueur(nom)
nom_res = j.getNom()
self.assertEqual(nom_res, nom,
"Le nom du joueur " + str(j) + " devrait être " + nom + " et getNom a retourné " + str(
nom_res) +
"\nCela peut provenir de la fonction getNom ou de la fonction Joueur")
def test_ajouterTresor(self):
j = Joueur("test")
liste_tresors = [(2, 1), (6, 2), (4, 3), (6, 3), (2, 3), (14, 4)]
for tresor, nb_attendu in liste_tresors:
j.ajouterTresor(tresor)
res = j.getNbTresorsRestants()
self.assertEqual(res, nb_attendu, "Le nombre de trésors du joueur " + str(j) + " devrait être " + str(
nb_attendu) + " mais getNbTresors a retourné " + str(res) +
"\nCela peut provenir des fonctions getNbTresorsRestants, ajouterTresor ou Joueur")
def verifColision(obstacle: Obstacle, joueur: Joueur):
if obstacle.x - (Settings.Obstacle.largeur / 2) < joueur.posHorizontale + (Settings.Joueur.largeurChat / 2) - 10 and obstacle.x + (Settings.Obstacle.largeur / 2) > joueur.posHorizontale - (Settings.Joueur.largeurChat / 2):
if obstacle.inverse:
if obstacle.y + (Settings.Obstacle.hauteur / 2) > joueur.posVerticale - (Settings.Joueur.hauteurChat / 2):
joueur.enVie = False
joueur.canvas.delete(joueur.chat)
else:
if obstacle.y - (Settings.Obstacle.hauteur / 2) < joueur.posVerticale + (Settings.Joueur.hauteurChat / 2):
joueur.enVie = False
joueur.canvas.delete(joueur.chat)
def main():
# initialisation
joueur1 = Joueur("Max")
joueur2 = Joueur("Daniel")
joueur3 = Joueur("Fernando")
joueur4 = Joueur("Pierre")
dico_joueurs = {}
dico_joueurs[1] = joueur1
dico_joueurs[2] = joueur2
dico_joueurs[3] = joueur3
dico_joueurs[4] = joueur4
idj_actuel = 1
stockage = []
(dico_joueurs[idj_actuel]).camembert = ['3']
#vrai main ?
statut = True
while statut:
print(" ++++++++++++++++++++++")
print(" ++++++ tour en cours :", dico_joueurs[idj_actuel])
print("camemberts de base du joueur: " +
str((dico_joueurs[idj_actuel]).camembert))
if (dico_joueurs[idj_actuel]).final == 0:
a = question_aleatoire(
stockage, 0, 0
) # return aleatoire_question[0], stock_id_question, theme_choisi #le zéro sert à laisser le thème en aléatoire
else:
a = question_finale(stockage, 0, '3')
print("test question" + str(a))
id_question = a[0][0]
libelle = a[0][1]
difficulte = a[0][2]
stockage = a[1]
theme = a[2]
print("stockage :\t", stockage)
print("difficulté :\t", difficulte)
print("thème : \t", theme)
print(" ++++++ Question :", libelle)
b = input(" ++++++ Votre réponse :")
statut, joueur = traitement_reponse(b, id_question,
dico_joueurs[idj_actuel], theme,
'3', stockage)
idj_actuel = j_suivant(dico_joueurs, idj_actuel)
print(" ++++++++++++++++++++++")
print("camemberts après : " + str((dico_joueurs[idj_actuel]).camembert))
print(" ++++++ tour en cours :", dico_joueurs[idj_actuel])
def __init__(self, xmax=5, ymax=5, nb_piece=5, nb_roc=3, music=False):
self.table_jeu = Table_jeu(xmax, ymax,
nb_roc).initialiserPlateau().table_jeu
self.elephants = Joueur('M', nb_piece, self.table_jeu)
self.rhinoceros = Joueur('H', nb_piece, self.table_jeu)
self.joueurTour = self.elephants
self.nb_tour_done = 0
self.end = False
self.music = music
if self.music == True: # lance la musique de fond, True signifie 'ON', False signifie 'OFF'
winsound.PlaySound("donkey_kong_theme.wav", winsound.SND_ASYNC)
def __init__(self):
self.ecran = pygame.display.set_mode((1100, 600))
pygame.display.set_caption('Jeu De Combat')
self.jeu_encours = True
self.joueur_x, self.joueur_y = 600, 100
self.taille = [32, 64]
self.joueur_vitesse_x = 0
self.joueur = Joueur(self.joueur_x, self.joueur_y, self.taille)
self.enemie_x, self.enemie_y = 100, 400
self.enemie_taille = [88, 60]
self.image_enemie = pygame.image.load('knight.png')
self.enemie = Enemie(self.enemie_x, self.enemie_y, self.enemie_taille)
self.image_arriere_plan = pygame.image.load(
'PC Computer - RPG Maker VX Ace - Battle Background Overlays 33.png'
)
self.arriere_plan_rect = [34, 34, 574, 214]
self.image_ciel_bleu = self.image_arriere_plan.subsurface(
self.arriere_plan_rect)
self.image_ciel_bleu = pygame.transform.scale(self.image_ciel_bleu,
(1100, 600))
self.image_sol_plat = pygame.image.load(
'Game Boy Advance - Sonic Advance - Background Elements 1.gif')
self.image_sol_rect = [542, 3693, 373, 117]
self.image_sol = self.image_sol_plat.subsurface(self.image_sol_rect)
self.image_sol = pygame.transform.scale(self.image_sol, (1100, 170))
self.image_plat_rect = [535, 3689, 379, 123]
self.image_plat = self.image_sol_plat.subsurface(self.image_plat_rect)
self.image_plat = pygame.transform.scale(self.image_plat, (300, 50))
self.sol = Sol(self.image_sol)
self.gravite = (0, 10)
self.resistance = (0, 0)
self.rect = pygame.Rect(0, 0, 1100, 600)
self.collision_sol = False
self.horloge = pygame.time.Clock()
self.fps = 30
self.projectile_groupe = Group()
self.t1, self.t2 = 0, 0
self.delta_temps = 0
self.image_joueur = pygame.image.load(
'WonderSwan WSC - RockmanEXE WS - MegaManEXE Heat Style.png')
self.image_joueur_rect = pygame.Rect(124, 453, 8, 8)
self.image_boule_de_feu = self.image_joueur.subsurface(
self.image_joueur_rect)
self.plateforme_groupe = Group()
self.plateforme_liste_rect = [
pygame.Rect(0, 300, 300, 50),
pygame.Rect(800, 300, 300, 50),
pygame.Rect(400, 150, 300, 50)
]
self.slash_groupe = Group()
self.slash_image_rect = pygame.Rect(108, 232, 24, 43)
self.image_slash = self.image_enemie.subsurface(self.slash_image_rect)
self.image_slash = pygame.transform.scale(self.image_slash, (30, 30))
def __init__(self, demo: bool = True):
self.pioche = []
self.demo = demo
for i in range(1, 15):
self.pioche.append("E")
for i in range(1, 9):
self.pioche.append("A")
for i in range(1, 8):
self.pioche.append("I")
for i in range(1, 6):
self.pioche.append("N")
self.pioche.append("O")
self.pioche.append("R")
self.pioche.append("S")
self.pioche.append("T")
self.pioche.append("U")
for i in range(1, 5):
self.pioche.append("L")
for i in range(1, 3):
self.pioche.append("D")
self.pioche.append("M")
for i in range(1, 2):
self.pioche.append("G")
self.pioche.append("B")
self.pioche.append("C")
self.pioche.append("P")
self.pioche.append("F")
self.pioche.append("H")
self.pioche.append("V")
for i in range(1, 2):
self.pioche.append("J")
self.pioche.append("Q")
self.pioche.append("K")
self.pioche.append("W")
self.pioche.append("X")
self.pioche.append("Y")
self.pioche.append("Z")
self.plateau = Plateau()
self.joueur = Joueur()
if demo:
random.Random(7).shuffle(self.pioche)
for i in range(0, 7):
self.joueur.ajouterLettre(self.pioche[0])
del self.pioche[0]
else:
random.shuffle(self.pioche)
for i in range(1, 8):
rand = random.randint(0, len(self.pioche))
self.joueur.ajouterLettre(self.pioche[rand])
del self.pioche[rand]
async def creerJoueur(self,sid,username):
cookie = str(sid)[:8]
'''
while cookie in [self.Clients[i].cookie for i in range(len(self.Clients))] :
cookie = str(uuid.uuid4)[:8]
'''
#Il faudrait vérifier si le nom est correct (different/non vide ...)
j = Joueur(len(self.Joueurs),username,sid,cookie)
self.Joueurs.append(j)
await self.sio.emit('user_cookie', {'data': cookie}, room=sid)
print("Nouveau client enregistré ! ")
print(cookie)
#Si tout est correct on envoie une validation au client
await self.sio.emit('user_registration_cookie', {'data': cookie}, room=sid)
j.etape=1
class Potion(ObjetRamassable):
joueur = Joueur.getInstance("👤", "X", 100)
""" Représente une potion qui redonne de l'énergie au joueur lorsqu'il la boit. """
def __init__(self, energie):
""" Arguments :
- energie : la quantité d'energie récupérée lorsque l'on utilise la potion
"""
self._energie = energie
self._symboleWindowsTerminal = "🧃"
self._symbole = "."
def utiliser(self):
Potion.joueur.gagnerEnergie(self._energie)
print("J'ai récupéré " + str(self._energie) +
" point(s) d'énergie ! Je pète le feu !!")
return True
def description(self):
return "Potion de " + str(self._energie) + " énergie(s)."
def getSymbole(self, isWindowsTerminal):
if isWindowsTerminal:
return self._symboleWindowsTerminal
else:
return self._symbole
class Clef(ObjetRamassable):
""" Représente une potion qui redonne de l'énergie au joueur lorsqu'il la boit. """
joueur = Joueur.getInstance("👤", "X", 100)
def __init__(self):
self._symboleWindowsTerminal = "🔑"
self._symbole = "C"
def description(self):
return "Il te manque " + str(
10 - self.joueur.getCle()) + " pour pouvoir sortir !"
def ramasser(self):
if Clef.joueur.getCle() < 10:
Clef.joueur.mettreObjetDansLeSac(self)
Clef.joueur.gagnerCle()
else:
print(
"Vous avez déjà les 10 clefs requises... dirigez-vous vers le sphinx !"
)
input()
def getSymbole(self, isWindowsTerminal):
if isWindowsTerminal:
return self._symboleWindowsTerminal
else:
return self._symbole
def utiliser(self):
if Clef.joueur.getCle() == 10:
print("Va voir le sphinx jeune Padawan")
else:
print("Il est trop tôt pour utiliser la clé jeune Padawan!")
return False
def ajouter_joueur(self, client):
"""Ajoute un joueur.
On doit simplement préciser le client (le socket) en
paramètre. Un nouveau joueur est créé et retourné.
"""
if self.partie_commencee:
raise RuntimeError("La partie a déjà commencé")
joueur = Joueur(self, client)
joueur.numero = len(self.joueurs) + 1
joueur.placer_robot()
self.clients[client] = joueur
self.joueurs.append(joueur)
return joueur
def __init__(self):
self.ecran = pygame.display.set_mode((1100, 600))
pygame.display.set_caption('Jeu Combat')
self.jeu_encours = True
self.joueur_x, self.joueur_y = 700, 200
self.joueur_vitesse_x = 0
self.joueur_taille = [32, 64]
self.joueur = Joueur(self.joueur_x, self.joueur_y, self.joueur_taille)
self.sol = Sol()
self.gravite = (0, 10)
self.resistance = (0, 0)
self.clock = pygame.time.Clock()
self.fps = 30
self.rect = pygame.Rect(0, 0, 1100, 600)
self.collision_sol = False
class Singe(Personnage):
""" Cette classe représente un singe qui vole une clé lorsqu'on arrive dans sa case, ensuite il s'enfuit """
joueur = Joueur.getInstance("👤", "X", 100)
def __init__(self):
""" Constructeur. Paramètres :
- couleur : la couleur du perroquet (chaine de caractères)
"""
self._symboleWindowsTerminal = "🐵"
self._symbole = "S"
def description(self):
""" Renvoie la description du perroquet."""
return "Un singe"
def rencontrer(self):
#Vole une clé au joueur
if Singe.joueur.getCle() != 0:
print("Oh nonnn, le singe vient de te piquer une clef !")
Singe.joueur.perdreCle()
print("Vous avez maintenant " + str(Singe.joueur.nbCle) + " clef")
Singe.joueur.getCaseCourante().supprimerPersonnage(self)
else:
print("Le singe vous dévisage..")
input()
def parler(self, joueur):
print("wouuuuuaaaaaInInIn WWWoouaaaahhInInInIn !!!")
def getSymbole(self, isWindowsTerminal):
if isWindowsTerminal:
return self._symboleWindowsTerminal
else:
return self._symbole
def __init__(self):
""" Constructeur. Paramètres :
"""
self._joueur = Joueur.getInstance("", "", 100)
self._symbole = "K"
self._symboleWindowsTerminal = "🐊"
class Ramasser(Action):
joueur = Joueur.getInstance("👤", "X", 100)
def execute(self):
case = Ramasser.joueur.getCaseCourante()
if len(case.getObjets()) == 0:
print("Mais... il n'y a rien à ramasser !")
class Crane(ObjetRamassable):
""" Représente une potion qui redonne de l'énergie au joueur lorsqu'il la boit. """
joueur = Joueur.getInstance("👤", "X", 100)
__instance = None
@staticmethod
def getInstance():
if Crane.__instance is None:
Crane.__instance = Crane()
return Crane.__instance
def __init__(self):
self._symboleWindowsTerminal = "💀"
self._symbole = "U"
def description(self):
return "Donne ce crâne de cristal à Indiana Jones pour récupérer la carte du labyrinthe !"
def getSymbole(self, isWindowsTerminal):
if isWindowsTerminal:
return self._symboleWindowsTerminal
else:
return self._symbole
def utiliser(self):
pass
def init_game(self):
print("************************************\n" +
"* BIENVENUE A LA TABLE DE MONOPOLY *\n" +
"************************************\n")
j = Joueur()
self.joueurs.append(j)
j = Joueur()
self.joueurs.append(j)
print("Il y a", len(self.joueurs), "joueurs à la table\n")
while len(self.joueurs) < 5 and input(
"Souhaitez-vous ajouter un nouveau joueur (max = 5) (o/N) ? "
).lower() == "o":
j = Joueur()
self.joueurs.append(j)
print("Il y a", len(self.joueurs), "joueurs à la table\n")
print("\nDébut de la partie\n")
def initialisationJoueurs(self):
"""
Cette fonction permet de créer et d'ajouter les joueurs sur le plateau.
:return:
"""
for i in range(self.nbJoueurs):
self.players.append(Joueur(i))
creeJoueurs(self.players, self.plateau)
def fin_entree_joueur(self):
for w in range(len(self.liste_entry)):
entry = self.liste_entry[w]
nom_joueur = entry.get()
combobox = self.liste_combobox[w]
couleur_joueur = combobox.get()
objet = Joueur(nom_joueur, self.couleurs[couleur_joueur])
self.liste_joueur.append(objet)
self.destroy()
def __init__(self, nbj, nbIA=0, consoleGraphique=0):
"cette fonction initilaise le jeu"
self.numeroTour = 1
self.nombreJoueur = nbj
self.terrain = TerrainJeux()
if consoleGraphique == 0:
# 0 pour le jeux en console les autres valeurs pour le jeux graphique
self.listeJoueur = [
Joueur(i, input("entrez le nom du joueur " + str(i) + "\n"))
for i in range(self.nombreJoueur - nbIA)
]
self.listeJoueur.extend([
JoueurAI(i + self.nombreJoueur - nbIA, "Ordi " + str(i))
for i in range(nbIA)
])
else:
self.listeJoueur = [Joueur(i) for i in range(self.nombreJoueur)]
self.talon = Talon()
self.talon.mix()
self.__joueurActuel = 0
def __init__(self):
self.ecran = pygame.display.set_mode((900, 500))
pygame.display.set_caption('Jeu Pong')
self.jeu_encours = True
self.joueur_1_x, self.joueur_1_y = 20, 250
self.joueur_2_x, self.joueur_2_y = 860, 250
self.joueur_taille = [20, 80]
self.vitesse_y_1, self.vitesse_y_2 = 0, 0
self.joueur_1 = Joueur(self.joueur_1_x, self.joueur_1_y,
self.joueur_taille)
self.joueur_2 = Joueur(self.joueur_2_x, self.joueur_2_y,
self.joueur_taille)
self.rect = pygame.Rect(0, 0, 900, 500)
self.balle_direction = [-1, 1]
self.balle = Balle(450, 250, [10, 10],
random.choice(self.balle_direction))
self.balle_tire = False
self.balle_vitesse_x, self.balle_vitesse_y = 15, 2
self.score_1, self.score_2 = 0, 0
class Sac(Action):
joueur = Joueur.getInstance("👤", "X", 100)
def execute(self):
sac = Sac.joueur.getSac()
if (len(sac)) == 0:
print("Le sac est vide")
input()
else:
print("Le sac contient: ")
showSac = {}
for obj in sac:
test = True
for clef, valeur in showSac.items():
if obj.__class__.__name__ + '(' + obj.description(
) + ')' == clef:
valeur.append(obj)
test = False
if (test):
showSac[obj.__class__.__name__ + '(' + obj.description() +
')'] = [obj]
index = 1
for clef, valeur in showSac.items():
print(str(index) + '- ' + clef + " : " + str(len(valeur)))
index += 1
while True:
choice = input(
"Pour utiliser un objet, taper son numéro, ou appyer sur entrée pour ne rien faire. "
)
if choice == "":
break
else:
try:
num = int(choice)
choix = list(showSac.values())[num - 1]
obj = choix[0]
test = obj.utiliser()
if (test):
sac.remove(obj)
input()
break
except Exception:
print(
"\nWhere is the item ? \nIt is not in the list !\n"
)
def description(self):
return "Permet de se regarfer l'inventaire de son sac"
def getType(self):
return self.getCategories()[1]
def place_mur(__, nombre=2):
w = int(G.xmax / (G.R * 2)) + 1
h = int(G.ymax / (G.R * 2)) + 1
for x in range(w):
Mur(x * G.R * 2, 0)
Mur(x * G.R * 2, G.R * h * 2 - G.R * 2)
for y in range(h - 2):
Mur(0, G.R * 2 + y * G.R * 2)
Mur(G.R * w * 2 - G.R * 2, G.R * 2 + y * G.R * 2)
for x in range(w - 2):
for y in range(h - 2):
if x != 0 and x != 1 or y != 0 and y != 1 or x == 1 and y == 1:
if x != w - 3 and x != w - 4 or y != 0 and y != 1 or x == w - 4 and y == 1:
if x != w - 3 and x != w - 4 or y != h - 3 and y != h - 4 or x == w - 4 and y == h - 4:
if x != 0 and x != 1 or y != h - 3 and y != h - 4 or x == 1 and y == h - 4:
if y % 2 and x % 2:
Mur(G.R * 2 + x * G.R * 2,
G.R * 2 + y * G.R * 2)
else:
Mur(G.R * 2 + x * G.R * 2,
G.R * 2 + y * G.R * 2, 1)
else:
if x == 0 and y == h - 3:
if nombre >= 4:
Joueur(G.R * 2 + x * G.R * 2,
G.R * 2 + y * G.R * 2)
else:
if x == w - 3 and y == h - 3:
if nombre >= 2:
Joueur(G.R * 2 + x * G.R * 2,
G.R * 2 + y * G.R * 2)
else:
if x == w - 3 and y == 0:
if nombre >= 3:
Joueur(G.R * 2 + x * G.R * 2,
G.R * 2 + y * G.R * 2)
else:
if x == 0 and y == 0:
Joueur(G.R * 2 + x * G.R * 2, G.R * 2 + y * G.R * 2)
class Est(Action):
joueur = Joueur.getInstance("👤", "X", 100)
def execute(self):
Est.joueur.avancerEst()
Est.joueur.perdreEnergie()
def description(self):
return "Permet de se déplacer vers l'Est"
def getType(self):
return self.getCategories()[0]
class Sud(Action):
joueur = Joueur.getInstance("👤", "X", 100)
def execute(self):
Sud.joueur.avancerSud()
Sud.joueur.perdreEnergie()
def description(self):
return "Permet de se déplacer vers le sud"
def getType(self):
return self.getCategories()[0]
class Nord(Action):
joueur = Joueur.getInstance("👤", "X", 100)
def execute(self):
Nord.joueur.avancerNord()
Nord.joueur.perdreEnergie()
def description(self):
return "Permet d'aller au nord"
def getType(self):
return self.getCategories()[0]
def main():
casino = Casino(100000)
jeu1 = Roulette("my wheel", casino)
jeu2 = MachineASous("bandit manchot", casino)
joueur = Joueur("Clement", 1000)
joueur.entrer_casino(casino)
joueur.jouer()
def __init__(self, ident):
Joueur.__init__(self, ident)
self.algo = {'petite': 0.4, 'garde': 0.65, 'garde_sans': 0.85,
'garde_contre': 1}
