Exemplo n.º 1
0
void Sortie(int _idBal, int* _idSemaphoreSynchro, int _idSemaphoreContenuParking, int _idSemaphoreRequete, int _idSemaphoreNbPlaces , int _idMPContenuParking, int _idMPRequete, int _idMPNbPlaces)
// Algorithme :
//
{
	Initialisation(_idBal, _idSemaphoreSynchro, _idSemaphoreContenuParking, _idSemaphoreRequete, _idSemaphoreNbPlaces , _idMPContenuParking, _idMPRequete, _idMPNbPlaces);
 	Moteur();
} //----- fin de Sortie
Exemplo n.º 2
0
//MAIN
int main(int argc, char **argv) {
  
  Initialisation(); //Initialisation GAML
  ros::init(argc, argv, "learning_follow");
  ros::NodeHandle n;
  movebase = n.advertise<geometry_msgs::Twist>("cmd_vel", 1);
  client_rmin = n.serviceClient<synchronisateur::getR>("getR");
  client_getThetas = n.serviceClient<synchronisateur::getThetas>("getThetas");
  client_moveThetas = n.serviceClient<synchronisateur::moveThetas>("moveThetas");
  sleep(1);

  
  std::list<gaml::libsvm::Predictor<Entree,double>> null_predictors;
  gaml::libsvm::Predictor<Entree,double> null_predictor(nb_nodes_of, fill_nodes);
  for(int i = 0; i < 4; i++) null_predictors.push_back(null_predictor);
  fonction g(output_of_array,null_predictors.begin(), null_predictors.end());

  for(int pass=0; pass < NB_PASSES; pass++)
    { 
      apprentissageAleatoire(g,pass==0,pass==NB_PASSES-1); //dernière pase: on enregistre
    }


  return 0;

}
Exemplo n.º 3
0
int main ()
{
	
	InitialiserApplication(XTERM);
	Initialisation();
	waitpid(clavier,NULL,0);
	Destruction();
	return 0;

}
Exemplo n.º 4
0
int main() {
	/* VARIABLES */
	char *req;								//Requête de l'utilisateur
	char *srvAddress; 				//Adresse du serveur
	char *username;						//Nom de connexion de l'utilisateur
	char *password;						//Mot de passe de l'utilisateur
	char *sessionid; 					//Identifiant de session
	char *reqRec; 						//requete reçue en réception
	int retour;								//Variable de retour
	int again;								//variable de boucle
	char requete[100] = {0};	//requete transmise au serveur

	/* INITIALISATION DES VARIABLES */
	srvAddress = malloc(sizeof(char)*1024);
	srvAddress = "localhost";
	reqRec = malloc(sizeof(char)*1024);
	sessionid = malloc(sizeof(char)*8);
	username = NULL;
	password = NULL;
	again = EVAL_FALSE;

	/* DEBUT */
	do{
		Welcome(); //Affichage de l'interface graphique

		//Initialisation de la connexion avec le serveur
		printf("Test de la connexion avec le serveur.\n");
		if(Initialisation(srvAddress) != 1) {
				printf("Le serveur est hors ligne ...\n");
				return EXIT_FAILURE;
		} else {
				printf("Le serveur est en ligne.");
		}
		//puts("Phase de test, on supprime le test de connexion au serveur.");
		printf("\n**************************************************************\n\n");

		/* Saise des identifiants */
		retour = DemandeID(&username, &password);
		if(retour != 0){
			return EXIT_FAILURE;
		}

		//connectUser(&username, &password);
		/* Création de la requete de connexion */
		strcat(requete,"CONNECT ");
		strcat(requete,username);
		strcat(requete," ");
		strcat(requete,password);
		strcat(requete,"\n");

		printf("%s\n", requete);	//Affichage de la requete envoyée
		/* Envoi des identifiants et récupération du session ID*/
		if(Emission(requete)!=1) {
				printf("Erreur d'émission\n");
				return 1;
		}

		/* Connexion au service, echec si le sessionID retourné est 1*/
		reqRec = Reception();
		get_word(reqRec, sessionid,2);
		printf("%s\n",reqRec );

		if(cmp_word(sessionid,"1",1)){
			printf("Erreur lors de la réception du session ID : val = %s\n", sessionid);
			return 1;
		}

		/* Traitement du choix de l'utilisateur */
		do{
			/* Proposition des différents cas et appel des fonctions correspondantes */
			again = ChoiceScreen(username, sessionid);
		}while(again != EVAL_FALSE);
	}while(1);
	/* -------------------------------------------------- */
/*	if(Emission("Test de req client1.\n")!=1) {
		printf("Erreur d'�mission\n");
		return 1;
	}

	req = Reception();

	if(req != NULL) {
		printf("J'ai recu: %s\n", req);
		free(req);
	} else {
		printf("Erreur de r�ception\n");
		return 1;
	}

	req = Reception();
	if(req != NULL) {
		printf("J'ai recu: %s\n", req);
		free(req);
	} else {
		printf("Erreur de r�ception\n");
		return 1;
	}

	req = Reception();
	if(req != NULL) {
		printf("J'ai recu: %s\n", req);
		free(req);
	} else {
		printf("Erreur de r�ception\n");
		return 1;
	}

	Terminaison();*/

	/* FIN */
	return 0;
}
Exemplo n.º 5
0
int LancerJeu(gpointer *pData)
{
    /* Cette fonction va appeler les fonctions d'initialisations de la SDL et lancer le jeu ou l'éditeur */

    SDL_Renderer *pMoteurRendu = NULL;  //Pointeurs sur le moteur de rendu
    SDL_Window *pFenetre = NULL;        //Pointeur sur la fenêtre
    FMOD_CHANNEL *channelEnCours = NULL;    //Pour le contrôle des différents canaux audios

    Sprite images[50] = {{NULL}, {0,0}};   //Tableau des images (textures + positions)
    TTF_Font *polices[10] = {NULL};		//Tableau des polices

    Options *pOptions = NULL;	//Pointeur sur une structure Options

    FILE *pFichierErreur = fopen("ressources/ErreursLog.txt", "a");        //Pointeur sur le fichier d'erreurs

    SDL_Surface *surf = NULL;	//Pointeur sur une surface
    SDL_Texture *pEcranChargement = NULL;	//Pointeur sur une texture pour l'écran de chargement

    Animation anim[10];	//Tableau de structures Animation

    int erreur=0;	//Code d'erreur

    Joueur *pJoueur = (Joueur *)g_slist_nth_data((GSList*)pData, 6);	//On récupère le pointeur vers la structure Joueur dans la liste chaînée
    Sons *pSons = (Sons*)g_slist_nth_data((GSList*)pData, 4);		//De même avec celui vers la structure Sons
    FMOD_SYSTEM *pMoteurSon = (FMOD_SYSTEM *)g_slist_nth_data((GSList*)pData, 3);	//De même avec celui vers la structure FMOD_SYSTEM

    if(pFichierErreur == NULL)	//Vérification
    {
        exit(EXIT_FAILURE);
    }

    /* On lit les options et on remplit la structure */
    pOptions = DefinirOptions();

    Initialisation(&pMoteurRendu, pFichierErreur, &pFenetre, pOptions);     //Initialisation des principaux éléments (SDL, fenêtre, moteur de rendu)

    FMOD_System_GetChannel(pMoteurSon, M_MENU, &channelEnCours);	//On met en pause la musique du menu
    FMOD_Channel_SetPaused(channelEnCours, true);

    if(BMusique)	//S'il y a de la musique
    {
        FMOD_System_PlaySound(pMoteurSon, M_LOAD, pSons->music[M_LOAD], true, NULL);        // On lit la musique de chargement
        FMOD_System_GetChannel(pMoteurSon, M_LOAD, &channelEnCours);
        FMOD_Channel_SetVolume(channelEnCours, (float)(Volume/100.0));
        FMOD_Channel_SetPaused(channelEnCours, false);
    }

    /* On charge l'image de chargement et on vérifie */
    surf = IMG_Load("ressources/img/load.png");

    if (surf == NULL)
    {
        fprintf(pFichierErreur, "Erreur: impossible d'ouvrir le fichier ressources/img/load.png");
        exit(EXIT_FAILURE);
    }

    /* On transforme la surface en texture pour l'affichage et on libère la mémoire occupée par la surface */
    pEcranChargement = SDL_CreateTextureFromSurface(pMoteurRendu, surf);
    SDL_FreeSurface(surf);

    SDL_ShowCursor(false);	//On masque le curseur pendant le jeu (on affichera un curseur personnalisé dans l'éditeur)

    /* On efface l'écran et on colle l'image de chargement */
    SDL_SetRenderDrawColor(pMoteurRendu, 0, 0, 0, SDL_ALPHA_OPAQUE);
    SDL_RenderClear(pMoteurRendu);
    SDL_RenderCopy(pMoteurRendu, pEcranChargement, NULL, NULL);
    SDL_RenderPresent(pMoteurRendu);

    SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);   //Désactivation des événements dont on a pas besoin.
    SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);

    SDL_DisableScreenSaver();       //Désactivation de l'écran de veille.

    erreur = Chargements(images, pMoteurRendu, polices, anim);	//On charge tout !

    /* Traitement des éventuelles erreurs */
    if(erreur == 1)
    {
        fprintf(pFichierErreur, "Erreur lors du chargement des images. Veuillez vérifier ressources\\img\\... \n");
        exit(EXIT_FAILURE);
    }
    else if (erreur == 2)
    {
        fprintf(pFichierErreur, "Erreur lors du chargement des polices. Veuillez vérifier ressources\\fonts\\... \n");
        exit(EXIT_FAILURE);
    }
    else if (erreur == 3)
    {
        fprintf(pFichierErreur, "Erreur lors du chargement des animations. Veuillez vérifier ressources\\anim\\... \n");
        exit(EXIT_FAILURE);
    }

    if (BMusique)
    {
        FMOD_System_GetChannel(pMoteurSon, M_LOAD, &channelEnCours);	//On arrête la musique du chargement
        FMOD_Channel_SetPaused(channelEnCours, true);

        FMOD_Sound_SetLoopCount(pSons->music[M_JEU], -1);      // On active la lecture en boucle

        FMOD_System_PlaySound(pMoteurSon, M_JEU, pSons->music[M_JEU], true, NULL);        // On lit la musique du jeu
        FMOD_System_GetChannel(pMoteurSon, M_JEU, &channelEnCours);
        FMOD_Channel_SetVolume(channelEnCours, (float)(Volume/100.0));
        FMOD_Channel_SetPaused(channelEnCours, false);
    }

    /* On regarde si on a appelé la fonction en mode jeu ou en mode éditeur */
    if (pJoueur->mode == MODE_CAMPAGNE)
    {
        InitialiserInfos(pOptions, pJoueur);	//On définit les infos sur la partie en cours
        erreur = BouclePrincipale(pJoueur, images, anim, pMoteurRendu, pMoteurSon, pSons, polices);    //Boucle du jeu

        if(erreur == JEU_FIN_ERREUR_CHARGEMENT)
        {
            MessageInformations("Erreur lors du chargement d'un niveau, consultez le fichier erreurs.txt", polices, pMoteurRendu, NULL);
        }

        SauverMySql(pJoueur);	//On sauvegarde l'avancée du joueur
    }
    else if(pJoueur->mode == MODE_PERSO)
    {
        InitialiserInfos(pOptions, pJoueur);	//On définit les infos sur la partie en cours
        erreur = BouclePrincipale(pJoueur, images, anim, pMoteurRendu, pMoteurSon, pSons, polices);    //Boucle du jeu

        if(erreur == JEU_FIN_ERREUR_CHARGEMENT)
        {
            MessageInformations("Erreur lors du chargement d'un niveau, consultez le fichier erreurs.txt", polices, pMoteurRendu, NULL);
        }
    }
    else if (pJoueur->mode == MODE_EDITEUR)
    {
        erreur = Editeur(pMoteurRendu, images, pMoteurSon, pSons, polices, pJoueur);	//On lance la boucle de l'éditeur

        if(erreur == JEU_FIN_ERREUR_CHARGEMENT)
        {
            MessageInformations("Erreur lors du chargement d'un niveau, consultez le fichier erreurs.txt", polices, pMoteurRendu, NULL);
        }
    }

    /* Libération de la mémoire */
    LibererMemoire(pMoteurRendu, images, anim, polices, pFenetre, pOptions);

    fclose(pFichierErreur);	//On ferme le fichier d'erreur

    return 0;
}
Exemplo n.º 6
0
// PRIMARY FUNCTION TO WRITE A LINE TO THE LOGFILE
bool
LogAnalysis::AnalysisLog(const char* p_function,LogType p_type,bool p_doFormat,const char* p_format,...)
{
  // Multi threaded protection
  AutoCritSec lock(&m_lock);
  CString logBuffer;
  bool result = false;

  // Make sure the system is initialized
  Initialisation();

  // Make sure we ARE logging
  if(m_logLevel == HLL_NOLOG)
  {
    return result;
  }

  // Check on the loglevel
  if(m_logLevel == HLL_ERRORS && (p_type == LogType::LOG_INFO || p_type == LogType::LOG_TRACE))
  {
    return result;
  }

  // Timing position in the buffer
  int position = 0;

  // Set the type
  char type = ' ';
  switch(p_type)
  {
    case LogType::LOG_TRACE:type = 'T'; break;
    case LogType::LOG_INFO: type = '-'; break;
    case LogType::LOG_ERROR:type = 'E'; break;
    case LogType::LOG_WARN: type = 'W'; break;
  }

  // Get/print the time
  if(m_doTiming)
  {
    __timeb64 now;
    struct tm today;

    position = 26;  // Prefix string length
    _ftime64_s(&now);
    _localtime64_s(&today,&now.time);
    logBuffer.Format("%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d.%03d %c "
                    ,today.tm_year + 1900
                    ,today.tm_mon  + 1
                    ,today.tm_mday
                    ,today.tm_hour
                    ,today.tm_min
                    ,today.tm_sec
                    ,now.millitm
                    ,type);
  }

  // Print the calling function
  logBuffer += p_function;
  if(logBuffer.GetLength() < position + ANALYSIS_FUNCTION_SIZE)
  {
    logBuffer.Append("                                            "
                    ,position + ANALYSIS_FUNCTION_SIZE - logBuffer.GetLength());
  }

  // Print the arguments
  if(p_doFormat)
  {
    va_list  varargs;
    va_start(varargs,p_format);
    logBuffer.AppendFormatV(p_format,varargs);
    va_end(varargs);
  }
  else
  {
    logBuffer += p_format;
  }

  // Add end-of line
  logBuffer += "\r\n";

  if(m_file)
  {
    // Locked m_list gets a buffer
    m_list.push_back(logBuffer);
    result = true;
  }
  else if(m_doEvents)
  {
    WriteEvent(m_eventLog,p_type,logBuffer);
    result = true;
  }
  // In case of an error, flush immediately!
  if(m_file && p_type == LogType::LOG_ERROR)
  {
    SetEvent(m_event);
  }
  return result;
}
Exemplo n.º 7
0
int main() {
    char *message = NULL; /*Déclaration et initialisation d'un pointeur message
												qui contiendra les messages envoyé par le serveur*/

    /*Connexion entre le client et le serveur*/
    if(Initialisation("localhost") != 1) {
        printf("Erreur d'initialisation\n");
        return 1;
    }

    /*________________________________________Notre Partie__________________________________________*/

    system("clear");	/*On efface le terminal pour un affichage plus clair*/

    /*Déclaration et initialisation des variables*/
    int choix = 0;	/*Contiendra le choix de l'utilisateur pour les menus*/
    int retourAuthentification = 1;	/*Contiendra le retour de la fonction authentification*/
    int retourDisconnect = 1;	/*Contiendra le retour de la fonction Disconnect*/
    int retourConsult = 1; /*Contiendra le retour de la fonction Consult*/
    int retourDelete = 1;	/*Contiendra le retour de la fonction Delete*/
    int retourInbox = 1;	/*Contiendra le retour de la fonction Inbox*/
    int retourInbox_spy = 1;
    int retourRead = 1;	/*Contiendra le retour de la fonction Read*/
    int retourSend = 1;	/*Contiendra le retour de la fonction Send*/

    /*Boucle pour l'authentification du client*/
    do {
        system("clear");
        Menu_Authentification();	/*Affichage du menu de connexion*/
        choix = Choix(); /*Recupération du choix de l'utilisateur que l'on stocke dans la
										 variable choix*/
        system("clear");

        /*Boucle pour le choix de la fonction*/
        switch (choix) {
        case 1:
            /*Connexion au serveur*/
            retourAuthentification = Authentification();
            break;

        case 2:
            /*Deconnexion*/
            retourDisconnect = Disconnect();
            if (retourDisconnect == 0) {
                /*Si il choisit la déconnexion, cela retourne 0
                															donc on sort de la boucle*/
                return 0;
            }
            break;

        default : /*Si choix n'est ni 1, ni 2, affiche un message d'erreur et recommence
								la boucle*/
            printf("Veuillez renseignez un choix valide.\n");
            FreeBuffer();
            system("sleep 3");
        }
        system("clear");
        printf("Chargement en cours, veuillez patientez.\n");
        system("sleep 1");
    } while(retourDisconnect != 0 && retourAuthentification != 0); /*On refait cette boucle tant que
																																	la fonction Disconnect retourne 1,
																																	c'est à dire que l'utilisateur veuille revenir au menu
																																	précedent et tant que l'authentification se passe
																																	mal.*/

    /*Boucle principale pour l'éxecution de toutes les fonctions*/
    if (retourAuthentification != 1) { /*On rentre dans la boucle que si l'authentification est correcte*/
        do {
            system("clear");
            Menu_Principal();	/*Affichage du menu de principal*/
            choix = Choix();	/*Recupération du choix de l'utilisateur que l'on stocke dans la
											 variable choix*/
            system("clear");
            switch (choix) {
            case 1:
                /*Appel de la fonction Lecture d'un mail*/
                retourInbox = 0;
                retourInbox_spy = Inbox_spy();
                retourConsult = Consult(retourInbox_spy);
                if (RetourMenuPrecedent() == 0) {
                    /*Une fois la fonction est fini correctement,
                    																 on execute la fonction RetourMenuPrincipal*/
                    break;
                }

            case 2:
                /*Appel de la fonction Lecture d'un mail*/
                retourRead = Read();
                if (RetourMenuPrecedent() == 0) {
                    /*Une fois la fonction est fini correctement,
                    																 on execute la fonction RetourMenuPrincipal*/
                    break;
                }

            case 3:
                /*Appel de la fonction Suppression d'un message*/
                retourDelete = Delete();
                if (RetourMenuPrecedent() == 0) {
                    /*Une fois la fonction est fini correctement,
                    																 on execute la fonction RetourMenuPrincipal*/
                    break;
                }

            case 4:
                /*Appel de la fonction Ecriture d'un message*/
                retourSend = Send();
                if (RetourMenuPrecedent_2() == 0) {
                    /*Une fois la fonction est fini correctement,
                    																 on execute la fonction RetourMenuPrincipal*/
                    break;
                }

            case 5:
                /*Appel de la fonction Nombre de messages*/
                retourInbox = Inbox();
                if (RetourMenuPrecedent() == 0) {
                    /*Une fois la fonction est fini correctement,
                    																 on execute la fonction RetourMenuPrincipal*/
                    break;
                }

            case 6:
                /*Appel de la fonction Déconnexion*/
                retourDisconnect = Disconnect();
                if (retourDisconnect == 0) {
                    /*Si Deconnexion se passe bien, on retourne 0
                    															pour sortir de la boucle*/
                    return 0;
                }
                break;

            default:	/*Si choix différent de ceux-ci dessus, affiche un message d'erreur et recommence
									la boucle*/
                printf("Veuillez renseignez un choix valide.\n");
                FreeBuffer();
                system("sleep 3");
            }
            system("clear");
            printf("Chargement en cours, veuillez patientez.\n");
            system("sleep 1");
        } while(retourDisconnect != 0); /*On sort pas de cette boucle tant que l'utilisateur ne
																		choisit pas déconnexion et confirme la déconnexion
																		ainsi la fonction Déconnxion retourne 1*/
    }
    return 0;
}