/* main program. Creates the philosophers and the waiter and waits for termination of its children. */
void
dinner(int num_philo, int num_cycles)
{
if (num_philo < 2 || num_cycles < 1)
{
ecrire("Parameters with impossible values\n");
quitter(FAILURE);
}
int *philos; //to store the philosophers' pid
int waiter;
int my_prio = obtenir_priorite(obtenir_pid());
int child_prio = (my_prio == MAX_PRIORITY ? my_prio : my_prio + 1); //let's give an lower priority to the children in order to minimize the number of preemptions before the start of the dinner.
int status;
int args[4] = { 0, 0, 0, 0 };
philos = allouer(num_philo * sizeof(int));
if (philos == NULL)
{
ecrire("Allouer philos failed\n");
quitter(FAILURE);
}
int i, j;
ecrire("The dining philosophers. \nBon appétit !\n");
// we need to spawn the waiter first
args[0] = num_philo;
waiter = fourchette(child_prio, "waiter", args);
if (waiter < 1)
{
ecrire("An error occured. The program will stop.\n");
quitter(FAILURE);
}
args[0] = waiter; //the waiter's pid is a parameter of the philosophers
args[2] = num_cycles;
// spawns the philosophers
for (i = 0; i < num_philo; i++)
{
args[1] = i; //philosopher's id
philos[i] = fourchette(child_prio, "philosopher", args);
if (philos[i] < 1)
{
ecrire
("An error occured. Impossible to create the philosophers. The process will exit now.\n");
//clean up
for (j = 0; j < i; j++)
tuer(philos[j], FAILURE);
tuer(waiter, FAILURE);
quitter(FAILURE);
}
}
//everything's done, let's wait for the end
for (i = 0; i < num_philo; i++)
attendre(philos[i], &status);
//the waiter can stop
envoyer_entier(waiter, END_OF_DINNER, 10);
attendre(waiter, &status);
ecrire("The dinner ends.\n");
quitter(SUCCESS);
}
int main( int argc, char ** argv )
{
unsigned iLargeur = 0, iHauteur = 0;
unsigned int iNbSnake = 0;
unsigned int isFini = 0;
unsigned int iTemps = 0;
if( argc < 4 )
{
printf( "Mauvaise utilisation du programme\n" );
printf( "snake <LARGEUR>x<HAUTEUR> <NB_SERPENTS> <TEMPS>\n" );
return EXIT_FAILURE;
}
sscanf( argv[1], "%dx%d", &iLargeur, &iHauteur );
char cPlateau[iHauteur*iLargeur];
sscanf( argv[2], "%d", &iNbSnake );
Tete tTete[iNbSnake];
sscanf( argv[3], "%d", &iTemps );
initialisation( (char * const)cPlateau, iHauteur, iLargeur, tTete , iNbSnake );
srand( time( NULL ) );
system( "clear" );
while( !isFini )
{
attendre( iTemps );
system( "clear" );
afficher_cadre( (char * const)cPlateau, iHauteur, iLargeur );
isFini = evolution( (char * const)cPlateau, iHauteur, iLargeur, tTete, iNbSnake );
}
statistiques( (char * const)cPlateau, iHauteur, iLargeur );
return EXIT_SUCCESS;
}
void afficheBoutonExpert()
{
POINT bg; bg.x = 0; bg.y = 600;
affiche_image("../data/img/menu2.bmp",bg,1100,600);
affiche_all();
attendre(150);
}
/* Execute une commande indiquee en parametre lors d'un achat dans la boutique */
void executerCommandeAcheterBoutique(const char *commande)
{
char typePotion[TAILLE_MAX];
unsigned int quantitePotion, niveauPotion;
unsigned int prixCommande;
unsigned int choixJoueur;
/* Si la commande est -1 (le joueur veut revenir a la boutique) on retourne a la boutique */
if(strcmp(commande, "-1") == 0)
boutique();
/* Sinon si on peut lire la quantite, le type de la potion et son niveau (commande correcte) */
else if(sscanf(commande, "%d %s %d", &quantitePotion, typePotion, &niveauPotion) == 3)
{
/* On formate le nom de la potion entree pour que le joueur puisse entrer de n'importe
quelle forme le nom de la potion (Sante, sante, SaNtE etc.) */
formaterNomPotion(typePotion);
/* On affiche la commande */
printf("Vous souhaitez donc acheter %d potion(s) de %s de niveau %d.\n", quantitePotion,
typePotion, niveauPotion);
/* On calcule le prix de la commande */
prixCommande = calculerPrixPotionAcheterBoutique(quantitePotion, typePotion,
niveauPotion);
/* On affiche le prix */
printf("Ca vous fera %d tek.\n", prixCommande);
/* On demande si le joueur est sur de faire l'achat */
choixJoueur = demanderConfirmation("Etes vous sur de vouloir faire cet achat ? (0/1)",
SEPARATION);
/* Si le joueur veut effectuer l'achat */
if(choixJoueur == OUI)
{
/* On lui enleve le prix de la commande, si le joueur a assez d'argent on lui ajoute
sa commande dans son inventaire */
if(peutAcheterCommande(prixCommande))
{
enleverTekInventaire(prixCommande);
ajouterPotionInventaire(quantitePotion, recupererTypePotion(typePotion), niveauPotion);
}
}
/* Si le joueur ne veut pas effectuer l'achat, on le redirige juste vers la categorie
achat de la boutique */
/* On retourne dans la categorie achat de la boutique */
acheterBoutique();
}
/* Sinon c'est une commande incorrecte */
else
{
/* On affiche un message d'erreur, on attend un certain temps et on retourne dans la
categorie achat de la boutique */
printf("Veuillez entrer une commande correcte !\n");
attendre(1.2);
acheterBoutique();
}
}
void afficheBoutonRecommencerSombre()
{
POINT P1 = {730,530};
POINT P2 = {860,580};
draw_fill_rectangle(P1,P2,couleur_RGB(25,180,220));
draw_rectangle(P1,P2,black);
P1.x = 737;
P1.y = 566;
aff_pol("RECOMMENCER",15,P1,noir);
affiche_all();
attendre(150);
}
bool Session::boucle(float freq, bool continuer) {
Audio::maj();
for(std::list<std::pair<VueInterface *, bool> >::iterator i = _vuesASupprimer.begin(); i != _vuesASupprimer.end(); ++i) {
i->first->parent()->supprimerEnfant(*i->first);
if(i->second)
delete i->first;
}
_vuesASupprimer.clear();
if(!continuer) {
Session::reinitialiserEvenements();
Session::_vueFenetre = 0;
_horlogeSurvol = horloge();
VueInterface::definirVueActuelle(0);
_vues.pop();
_vueFenetre = _vues.top();
_vueTemp = _vueFenetre;
_retourHierarchie = true;
_continuer = true;
return false;
}
if(_horlogesAjoutees) {
for(std::list<Session::HorlogeLocale *>::iterator i = Session::_horloges.begin(); i != Session::_horloges.end(); ++i) {
if((*i)->_v == 0) {
(*i)->_v = _vueTemp;
}
}
_horlogesAjoutees = false;
}
if(Session::_vueFenetre != _vueTemp || _retourHierarchie) {
if(!_retourHierarchie || _vues.top() != _vueTemp) {
_vues.push(_vueTemp);
}
_retourHierarchie = false;
Session::reinitialiserEvenements();
_horlogeSurvol = horloge();
horloge_t tpsV = _derniersTemps[_vueTemp];
horloge_t tps = horloge();
for(std::list<Session::HorlogeLocale *>::iterator i = Session::_horloges.begin(); i != Session::_horloges.end(); ++i) {
if((*i)->_v == _vueTemp && ***i != 0.0) {
***i += tps - tpsV;
}
}
_vueFenetre = _vueTemp;
VueInterface::definirVueActuelle(_vueFenetre);
}
Ecran::effacer();
int couche = 0, ancien;
do {
ancien = couche;
_vueFenetre->preparationDessin();
Ecran::ajouterCadreAffichage(_vueFenetre->cadre());
Ecran::ajouterVerrouTransformations();
_vueFenetre->afficher(glm::vec2(0), ancien, couche);
glDisable(GL_DEPTH_TEST);
Ecran::retourVerrouTransformations();
Ecran::supprimerVerrouTransformations();
Ecran::supprimerCadreAffichage();
} while(ancien != couche);
Ecran::finaliser();
bool const aClic[2] = {_evenements[B_GAUCHE], _evenements[B_DROIT]};
_evenements[SOURIS] = false;
while(Session::gestionEvenements());
if(_souris != _sourisClic) {
_nbClic[0] = _nbClic[1] = 0;
}
if(horloge() - _horlogeClic > DELAI_REPETITION_CLIC) {
_nbClic[0] = _nbClic[1] = 0;
}
if(_evenements[B_GAUCHE] && !aClic[0]) {
_nbClic[1] = 0;
_sourisClic = _souris;
_horlogeClic = horloge();
}
else if(!_evenements[B_GAUCHE] && aClic[0]) {
++_nbClic[0];
}
if(_souris != _sourisSurvol && horloge() - _horlogeSurvol < 1.0f) {
_horlogeSurvol = horloge();
_sourisSurvol = _souris;
}
if(_vueFenetre) {
_derniersTemps[_vueTemp] = horloge();
if(VueInterface *a = _vueFenetre->gestionClic()) {
VueInterface::definirVueActuelle(a);
}
_vueFenetre->gestionGestionClavier();
if(VueInterface *tmp = VueInterface::vueActuelle()) {
tmp->gestionSouris(true, Session::souris() - tmp->positionAbsolue(), _evenements[B_GAUCHE], _evenements[B_DROIT]);
}
if(!_evenements[B_GAUCHE] && !_evenements[B_DROIT]) {
if(VueInterface *tmp = _vueFenetre->gestionSurvol()) {
tmp->gestionSouris(false, Session::souris() - tmp->positionAbsolue(), _evenements[B_GAUCHE], _evenements[B_DROIT]);
if(tmp->description().empty())
_horlogeSurvol = horloge();
else if(horloge() - _horlogeSurvol >= 1.0f) {
Ecran::definirBulleAide(tmp->description());
}
}
else {
_horlogeSurvol = horloge();
}
}
else {
_horlogeSurvol = horloge();
}
Ecran::maj();
}
_vueTemp = _vueFenetre;
attendre(1.0f / freq - (horloge() - Session::_horlogeBoucle));
Session::_horlogeBoucle = horloge();
return continuer;
}
int main (int argc , char** argv)
{
int largeur,hauteur,nbserpents,attente;
/*----------------- 1.recuperation des arguments de la commande---------------------------*/
if (argc !=4) /* test si le nombre d'arguments entres lors de l'exécution est egale a 4 */
{
printf("entrer tout vos arguments\n");
}
if(argv[0][0]=='.')
{
sscanf(argv[1],"%dx%d",&hauteur,&largeur);
sscanf(argv[2],"%d",&nbserpents);
sscanf(argv[3],"%d",&attente);
}
printf("largeur = %d\n",largeur);
printf("hauteur = %d\n",hauteur);
printf("nbserpents = %d\n",nbserpents);
printf("temps d'attendre = %d\n",attente);
/* ----------- 2. initialisation de l'environnement (tableau) qui permet l'enregistrement des serpents -------*/
char tableau [hauteur*largeur];
init_tableau( hauteur, largeur, tableau);
/*------- initialisation de nombre de bloquage des serpents-------*/
int bloque [nbserpents];
int somme_bloque=0;
int t;
for(t=0; t < nbserpents; t++)
{
bloque[t]=0;
}
/* ----------------- 3.generation des directions aleatoires des serpents ----------*/
serpent tab1[nbserpents]; /*declaration des la structure de tableau des serpents à afficher*/
int k,sens1;
srand(time(NULL));
for(k=0;k<nbserpents;k++)
{
tab1[k].xposi= rand()%hauteur ; /* position du serpent suivent x */
tab1[k].yposi= rand()%largeur; /* position du serpent suivent y */
sens1=rand()%3; /* sens de deplacement du serpent */
/* Trouver le sens de direction */
switch(sens1)
{
case 0 : tab1[k].sens=haut;
break;
case 1 : tab1[k].sens=bas;
break;
case 2 : tab1[k].sens=droite;
break;
case 3 : tab1[k].sens=gauche;
break;
}
printf("%c\n",tab1[k].sens);
printf("%d\n",tab1[k].xposi);
printf("%d\n",tab1[k].yposi);
tableau[tab1[k].xposi*largeur+tab1[k].yposi]=tab1[k].sens; /* Placement des serpents dans l'environnement */
}
/* ------------------ 4. Affichage de cadre du tableau --------------------------------*/
affichage_cadre( hauteur, largeur,tableau);
/* ------------------ 5. Deplacement des serpents dans l'environnement définie -------------------*/
while(somme_bloque != nbserpents) /* on teste si les serpent sont tous bloqués */
{
for(k=0;k<nbserpents;k++) /* cette branche permet de gerer tous les deplacements des serpents */
{
switch(tab1[k].sens)
{
case haut : bloque[k]=depl_sens_haut(hauteur,largeur,&tab1[k],tableau);
break;
case bas: bloque[k]=depl_sens_bas(hauteur,largeur,&tab1[k],tableau) ;
break;
case droite : bloque[k]=depl_sens_droite(hauteur,largeur,&tab1[k],tableau) ;
break;
case gauche : bloque[k]=depl_sens_gauche(hauteur,largeur,&tab1[k],tableau);
break;
}
}
int t;
somme_bloque=0;
for(t=0; t < nbserpents; t++)
{
somme_bloque=somme_bloque+bloque[t]; /* calcul de la variable somme_bloque */
}
attendre(attente); /* delai d'attente */
system( CLRSCR ); /* effacer à chaque fois l'ecran*/
affichage_cadre( hauteur, largeur,tableau); /* affichage du tableau a l'etat suivant (initial+1)*/
} /* fin de while*/
/* -------------6. statisques : pourcentage pour remplissage + chaque direction ------------------------------- */
int gh; /* parcours en hauteur*/
int gl; /* parcours en largeur*/
int ha=0; /* nombre de deplacement de la direction 'HAUT' */
int ba=0; /* nombre de deplacement de la direction 'BAS' */
int dr=0; /* nombre de deplacement de la direction 'DROITE' */
int ga=0; /* nombre de deplacement de la direction 'GAUCHE' */
int occupe=0; /* nombre de place occupé dans l'environnement(tableau) par tous les directions */
int vide=0; /* nombre de place vide*/
for(gh=0;gh<hauteur;gh++){
for(gl=0;gl<largeur;gl++){
if(tableau[gh*largeur+gl]==haut){
occupe=occupe+1;
ha=ha+1;
}
else if(tableau[gh*largeur+gl]==bas){
occupe=occupe+1;
ba=ba+1;
}
else if(tableau[gh*largeur+gl]==droite){
occupe=occupe+1;
dr=dr+1;
}
else if(tableau[gh*largeur+gl]==gauche){
occupe=occupe+1;
ga=ga+1;
}
else if (tableau[gh*largeur+gl]==' '){
vide=vide+1;
}
}
}
printf("%d\n",hauteur*largeur);
printf("%d\n",occupe);
printf("%d\n",vide);
float pourcentage; /* pourcenatge de remplissage de l'espace */
float pourcentage1; /* pourcenatge de remplisssage de la direction HAUT*/
float pourcentage2; /* pourcenatge de remplisssage de la direction BAS*/
float pourcentage3; /* pourcenatge de remplisssage de la direction DROITE*/
float pourcentage4; /* pourcenatge de remplisssage de la direction GAUCHE*/
pourcentage= ((float)(occupe))/((float)(largeur*hauteur))*100;
printf("Le plateau est rempli a %0.1f (%d/%d) dont :\n",pourcentage,occupe,largeur*hauteur);
pourcentage1= ((float)(ha))/((float)(occupe))*100;
printf("- %0.1f '^' (%d/%d)\n",pourcentage1,ha,occupe);
pourcentage2= ((float)(ba))/((float)(occupe))*100;
printf("- %0.1f 'v' (%d/%d)\n",pourcentage2,ba,occupe);
pourcentage3= ((float)(dr))/((float)(occupe))*100;
printf("- %0.1f '>' (%d/%d)\n",pourcentage3,dr,occupe);
pourcentage4= ((float)(ga))/((float)(occupe))*100;
printf("- %0.1f '<' (%d/%d)\n",pourcentage4,ga,occupe);
return 0;
} /*---------------- Fin de programme principale ----------------*/
