void plateau_modification_introduire_piece(plateau_siam* plateau,
                                           int x,int y,
                                           type_piece type,
                                           orientation_deplacement orientation)
{
    assert(plateau_etre_integre(plateau));
    assert(coordonnees_etre_bordure_plateau(x, y));
    assert(type_etre_animal(type));
    assert(orientation_etre_integre_deplacement(orientation));
    
    if ((plateau_modification_introduire_piece_etre_possible(plateau, x, y, type, orientation)==1))
        {
            if (piece_etre_case_vide(&plateau->piece[x][y])==1)
            {
                piece_siam* piece=&plateau->piece[x][y];
                piece_definir(piece,type,orientation);
            }
            else
            {
                poussee_realiser(plateau, x, y, type, orientation);
                piece_definir(&plateau->piece[x][y],type,orientation);
            }
        }
    
}
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]);
            }
    }
   
}
Beispiel #3
0
void piece_initialiser(piece_siam* piece)
{
    assert(piece!=NULL);

    piece_definir(piece,case_vide,aucune_orientation);

    assert(piece_etre_integre(piece));
}
Beispiel #4
0
piece_siam piece_correspondre_nom_cours(const char* nom_cours)
{
  assert(nom_cours!=NULL);
  assert(strlen(nom_cours)==3);

  //Possibilites:
  //
  // - nom vaut "***" -> case vide
  // - nom vaut "RRR" -> rocher
  // - nom commence par "e-" ou "r-"
  //     Alors il s'agit d'un animal.
  //     -> Recuperer le 3eme caractere
  //     -> Le convertir dans l'orientation de l'animal.
  //  - Si aucun des cas precedent, alors affiche erreur.

  piece_siam piece;
  piece_initialiser(&piece);


  if(strncmp(nom_cours,"***",3)==0)
    {
      piece_definir_case_vide(&piece);
    }
  else if(strncmp(nom_cours,"RRR",3)==0)
    {
      piece_definir_rocher(&piece);
    }
  else if((nom_cours[0]=='e' || nom_cours[0]=='r') && nom_cours[1]=='-')
    {
      const type_piece type=type_correspondre_caractere_animal(nom_cours[0]);
      const orientation_deplacement orientation=orientation_correspondre_caractere(nom_cours[2]);

      piece_definir(&piece,type,orientation);
    }
  else
    {
      printf("Erreur fonction %s\n",__FUNCTION__);
      abort();
    }

  return piece;

}
Beispiel #5
0
void piece_definir_rocher(piece_siam* piece)
{
  assert(piece!=NULL);
  piece_definir(piece,rocher,aucune_orientation);
  assert(piece_etre_integre(piece));
}