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;
}
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;
}
//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;
}
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;
}
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 ;
}
/* 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;
}
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) ;
}
