Bonjour, j'aimerais coder une IA en python pour notre projet ISN (un jeu d’échecs), avez vous des conseils, comme une piste pour débuter ou un tutoriel? Le langage python est imposé.

salut,

regardes ça:

http://fr.openclassrooms.com/forum/sujet/un-jeu-d-echec-en-console-77316

avec l'IA en plus, c'est ambitieux comme projet ISN.

courage.

Merci a toi ! c'est sympa

Tout ce que je peux te conseiller c'est de passer par la récursivité en utilisant la POO. Je n'ai ni le temps ni les compétences pour faire entièrement le programme mais je peux te conseiller sur la structure de celui-ci (j'y travaille ).

Ha merci bien on va voir ça

Re. Ah ben voilà à cause de toi j'ai pas encore fait mes devoirs . J'ai pas testé car c'est que du code abstrait (je vais pas te pondre le truc quand même) mais voilà en gros ce que ça donne:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Dictionnaire répertoriant les mouvements possibles d'une pièce d'échec
MOVE = {
	'up': lambda x, pos: (pos[0], pos[1] - x),
	'down': lambda x, pos: (pos[0], pos[1] + x),
	'left': lambda x, pos: (pos[0] - x, pos[1]),
	'right': lambda x, pos: (pos[0] + x, pos[1]),
	'upleft': lambda x, pos: (pos[0] - x, pos[1] - x),
	'upright': lambda x, pos: (pos[0] + x, pos[1] - x),
	'downleft': lambda x, pos: (pos[0] - x, pos[1] + x),
	'downright': lambda x, pos: (pos[0] - x, pos[1] + x)
}

# Cas particulier: le chevalier, je redéfinie un autre dico mais je suis pas sûr de la nécessité
KNIGHTMOVE = {
	'upleft': lambda pos: (pos[0] - 1, pos[1] - 3),
	'upright': lambda pos: (pos[0] + 1, pos[1] - 3),
	'downleft': lambda pos: (pos[0] - 1, pos[1] + 3),
	'downright': lambda pos: (pos[0] + 1, pos[1] + 3),
	'lefttop': lambda pos: (pos[0] - 3, pos[1] - 1),
	'leftdown': lambda pos: (pos[0] - 3, pos[1] + 1),
	'righttop': lambda pos: (pos[0] + 3, pos[1] - 1),
	'rightdown': lambda pos: (pos[0] + 3, pos[1] + 1),
}


# Jusque là pas de mystère, je définie une class Chess qui va représenter le plateau lui même
# Il possède un attribut pawns qui répertorie les pièce sur cet échiquier
class Chess(list):
	def __init__(self, value=[([None]*8).copy() for _ in range(8)], pawns=[]):
		super().__init__(value)
		self.pawns = pawns


# Classe Piece. Correspond à la pièce d'échec avec les précisions minimales
# Possède les attributs:
# chess -> échiquier sur lequel la pièce est placée
# pos   -> position de cette pièce sur l'échiquier
# color -> t'es si nul que ça en anglais ?
class Piece:
	def __init__(self, chess, pos, color):
		self.chess = chess
		self.pos = pos
		self.color = color

	def move(self, step, direction):
		self.pos = MOVE[direction](step, self.pos)

	def die(self):
		del self.chess[self.chess.pawns.index(self)]

# Pion
class Pawn(Piece):
	def move(self, direction):
		if direction == 'up':
			super().move(1, direction)

# Cavalier
class Knight(Piece):
	def move(self, direction):
		self.pos = KNIGHTMOVE[direction]

# Fou
class Bishop(Piece):
	def move(self, step, direction):
		if direction in ['upleft', 'upright', 'downleft', 'downright']:
			super().move(step, direction)

# Tour
class Rook(Piece):
	def move(self, step, direction):
		if direction in ['up', 'down', 'left', 'right']:
			super().move(step, direction)

# Eh oui, la pièce par défaut est en réalité une reine !
# Ça peut paraître con (ça l'est peut être) mais c'est pour faire en sorte que toutes les pièces n'héritent pas 
# de la reine, ça aurait été bizarre
Queen = Piece

# Roi
class King(Piece):
	def move(self, direction):
		super().move(1, direction)

C'est sûrement perfectible mais ça donne un aperçu.

Edit: J'ai "commenté" le code.

-
Edité par Anonyme 23 septembre 2014 à 11:42:53

Ho yeah ! une tuerie ! merci bien on va voir ça

Yep merci. Il te reste plus qu'à coder les fonctions qui te permettront de vérifier si le mouvement est possible (s'il y a un autre pion dans la case ciblée), une autre pour représenter l'échiquier, et pour finir l'IA, qui est quand même la question initiale. Je vais essayer de voir comment faire ça .

