Exemple #1
0
/* 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);
}
Exemple #2
0
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;
}
Exemple #3
0
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();
	}
}
Exemple #5
0
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);
}
Exemple #6
0
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;
}
Exemple #7
0
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 ----------------*/