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
//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;
}
int main ()
{
InitialiserApplication(XTERM);
Initialisation();
waitpid(clavier,NULL,0);
Destruction();
return 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;
}
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;
}
// 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;
}
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;
}
