void plateau_modification_deplacer_piece(plateau_siam* plateau,
                                         int x0,int y0,
                                         orientation_deplacement direction_deplacement,
                                         orientation_deplacement orientation_final)
{
    assert(plateau_etre_integre(plateau));
    assert(coordonnees_etre_dans_plateau(x0, y0));
    assert(orientation_etre_integre_deplacement(direction_deplacement));
    assert(orientation_etre_integre(orientation_final));
    
    if ( (x0==0 && direction_deplacement==gauche) || (x0==4 && direction_deplacement==droite) || (y0==0 && direction_deplacement==bas) || (y0==4 && direction_deplacement==haut) )
    {
        piece_definir_case_vide(&plateau->piece[x0][y0]);
    }

    if(plateau_exister_piece(plateau, x0, y0) && coordonnees_etre_dans_plateau(x0, y0))
    {
        piece_siam* piece=plateau_obtenir_piece(plateau,x0,y0);
        type_piece type=piece->type;
        if(plateau_modification_deplacer_piece_etre_possible(plateau,x0,y0,direction_deplacement,orientation_final))
            {
                int x=x0;
                int y=y0;
                

                // on réalise des boucles afin de s'assurer que les coordonnées ne sortiront pas du plateau
                if (coordonnees_etre_bordure_plateau(x0, y0)==0)
                {
                    coordonnees_appliquer_deplacement(&x0,&y0,direction_deplacement);
                    

                }
                else if ( (x0==0 && direction_deplacement!=gauche) || (x0==4 && direction_deplacement!=droite) || (y0==0 && direction_deplacement!=bas) || (y0==4 && direction_deplacement!=haut) )
                {
                    coordonnees_appliquer_deplacement(&x0,&y0,direction_deplacement);
                    

                }
                else if ( (x0==0 && direction_deplacement==gauche) || (x0==4 && direction_deplacement==droite) || (y0==0 && direction_deplacement==bas) || (y0==4 && direction_deplacement==haut) )
                {
                    piece_definir_case_vide(&plateau->piece[x0][y0]);
                    plateau->piece[x0][y0].orientation=aucune_orientation;
                }

                if (piece_etre_case_vide(&plateau->piece[x0][y0]) )
                {
                    if (type!=case_vide)
                    {piece_definir(&plateau->piece[x0][y0],type,orientation_final);}
                }
                else
                {
                    
                    poussee_realiser(plateau, x0, y0, plateau->piece[x0][y0].type, direction_deplacement);
                }
                
                piece_definir_case_vide(&plateau->piece[x][y]);
            }
    }
   
}
Пример #2
0
coup_jeu api_siam_tenter_changer_orientation_piece_si_possible(jeu_siam* jeu,int x,int y,orientation_deplacement orientation)
{
  assert(jeu!=NULL);
  assert(jeu_etre_integre(jeu));
  coup_jeu coup;
  coup_jeu_initialiser(&coup);
  if(orientation_etre_integre(orientation)==0){
    coup.valide=0;
    return coup;
  }
  // on verifie si on peut changer l'orientation de la piece
  if(plateau_modification_changer_orientation_piece_etre_possible(&jeu->plateau,x,y,orientation)==0){
    coup.valide=0;
    return coup;
  }
  // on verifie si la piece qu'on veut modifier appartient au joueur courant
  if(jeu_verifier_type_piece_a_modifier(jeu,x,y)==0){
    coup.valide=0;
    return coup;
  }
  /* si les conditions sont verifies on change l'orientation de la piece,
     on change de joueur, on regarde s'il est victorieux et on renvoie le coup valide*/
  plateau_modification_changer_orientation_piece(&jeu->plateau,x,y,orientation);
  const piece_siam* piece=plateau_obtenir_piece_info(&jeu->plateau,x,y);
  assert(piece!=NULL);
  assert(piece_etre_integre(piece));//on regarde si on a pas corrompu la piece
  jeu_changer_joueur(jeu);
  coup.valide=1;
  assert(coup_etre_integre(&coup));//on verifie qu'on renvoie un coup integre
  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;
}
Пример #4
0
int piece_etre_integre(const piece_siam* piece)
{
  assert (piece!= NULL); // On verifie que le pointeur est valide
  //On verifie que on a des types valides
  assert (type_etre_integre        (piece -> type)        == 1);
  assert (orientation_etre_integre (piece -> orientation) == 1);

  // Si piece est un animal et possede un deplacement comme orientation
  // Il est valide
  if(type_etre_animal(piece->type) == 1) 
    {
      if(orientation_etre_integre_deplacement(piece ->orientation) == 1)
	return 1;
    }
  //Si piece n'est pas un animal et aucune deplacement
  //Il est valide
  else
    {
      if(orientation_etre_integre_deplacement(piece ->orientation) == 0)
	return 1;
    }

  return 0;
}