Me--and--Me
Messages postés72Date d'inscriptionvendredi 15 mai 2009StatutMembreDernière intervention22 février 2010
-
4 oct. 2009 à 00:57
Me--and--Me
Messages postés72Date d'inscriptionvendredi 15 mai 2009StatutMembreDernière intervention22 février 2010
-
4 oct. 2009 à 23:35
Bonjour,
j'essaye de programmer un jeu d'échec pour pour un mini projet, le pb c'est que j'en connais rien en c j'essaye de m'attraper a ce niveau, mais je trouve des difficultés sans cette chose j'ai trouvé un code en c pour ce jeu mais je le comprend pas.
pouvez vous m'aidez SVP.
// On initialise la valeur de chaque piece
piece_values[KING] = 100000000;
piece_values[QUEEN] = 10000;
piece_values[BISHOP] = 3000;
piece_values[KNIGHT] = 3000;
piece_values[ROOK] = 5000;
piece_values[PAWN] = 1000;
// On initialise les bonus ajoute aux pieces en fonctions de leur position
memset(piece_position_bonus, 0, sizeof(piece_position_bonus));
//piece_position_bonus[KNIGHT][0][0] =
// On initialise la selection courante pour le premier tour (aucune piece selectionnee)
game->cur_sel_state = SELECTION_ERROR;
}
////////////////
// IsColonFree()
////////////////
int IsColonFree(GAME *game, int c, int l1, int l2)
{
int l, step_l;
step_l = (l2 - l1) > 0 ? 1: -1;
for(l = l1 + step_l; l != l2; l += step_l)
{
if(game->tab[l][c] != NONE)
return 0;
}
return 1;
}
//////////////
// IsRowFree()
//////////////
int IsRowFree(GAME *game, int l, int c1, int c2)
{
int c, step_c;
step_c = (c2 - c1) > 0 ? 1: -1;
for(c = c1 + step_c; c != c2; c += step_c)
{
if(game->tab[l][c] != NONE)
return 0;
}
return 1;
}
///////////////////
// IsDiagonalFree()
///////////////////
int IsDiagonalFree(GAME *game, int l1, int c1, int l2, int c2)
{
int l, c, step_l, step_c;
if(score > (piece_values[KING] / 10))
{
state = IN_CHESS;
// S'il y a echec, on verifie s'il s'agit d'un echec et mat
score = abs(GetBestMove(&best_move, game, color, 1, 1));
if(score > (piece_values[KING] / 10))
{
state = CHESS_MATE;
}
}
else
{
state = NO_CHESS;
}
return state;
}
////////////////
// SelectPiece()
////////////////
int SelectPiece(GAME *game, int l, int c)
{
// La selection est effectuee si la case choisie est occupee par une piece de la couleur 'color'
if(game->tab[l][c] * game->cur_color > 0)
{
game->cur_sel_pos.l = l;
game->cur_sel_pos.c = c;
game->cur_sel_state = SELECTION_OK;
}
return game->cur_sel_state;
}
//////////////
// MovePiece()
//////////////
int MovePiece(GAME *game, int l2, int c2)
{
int l1, c1;
int piece, arrival;
int move_possible;
int sav_arrival;
// Si un deplacement est possible, on le fait
if(move_possible)
{
sav_arrival = game->tab[l2][c2];
game->tab[l2][c2] = game->tab[l1][c1];
game->tab[l1][c1] = NONE;
if(CheckForChess(game, game->cur_color) == NO_CHESS)
{
// On invalide la selection de la piece courante
game->cur_sel_state = SELECTION_ERROR;
// Le delacement est correct
return MOVE_OK;
}
else
{
game->tab[l1][c1] = game->tab[l2][c2];
game->tab[l2][c2] = sav_arrival;
}
}
}
return MOVE_ERROR;
}
////////////
// AddMove()
////////////
void AddMove(MOVE *move, int *n, int l1, int c1, int l2, int c2)
{
MOVE *next, *cur_move;
if(move != NULL)
{
next = move;
while(next->next_move != NULL)
{
next = (MOVE *)next->next_move;
}
/////////////////////
// GenerateMoveList()
/////////////////////
int GenerateMoveList(GAME *game, int color, MOVE *move)
{
int l, c, i, j;
int piece, square;
int nb_moves;
// On initialise la liste chainee des coups
// Dans la premiere structure, seul le pointeur est utilise
// La liste commence veritablement a partir du 2eme maillon
// Ainsi, on evite la gestion particuliere du premier maillon
if(move != NULL)
{
move->next_move = NULL;
}
nb_moves = 0;
for(l = 0; l < 8; l++)
{
for(c = 0; c < 8; c++)
{
// Sélection d'une piece de la couleur 'color'
if(game->tab[l][c] * color <= 0)
continue;
////////////////
// GetBestMove()
////////////////
int GetBestMove(MOVE *best_move, GAME *game, int color, int depth, int org_depth)
{
MOVE move;
MOVE *cur_move;
int score, best_score;
int sav_arrival;
/////////////////
// EvaluateGame()
/////////////////
int EvaluateGame(GAME *game)
{
int l, c;
int piece;
int score;
score = 0;
for(l = 0; l < 8; l++)
{
for(c = 0; c < 8; c++)
{
if(game->tab[l][c] == NONE)
continue;
piece = abs(game->tab[l][c]);
// on effectue une 1ere evaluation fonction uniquement des possessions materielles des 2 camps
// ainsi qu'une 2eme evaluation, en meme temps, fonction de l'emplacement des pieces sur l'echiquier
// 3eme evaluation fonction du nombre de deplacements possibles
// 1/10 de points du PION sont attribues pour chaque deplacement possible
score += (GenerateMoveList(game, WHITE, NULL) - GenerateMoveList(game, BLACK, NULL)) * (piece_values[PAWN] / 10);
1000 lignes de code... c'est le reccord ! Il faut dire qu'il y a beaucoup de lignes blanches ;-)
Et, en plus, ce n'est pas indenté !
j'essaye de programmer un jeu d'échec J'ai surtout l'impression que ce essaies de trouver un programme tout fait; je ne pense pas que ce soit une bonne méthode. Il faut réfléchir pour en élaborer un algorithme et ensuite le traduire en code.
j'ai trouvé un code en c pour ce jeu mais je le comprend pas. Tu pourras te souvenir que les commentaires explicatifs ne sont jamais assez nombreux lorsqu'on cherche à reprendre ou à comprendre de nombreuses lignes de code.
Bon courage.
Me--and--Me
Messages postés72Date d'inscriptionvendredi 15 mai 2009StatutMembreDernière intervention22 février 20105 4 oct. 2009 à 23:35
ta raison sur certain point, mais je dois faire très vite j'ai qu'une semaine pour faire tout ce travail, c'est pourquoi j'essaye de m'appuyait sur certaine chose que je trouve sur le net, et puisque j'ai jamais étudier le c ni d'algorithme je trouve d'énorme difficulté a exprimer ce que je pense faire dans ce jeu, je sais pas si je dois passer mon temps à comprendre les fonctionnalités de C ou de faire marcher cette jeux car c'est noté :(.
