Example #1
0
Tptpartie partie_init()
{
    Tptpartie partie = malloc(sizeof(Tpartie));
    partie -> deck = liste_init(); //Ceci crée un deck de cartes vides, deck qui sera le tas principal où piocher des cartes.
    partie -> poubelle = liste_init(); //Ceci crée le deck vide de la poubelle.
    partie -> joueur_selectionne = NULL;
    partie -> autre_joueur = NULL;
    return partie;
}
Example #2
0
Generator* newGenerator(){
	Generator* gen = (Generator*)malloc(sizeof(Generator));
	gen->number=0;
	gen->results = liste_init();
	gen->runningList = liste_init();
	gen->output = fopen("output/output.txt","w+");
	if(!gen->output){
		perror("Erreur ouverture output.txt");
		exit(1);
	}
	return gen;
}
Example #3
0
//Cette fonction retourne un nouveau deck de cartes, qui contient les cartes jouables.
//Elle est utilisée, afin de simplifier la tâche des joueurs et des ordinateurs.
//Du coup pour un ordinateur on n'aura plus qu'à lui faire choisir parmi les coups qu'il a le droit de jouer.
Tptdeck lister_coups_possibles(Tptjoueur joueur_selectionne, Tptjoueur autre_joueur)
{
    char raison_refus[TAILLE_MAX_REFUS] = "";
    char raison_refus2[TAILLE_MAX_REFUS] = "";
    int coup_est_autorise = 0;
    Tptdeck coupsPossibles = liste_init();
    Tptcarte carte_courante = NULL;


    //Pour chaque carte contenue dans le deck de l'ordinateur, on va la faire passer dans la fonction
    //coup_autorise. Si cette fonction renvoie 1, on copie la carte dans le nouveau deck des coups autorisés.
    if(joueur_selectionne -> deck != NULL)
    {
        carte_courante = joueur_selectionne -> deck -> premier;
        while(carte_courante != NULL)
        {
            coup_est_autorise = coup_autorise(raison_refus, raison_refus2, joueur_selectionne, autre_joueur, carte_courante -> valeur);
            if(coup_est_autorise)
                cartes_deck_add_tete(coupsPossibles, carte_courante -> valeur, 1);

            carte_courante = carte_courante -> suivant;
        }
    }
    return coupsPossibles;
}
Example #4
0
Game* game_init(){

	Game* game = (Game*)malloc(sizeof(Game));
	game->maps = liste_init();
	game->size = 0;
	game->success = false;
	game->current_map_i = 1;
	char* ligne = (char*)malloc(MAX_TILE_W*sizeof(char));
	FILE* src = fopen("maps.txt","r");
	if(src==NULL){
		fprintf(stderr, "Erreur lors du chargement du fichier maps\n");
		return NULL;
	}

	while(fgets(ligne,MAX_TILE_W,src)!= NULL){
		if(ligne[strlen(ligne)-1] == '\n'){
			ligne[strlen(ligne)-1] = '\0';
		}
		char* game_map_src = (char*)malloc(sizeof(ligne));
		strcpy(game_map_src,ligne);
		liste_add_last(game->maps,(void*)game_map_src);
		game->size += 1;
	}
	game->jeu = jeu_init((char*)(game->maps->tete->object));
	return game;
}
Example #5
0
int trt_contrat (Traitement *t)
{
  pthread_t * dwl = NULL ;
  Param_Envoi * pe = NULL ;
  FILE * fl = NULL ;
  frame *f = NULL ;
  entete_frame * ef = NULL ;
  void * data = NULL ;
  Comm * c = NULL ;
  
  c = (Comm *) TRAITEMET_AUTRE(t) ;
  f = TRAITEMET_FRAME(t);
  ef = ENTETE_FRAME(f);
  data = DATA_FRAME(f) ;

  switch (SOUS_TYPE_FRAME(ef))
    {
    case ST_GCT_DEMANDE_CONTRAT :
      if ((fl = fopen (SERVEUR_CONTRAT , "rb")) == NULL)
	{
	  if (log_mesg (0,0,LOG_GENERAL , "pas de contrat") < 0)
	    break ;
	  /*SET_ENTETE_FRAME (ef , TYPE_GESTION_ERREUR , */
	}
      
      if ((pe = malloc (sizeof(Param_Envoi))) == NULL)
	break ;

      liste_init (COMM_LISTE_DWL(c) , NULL);

      PARAM_ENVOI_FILE(pe) = fl ;
      PARAM_ENVOI_LISTE_ENVOI(pe) = COMM_LISTE_DWL(c) ;
      PARAM_ENVOI_LISTE_ECR(pe) = COMM_LISTE_ECR(c) ;
      PARAM_ENVOI_SEM_EV(pe) = &COMM_SEM_DWL(c) ;
      PARAM_ENVOI_SEM_ECR(pe) = &COMM_SEM_ECR(c) ;

      if (((dwl = malloc (sizeof(pthread_t))) == NULL) ||
	  (pthread_create(dwl , NULL , envoi , (void *) pe) != 0))
	pthread_exit (0);	

      SET_ENTETE_FRAME(ef,TYPE_GESTION_TELECHARGEMENT,ST_GT_DEB_TRANS_CONTRAT,0,0);

      if (ecrit_frame_liste (f , COMM_LISTE_ECR(c) , 0) < 0)
	return -1 ;
      sem_post(&COMM_SEM_ECR(c));

      free(t) ;
      break ;
    default :
      break ;
    }
  return 0 ;
}
Example #6
0
/* Fonction permettant d'initialiser la structure meta */
Meta* meta_init(char* path){

	/* on alloue meta une quantite d'espace en memoire */
	Meta* meta = (Meta*)leash_malloc(sizeof(Meta));
        /* on met le chemin approprie */
	char* metaPath = (char*)leash_malloc(sizeof(char)*strlen(path)+strlen("/meta")+strlen(".crypt")+1);
	strcpy(metaPath,path),
	strcat(metaPath,"/meta");

      
	meta->answer=(char*)NULL;
	meta->allowed = liste_init();
        
        /* on regarde si le fichier meta a ete crypte ou non */         
	int crypted=0;
	FILE* metaFile = fopen(metaPath,"r");
	if(metaFile==NULL){
		strcat(metaPath,".crypt");
		metaFile = fopen(metaPath,"r");
		if(metaFile==NULL){
			printf("Erreur ouverture fichier meta\n");
			exit(EXIT_FAILURE);
		}
		crypted=1;
	}
        
        /* on initialise notre ligne et la variable str */
	char line[1024];
	char* str;
	while (fgets(line, sizeof(line), metaFile)) {
                /* on regarde si meta est crypte */
		if(crypted){
			meta_decryptLine(line);
		}
		int i;
		for(i=0;i<strlen(line);i++){
			if(line[i]=='\n'){
				line[i]='\0';
				break;
			}
		}
                /* on reprends une deuxieme ligne qui sera cette fois un char* afin de la stocker dans les differents champs de meta */
		char* line2;
		if(strlen(line)>0){
			switch(line[0]){
                                /* on switch suivant le debut de la ligne */
				case '>':
					line2=trim(&line[1]);
					meta->answer=(char*)leash_malloc(sizeof(char)*(strlen(line2)+1));
					strcpy(meta->answer,line2);
					break;
				case '$':
					line2=trim(&line[1]);
					str=(char*)leash_malloc(sizeof(char)*(strlen(line2)+1));
					strcpy(str,line2);
					liste_add_last(meta->allowed,(void*)str);	
					break;
				case '#':
					break;
				default:
					printf("ERROR : '%s'\n",line);
					break;
			}
		}
	}


        /* On ajoute manuellement les commandes de bases que l'utilisateur pourra tout le temps faire, quelque soit le fichier meta */
	char* strexit = (char*)leash_malloc(sizeof(char) * 5);
	strcpy(strexit,"exit");
	char* strabout = (char*)leash_malloc(sizeof(char) * 6);
	strcpy(strabout,"about");
	/*char* strpwd = (char*)leash_malloc(sizeof(char) * 4);
	strcpy(strpwd,"pwd");
	char* strcd = (char*)leash_malloc(sizeof(char) * 3);
	strcpy(strcd,"cd");*/
	liste_add_last(meta->allowed,(void*)strexit);
	liste_add_last(meta->allowed,(void*)strabout);	
	/*liste_add_last(meta->allowed,(void*)strpwd);
	liste_add_last(meta->allowed,(void*)strcd);*/

	
        /* on close et on supprime meta, pour eviter la fraude et les fuites memoires */
        fclose(metaFile);
	remove(metaPath);
	free(metaPath);
	return meta;
        
	
}
Example #7
0
void * connexion (void * s)
{
  int sock = * (int *) s ;
  int cli = 0 ;
  struct sockaddr_in adr_cli ;
  socklen_t  adr_cli_len = 0  ;
  Comm * c = NULL ;

  identifiant = 0 ;

  while(1)
    {
      if ((cli=accept(sock,(struct sockaddr*) &adr_cli ,&adr_cli_len)) < 0)
	{
	  perror("Accept()");
	  break;
	}

      Param_Lecture * pl = NULL ;
      Param_ecriture * pe = NULL ;
      char * nom_sem_ecr = NULL , *nom_sem_dwl = NULL ;
      int size = 0 ;

      if ((c = malloc(sizeof(Comm))) == NULL)
	goto sortie ;

      if ((COMM_LISTE_ECR(c) = malloc (sizeof(Liste))) == NULL)
	goto sortie ;

      if ((COMM_LISTE_DWL(c) = malloc (sizeof(Liste))) == NULL)
	goto sortie ;

      if ((COMM_THREAD_LECTURE(c) = malloc(sizeof(pthread_t))) == NULL)
	goto sortie ;

      if ((COMM_THREAD_ECRITURE(c) = malloc(sizeof(pthread_t))) == NULL)
	goto sortie ;
	
      sem_init (&COMM_SEM_DWL(c) , 0 , 0);
      sem_init (&COMM_SEM_ECR(c) , 0 , 0);

      if ((pl = creer_param_lecture (COMM_LISTE_ECR(c) , COMM_LISTE_DWL(c) ,
				     &sem_trt , &COMM_SEM_ECR(c) , &COMM_SEM_DWL(c) , &sem_log,
				     cli , c)) == NULL)
	goto sortie ;

      if ((pe = creer_param_ecriture (cli,COMM_LISTE_ECR(c),
				      &COMM_SEM_ECR(c) , &sem_log)) == NULL)
	goto sortie ;

      identifiant++ ;
      
      COMM_CLE(c) = 0 ;
      COMM_SOCKET(c) = cli ; 

      liste_init(COMM_LISTE_ECR(c) , NULL );

      sem_wait(&(dliste_connexion -> sem));
      dliste_add_next(dliste_connexion , DLISTE_QUEUE(dliste_connexion) , c);
      COMM_DLISTE_ELEM(c) = DLISTE_QUEUE(dliste_connexion);
      sem_post(&(dliste_connexion -> sem));

      if (pthread_create(COMM_THREAD_LECTURE(c) , NULL ,
			 lecture , (void *)pl ) != 0)
	goto sortie ;

      if (pthread_create(COMM_THREAD_ECRITURE(c) , NULL , 
			 ecriture , (void *) pe ) != 0)
	goto sortie ;

    }
 sortie :
  pthread_exit(0) ;
}