Ejemplo n.º 1
0
int main()
{
    typeJoueur* joueurs[NBJOUEURMAX];
    int nbJoueurs = 0;
    char choix;

    // charger joueurs

    do
    {
        afficherMenu(nbJoueurs);
        printf("Votre choix : ");
        scanf(" %c", choix);

        switch (choix)
        {
            case 'A' :
            {
                joueurs[nbJoueurs] = creerJoueur();
                if(joueurs[nbJoueurs] != NULL)
                {
                    nbJoueurs++;
                }
            }
        }
    }while(choix != 1);

    return 0;
}
Ejemplo n.º 2
0
void* handlerConnexion(void *args)
{
  int sock=*(int *)args;
  int read_size;
  char *reponse;
  char *message,client_message[2000];
  char **decouper;
  Dessin *dessin=malloc(sizeof(*dessin));
  dessin->couleur="0/0/0";
  dessin->size="1";
  char *size="1";
  char *couleur="0/0/0";

  int i=0;
  if((read_size=recv(sock,client_message,2000,0))>0)
    {
      decouper=(char **)fStrSplit(client_message,"/");
      if(strcmp(decouper[0],"CONNECT")==0)
	{
	  pthread_mutex_lock(&mutex);
	  nbConnecter++;
	  pthread_mutex_unlock(&mutex);
	  creerJoueur(decouper[1],sock,mesJoueurs);
	  reponse=(char *)malloc(sizeof(char *));
	  strcat(reponse,"WELCOME/");
	  strcat(reponse,decouper[1]);
	  strcat(reponse,"/\n");
	  printf("la reponse est %s \n",reponse);
	  write(sock,reponse,strlen(reponse));
	  notifierConnexion(mesJoueurs,decouper[1],sock);
	}
      if(strcmp(decouper[0],"SPECTATOR")==0)
	{
	  printf("il y'a un spectateur qui veut se connecter \n");
	  mesSpectateurs[nbSpectateur]=sock;
	  pthread_mutex_lock(&mutex);
	  nbSpectateur++;
	  pthread_mutex_unlock(&mutex);
	  
	}
      if(strcmp(decouper[0],"REGISTER")==0)
	{
	  int insc=inscription(decouper[1],decouper[2]);
	  if(insc==0)
	    {
	      char *reponse=(char *)malloc(sizeof(char *));
	  strcat(reponse,"WELCOME/");
	  strcat(reponse,decouper[1]);
	  strcat(reponse,"/\n");
	  close(sock);
	    }
	  else
	    {
	      char *access="ACCESSDENIED/\n";
	      write(sock,access,strlen(access));
	      close(sock);
	    }
	}
      if(strcmp(decouper[0],"LOGIN")==0)
	{
	  int auth=authentification(decouper[1],decouper[2]);
	  if(auth==0)
	    {
	      printf("authentification reussi \n");
	      pthread_mutex_lock(&mutex);
	      nbConnecter++;
	      pthread_mutex_unlock(&mutex);
	      creerJoueur(decouper[1],sock,mesJoueurs);
	      reponse=(char *)malloc(sizeof(char *));
	      strcat(reponse,"WELCOME/");
	      strcat(reponse,decouper[1]);
	      strcat(reponse,"/\n");
	      printf("la reponse est %s \n",reponse);
	      write(sock,reponse,strlen(reponse));
	      notifierConnexion(mesJoueurs,decouper[1],sock);
	    }
	  else
	    {
	      char *access="ACCESSDENIED/\n";
	      write(sock,access,strlen(access));
	      close(sock);
	      printf("echec authentification \n");
	    }

	}

      
    }
  while(nbConnecter!=MaxJoueur)
    {
    }
  pthread_cond_signal(&notifierJoueurs);
  while(tour!=0)
    {
      
      while((read_size=recv(sock,client_message,2000,0))>0)
	{printf("une commande est venu qd meme \n");
	  char** decouper=malloc(sizeof(char *));
	  decouper=(char **)fStrSplit(client_message,"/");
	  printf("command recu :%s \n",client_message);
	  if(strcmp(decouper[0],"SET_COLOR")==0)
	    {
	      printf("il veut definir la couleur \n");
	      char *maCouleur;
	      maCouleur=(char*)malloc(sizeof(char *));
	      strcat((char *)maCouleur,decouper[1]);
	      strcat(maCouleur,"/");
	      strcat(maCouleur,decouper[2]);
	      strcat(maCouleur,"/");
	      strcat(maCouleur,decouper[3]);
	      dessin->couleur=maCouleur;
	    }
	  if(strcmp(decouper[0],"EXIT")==0)
	    {
	      deconnexionJoueur(mesJoueurs,sock,decouper[1]);
	      supprimerJoueur(mesJoueurs,sock);
	      if(dessinateur->socket_id==sock)
		{close(sock);
		  finRound(mesJoueurs,buffer,"NO_ONE");
		  setDessinateur(mesJoueurs);
		  if(fgets(buffer,TAILLE_BUFFER,monFichier)!=NULL)
		    {
		      int n=strlen(buffer);
		      buffer[n-1]='\0';
		      aDessiner=buffer;
		      printf(" le mot a dessiner est %s lol ",aDessiner);
		      EnvoyerRole(mesJoueurs,buffer);
		      flagTimeout=0;
		      break;
		    }
		}
	      close(sock);
	    }
	 
	  if(strcmp(decouper[0],"GUESS")==0)
	    {
	      printf("veut deviner \n");
	      if(strcmp(decouper[1],aDessiner)==0)
		{
		  /*EnvoyerMotDeviner(mesJoueurs,decouper[1],sock,1);*/
		  printf("bien deviner mon pote \n");
		  DeclencherMotTrouver(mesJoueurs,sock);
		  if(flagScore==0)
		    {
		      setScore(mesJoueurs,sock,10);
		      setScore(mesJoueurs,dessinateur->socket_id,10);
		      flagScore++;
		    }
		  else
		    {
		      setScore(mesJoueurs,sock,10-flagScore);
		      setScore(mesJoueurs,dessinateur->socket_id,1);
		      flagScore++;
		    }
		    
		  if(flagTimeout==0)
		    {
		      declencherTimeOut(mesJoueurs);
		      flagTimeout=1; 
		      sleep(timeout);
		      if(flagPass==0)
			{
			  nomGagnant=getNomJoueur(mesJoueurs,sock);
			  EnvoyerScore(mesJoueurs);
			  finRound(mesJoueurs,buffer,nomGagnant);
			  
			  setDessinateur(mesJoueurs);
			  if(fgets(buffer,TAILLE_BUFFER,monFichier)!=NULL)
			    {
			      int n=strlen(buffer);
			      buffer[n-1]='\0';
			      aDessiner=buffer;
			      printf(" le mot a dessiner est %s lol ",aDessiner);
			      EnvoyerRole(mesJoueurs,buffer);
			      flagTimeout=0;
			      break;
			    }
			}
		      else
			{
			  finRound(mesJoueurs,buffer,"NO_ONE");
			  
			  setDessinateur(mesJoueurs);
			  if(fgets(buffer,TAILLE_BUFFER,monFichier)!=NULL)
			    {
			      int n=strlen(buffer);
			      buffer[n-1]='\0';
			      aDessiner=buffer;
			      printf(" le mot a dessiner est %s lol ",aDessiner);
			      EnvoyerRole(mesJoueurs,buffer);
			      flagTimeout=0;
			      break;
			    }
			}
		    }
		 
		    
		}
	      else
		{
		  EnvoyerMotDeviner(mesJoueurs,decouper[1],sock,0);
		  printf("incorrect le mot deviner \n");
		}
	
	
	    }
	   
	  if(strcmp(decouper[0],"TALK")==0)
	    {
	      Talk(mesJoueurs,sock,decouper[1]);
	    }

	  if(strcmp(decouper[0],"PASS")==0)
	    {
	      if(flagMotTrouver==0)
		{
		  /*personne n'a trouver alors on abondonne tranquillement */
		  finRound(mesJoueurs,buffer,"NO_ONE");
			  setDessinateur(mesJoueurs);
			  if(fgets(buffer,TAILLE_BUFFER,monFichier)!=NULL)
			    {
			      int n=strlen(buffer);
			      buffer[n-1]='\0';
			      aDessiner=buffer;
			      printf(" le mot a dessiner est %s lol ",aDessiner);
			      EnvoyerRole(mesJoueurs,buffer);
			      flagTimeout=0;
			      break;
			    }
		}
	      else 
		{
		  /*quelqu'un a deja trouver on attend la fin du timeout */
		  flagPass=1;
		}
	    }

	  if(strcmp(decouper[0],"CHEAT")==0)
	    {
	      pthread_mutex_lock(&mutex);
	      nbCheat++;
	      pthread_mutex_unlock(&mutex);
	      if(nbCheat==3)
		{
		  finRound(mesJoueurs,buffer,"NO_ONE");
		  setDessinateur(mesJoueurs);
		  if(fgets(buffer,TAILLE_BUFFER,monFichier)!=NULL)
		    {
		      int n=strlen(buffer);
		      buffer[n-1]='\0';
		      aDessiner=buffer;
		      printf(" le mot a dessiner est %s lol ",aDessiner);
		      EnvoyerRole(mesJoueurs,buffer);
		      break;
		    }
		}
	    }


	  if(strcmp(decouper[0],"SET_LINE")==0)
	    {
	      printf("il veut faire un setLine \n");
	      char *maLigne;
	      maLigne=(char *)malloc(sizeof(char *));
	      strcat(maLigne,decouper[1]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[2]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[3]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[4]);
	      /*dessin->ligne=maLigne;*/
	      EnvoyerDessin(mesJoueurs,maLigne,size,couleur);
	    }

	  if(strcmp(decouper[0],"SET_COURBE")==0)
	    {
  printf("il veut faire une courbe \n");
	      char *maLigne;
	      maLigne=(char *)malloc(sizeof(char *));
	      strcat(maLigne,decouper[1]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[2]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[3]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[4]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[5]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[6]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[7]);
	      strcat(maLigne,"/");
	      strcat(maLigne,decouper[8]);
	      EnvoyerCourbe(mesJoueurs,maLigne,size,couleur);
	      /* dessin->ligne=maLigne;
	      flagCourbe=1;
	      printf(" la courbe est  %s \n",dessin->ligne);*/
	      
	    }
	  if(strcmp(decouper[0],"SET_SIZE")==0)
	    {
	      printf("il veut definir la taille \n");
	      dessin->size=decouper[1];
		
	    }
	  if(strcmp(decouper[0],"SET_TEST")==0)
	    {
	      printf("on fait le test \n");
	    }
	  /* if(dessin->ligne!=NULL)
	    {
	      printf("le dessin est pres on l'envoi maintenant \n");
	      if(flagCourbe==1)
		{
		  EnvoyerCourbe(mesJoueurs,dessin);
		  flagCourbe=0;
		}
	      else
		{
	      EnvoyerDessin(mesJoueurs,dessin);
		}	     
	      dessin->ligne="0/0/0/0";
	
	      
	      }*/
	} 
      pthread_mutex_lock(&mutex);
      tour--;
      pthread_mutex_unlock(&mutex);
      printf("round numero %d \n",tour);

    }
}
Ejemplo n.º 3
0
TPartie* initialiser(Tparam *param){

    int i = 0, j = 0;
    int nombreBateaux = 0;
    int casesOccupeBateaux = 0;

    TPartie *partie = malloc (sizeof(TPartie));

    //On initialise le score
    partie->scorePlayer = 0;

    //=========== Initialisation / Allocation ===================

    partie->joueur = creerJoueur();
    partie->machine = creerJoueur();

    partie->grille = creerGrille(KHAUTGRILLE,KLARGGRILLE);
    partie->grilleMachine = creerGrille(KHAUTGRILLE, KLARGGRILLE);

    partie->parametres = param;

    partie->pileCoups = creerPile();

    partie->scorePlayer = 0;

    //On compte le nombre de bateaux à allouer
    nombreBateaux = getNbBat(param);

    //On alloue
    partie->joueur->mesBateaux = malloc( sizeof(TBateau*) * nombreBateaux );
    partie->machine->mesBateaux = malloc( sizeof(TBateau*) * nombreBateaux );

    //=========== Préparation ===================================

    //Préparation des bateaux

    //Création des structures et ajout des id (commencent à 0)
    for(i = 0 ; i < nombreBateaux ; i++){
        partie->joueur->mesBateaux[i] = creerBateau();
        partie->machine->mesBateaux[i] = creerBateau();

        partie->joueur->mesBateaux[i]->idBateau = i;
        partie->machine->mesBateaux[i]->idBateau = i + nombreBateaux;

        partie->joueur->mesBateaux[i]->estPlace = 0;
        partie->machine->mesBateaux[i]->estPlace = 0;
    }

    //Calcul du nombre de cases occupé par les bateaux
    //pour calculer le score
    for(i = 0 ; i < K_NBTYPEBATEAUX ; i++){
        for(j = 0 ; j < partie->parametres->nombreInstanceBateaux[j] ; j++){
            casesOccupeBateaux += i;
        }
    }

    partie->scorePlayer = KLARGGRILLE * KHAUTGRILLE + casesOccupeBateaux;

    return partie;

}