예제 #1
0
coup_jeu api_siam_tenter_introduire_nouvelle_piece_si_possible(jeu_siam* jeu,
                                                               int x,int y,
                                                               orientation_deplacement orientation)
{
    assert(jeu_etre_integre(jeu));
    coup_jeu coup;
    coup_jeu_initialiser(&coup);

 
    type_piece type = joueur_obtenir_animal(jeu->joueur);
    if(plateau_modification_introduire_piece_etre_possible(&(jeu->plateau),x,y,type,orientation)==0)
        return coup;

    const piece_siam *piece = plateau_obtenir_piece_info(&(jeu->plateau), x, y);

    if(piece->type != case_vide)
    {
       if(poussee_etre_valide(&(jeu->plateau), x, y, orientation, orientation) == 1)
       {
		//ici il faut vérifier la condition de victoire avant la poussée
		//car si jamais un rocher est au bord, il faut pouvoir le voir avant que la poussé ne soit effectuée !
            coup.condition_victoire=verification_condition_victoire_valide(jeu,x,y,orientation);
            poussee_realiser(&(jeu->plateau), x, y, orientation, orientation, &(coup.condition_victoire));
       }
    }

    plateau_modification_introduire_piece(&(jeu->plateau),x,y,type,orientation,&(coup.condition_victoire));
    coup.valide=1;   

	//on change de joueur
    joueur_changer(&(jeu->joueur));
    return coup;


}
int plateau_modification_deplacer_piece_etre_possible(const plateau_siam* plateau,
                                                      int x0,int y0,
                                                      orientation_deplacement direction_deplacement,
                                                      orientation_deplacement orientation)
{
    assert(plateau_etre_integre(plateau));
    
    assert(coordonnees_etre_dans_plateau(x0, y0));
    assert(orientation_etre_integre_deplacement(direction_deplacement));
    assert(orientation_etre_integre(orientation));
    
    
    if(type_etre_animal(plateau->piece[x0][y0].type))
    {
         orientation_deplacement orientation_piece_qui_pousse=plateau->piece[x0][y0].orientation;
         if ( (x0==0 && direction_deplacement==gauche) || (x0==4 && direction_deplacement==droite) || (y0==0 && direction_deplacement==bas) || (y0==4 && direction_deplacement==haut) )
    {
        return 1;
    }
        
    coordonnees_appliquer_deplacement(&x0,&y0,direction_deplacement);
        
    if( coordonnees_etre_dans_plateau(x0, y0)==0 || poussee_etre_valide(plateau, x0, y0, direction_deplacement )   )
    {
        if ( piece_etre_case_vide(&plateau->piece[x0][y0])==0 && orientation!=direction_deplacement )
        {
            puts("orientation finale non valide");
            return 0;
                    
        }
        if(piece_etre_case_vide(&plateau->piece[x0][y0])==0 && orientation_piece_qui_pousse!=direction_deplacement )
        {
            puts("orientation de la piece qui pousse differente de la direction de deplacement");
            return 0;
        }
        return 1;
    }
    }
    if (poussee_etre_valide(plateau, x0, y0, direction_deplacement)) return 1;
    return 0;
}
int plateau_modification_introduire_piece_etre_possible(const plateau_siam* plateau,
                                                        int x,int y,
                                                        type_piece type,
                                                        orientation_deplacement orientation)
{
    assert(plateau_etre_integre(plateau));
    
    assert(type_etre_animal(type));
    assert(orientation_etre_integre_deplacement(orientation));
    // cas de l'introduction hors coin quand la piece n'est pas vide
    if ( (plateau_exister_piece(plateau, x, y)) && ((x==0 && y>0 && y<4 && orientation!=droite) || (x==4 && y>0 && y<4 && orientation!=gauche) || (y==0 && x>0 && x<4 && orientation!=haut) || (y==4 && x>0 && x<4 && orientation!=bas) ))
    {
        return 0;
    }
    
    // cas de l'introduction dans les coins quand la piece n'est pas vide et que la poussée est valide
    if ( (plateau_exister_piece(plateau, x, y)) &&
        poussee_etre_valide(plateau, x, y, orientation) && ( ( x==0 && y==0 && (orientation==haut || orientation== droite) ) ||
                                                             ( x==4 && y==4 && (orientation==bas || orientation== gauche) ) ||
                                                             ( x==4 && y==0 && (orientation==haut || orientation== gauche) ) ||
                                                             ( x==0 && y==4 && (orientation==bas || orientation== droite) )
                                                          )
       )
    {
        return 1;
    }
    
    if( (coordonnees_etre_bordure_plateau(x, y)==1) && poussee_etre_valide(plateau, x, y, orientation) && plateau_denombrer_type(plateau, type)<5 )
    {
        
        return 1;
    }
    else
    {
        
        return 0;
    }

}
예제 #4
0
coup_jeu api_siam_tenter_deplacer_piece_si_possible(jeu_siam* jeu,
                                                    int x,int y,
                                                    orientation_deplacement deplacement,
                                                    orientation_deplacement orientation)
{
    assert(jeu_etre_integre(jeu));
    coup_jeu coup;
    coup_jeu_initialiser(&coup);

  
    if(plateau_modification_deplacer_piece_etre_possible(&(jeu->plateau),x,y, deplacement, orientation)==0)
    {
        puts("  deplacement impossible");
        return coup;
    }

    const piece_siam *piece = plateau_obtenir_piece_info(&(jeu->plateau), x, y);

    // On vérifie que la pièce au coordonnées indiquées appartienne bien au joueur actuel.

    if(piece->type==rocher || piece->type==case_vide)
    {
        puts("  Vous ne pouvez pas bouger cette pièce (rocher ou case vide) !");
        return coup;
    }

    if(joueur_etre_type_animal(jeu->joueur,piece->type)==0 )
    {
        puts("  La piece choisie n'est pas la votre !");
        return coup;
    }

	

    	//on copie les valeurs de x et y pour regarder ensuite à la case après deplacement, pour voir si la poussee
	//est réalisable
    int x_deplacement = x, y_deplacement=y;
    coordonnees_appliquer_deplacement(&x_deplacement, &y_deplacement, deplacement);

	//si la piece est au bord et qu'on veut l'enlever (deplacement hors plateau), 
	//on l'enleve directement et on fini le tour
    if(coordonnees_etre_dans_plateau(x_deplacement,y_deplacement) != 1)
    {
	plateau_modification_deplacer_piece(&(jeu->plateau), x, y , deplacement, orientation, &(coup.condition_victoire));
    	coup.valide=1;
 	joueur_changer(&(jeu->joueur));

	return coup;
    }

    piece = plateau_obtenir_piece_info(&(jeu->plateau), x_deplacement, y_deplacement);

    if(piece->type != case_vide)
    {
       if(poussee_etre_valide(&(jeu->plateau), x_deplacement, y_deplacement, deplacement, orientation) == 1)
       {
        coup.condition_victoire=verification_condition_victoire_valide(jeu,x,y,orientation);
        poussee_realiser(&(jeu->plateau), x_deplacement, y_deplacement, deplacement, orientation, &(coup.condition_victoire));
       }

       else
       {
           puts("  La poussee n'est pas valide");
           return coup;
       }
    }


    plateau_modification_deplacer_piece(&(jeu->plateau), x, y , deplacement, orientation, &(coup.condition_victoire));
    coup.valide=1;

	//on change de joueur
    joueur_changer(&(jeu->joueur));
    return coup;
}