on va passer par du graphique avec des menus et tout le tralala et ou on a du taf, ps le jeu est orientée de l'animé no game no life sachant que la photo et faite par notre graphiste les pions tout

# Méta-classe Piece. Correspond à la pièce d'échec avec les précisions minimales

Non piece n'est pas une métaclasse, simplement une classe.

ha merci de l'info

@oldProgrammer: Yes t'as raison je corrige ça (j'avais mis méta-classe pour dire que ce n'était pas une classe qui allait être utilisée mais effectivement ce n'est pas le bon terme).

-
Edité par Anonyme 23 septembre 2014 à 11:44:15

et étant donné qu'on veut crée 3 IA de différents niveau, ça ce modifierai comment ?

Bon. Mon ordi vient de lacher donc je peux pas te mettre de code, trop fastidieux. Mais ce que je te conseille de faire c'est, comme je te l'ai dit, de passer par la récursivité. L'idée serait que la classe Piece ait une méthode check_moves qui te permette de vérifier les cases où elle peut se déplacer, et de vérifier quelles pièces peuvent la "manger" sur cette même position. C'est là qu'intervient la récursivité, tu évalue chaque danger potentiel par sa position, de sa portée d'attaque, et pour finir de son prochain déplacement (défini par l'IA aussi). Tu met donc en place une sorte de liste du premier élément, le meilleur coup, et le dernier, le moins bon. L'action est alors définie par un choix aléatoire entre les x premiers éléments de la liste avec x l'indice de difficulté (plus il est faible, plus l'IA est fort).

nikel ! écoute parfait merci !

Une véritable IA calculerait tous ses mouvements possibles dans les x coups suivants et toutes les réponses possibles du joueur puis choisirait la meilleure suite de mouvements (avec un premier tri en cours de route je pense). Plus x est grand, plus la difficulté est grande. Un joueur entraîné doit, je pense, pouvoir vaincre l'ordi pour x<=2, un champion pour x<=4 mais au-delà c'est de l'ordre de l'impossible. Ce qui est de l'ordre de l'impossible aussi, c'est de faire une telle IA en python. C'est un peu coton à implémenter, mais python n'est surtout pas optimisé pour faire les millions de tests que cette IA implique (du coup je ne te conseille pas de faire ça dans un premier temps).

J'avais vu un puissance 4 en python qui utilisait cette IA, mais pour x>=4  l'ordi mettait de nombreuses secondes à réfléchir à son prochain coup. Par contre pour x>=3 il était impossible de le battre.

et ben pourquoi ne pas faire un noyau en lua qui est (je crois) fait ou presque avec ses modules et autres (je ne connais pas trop lua) pour les ia ?

@Folaefolc : tout simplement parce que Python est ici imposé Le PO a indiqué faire ce projet dans le cadre du cours d'ISN (Informatique et Sciences du Numérique), une spécialité en Terminale qui a été introduite pour l'année scolaire 2012-2013 (pile mon année de terminale, mais ça on s'en fou).

Effectivement python imposé, pour ce qui est du temps de réflexion rappelons que le jeu disposera d'un timer, donc l'IA si elle joue en 15sec c'est parfait ! merci a vous et pour ce qui est de la difficulté ce n'est pas vraiment le probléme, on est 3 et on mange des pages de python tout les jours mais j'y penserais merci